clean_experiment_group0.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "4eSGpTsuzVdx"
   },
   "outputs": [],
   "source": [
    "# TODO:\n",
    "# Interesting examples to pull out (preds are different btwn CFQI and FQI) \n",
    "#install jax with \n",
    "# exit()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "id": "Fx1QSY2pzVd1"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/licensed/anaconda3/2021.11/lib/python3.9/site-packages/scipy/__init__.py:146: UserWarning: A NumPy version >=1.16.5 and <1.23.0 is required for this version of SciPy (detected version 1.24.2\n",
      "  warnings.warn(f\"A NumPy version >={np_minversion} and <{np_maxversion}\"\n"
     ]
    }
   ],
   "source": [
    "import json\n",
    "import sys\n",
    "import jax.numpy as jnp\n",
    "import seaborn as sns\n",
    "import tqdm\n",
    "import matplotlib.pyplot as plt \n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.optim as optim\n",
    "from sklearn.ensemble import ExtraTreesRegressor, ExtraTreesClassifier\n",
    "from lightgbm import LGBMRegressor, LGBMClassifier\n",
    "import itertools\n",
    "import pandas as pd\n",
    "import pickle\n",
    "import math\n",
    "import torch \n",
    "import torch.optim as optim\n",
    "from sklearn.metrics import mean_squared_error\n",
    "import jax.random as random\n",
    "from typing import List, Tuple\n",
    "import gym\n",
    "from sklearn.model_selection import train_test_split\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "import pickle\n",
    "from agents import NFQAgent\n",
    "from networks import NFQNetwork\n",
    "import os\n",
    "platform = 'local' ## Change this to local when using your local computer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from multigroupGP import GP, MultiGroupRBF, RBF\n",
    "from sklearn.gaussian_process import GaussianProcessRegressor\n",
    "from sklearn.gaussian_process.kernels import DotProduct, WhiteKernel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_path = 'mimic_iv/'\n",
    "group0_test_Ktuples = pickle.load(open(data_path + 'group_0_GroupedtestKtuples.pkl', 'rb'))\n",
    "group0_train_Ktuples  = pickle.load(open(data_path + 'group_0_GroupedtrainKtuples.pkl', 'rb'))\n",
    "group1_test_Ktuples  = pickle.load(open(data_path + 'group_1_GroupedtestKtuples.pkl', 'rb'))\n",
    "group1_train_Ktuples = pickle.load(open(data_path + 'group_1_GroupedtrainKtuples.pkl', 'rb'))\n",
    "group2_test_Ktuples  = pickle.load(open(data_path + 'group_2_GroupedtestKtuples.pkl', 'rb'))\n",
    "group2_train_Ktuples = pickle.load(open(data_path + 'group_2_GroupedtrainKtuples.pkl', 'rb'))\n",
    "group3_test_Ktuples  = pickle.load(open(data_path + 'group_3_GroupedtestKtuples.pkl', 'rb'))\n",
    "group3_train_Ktuples = pickle.load(open(data_path + 'group_3_GroupedtrainKtuples.pkl', 'rb'))\n",
    "group4_test_Ktuples  = pickle.load(open(data_path + 'group_4_GroupedtestKtuples.pkl', 'rb'))\n",
    "group4_train_Ktuples = pickle.load(open(data_path + 'group_4_GroupedtrainKtuples.pkl', 'rb'))\n",
    "group5_test_Ktuples  = pickle.load(open(data_path + 'group_5_GroupedtestKtuples.pkl', 'rb'))\n",
    "group5_train_Ktuples = pickle.load(open(data_path + 'group_5_GroupedtrainKtuples.pkl', 'rb'))\n",
    "group6_test_Ktuples  = pickle.load(open(data_path + 'group_6_GroupedtestKtuples.pkl', 'rb'))\n",
    "group6_train_Ktuples = pickle.load(open(data_path + 'group_6_GroupedtrainKtuples.pkl', 'rb'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "id": "ylvMe5fdzVd-"
   },
   "outputs": [],
   "source": [
    "def generate_rollout(vnum, tuples, group=0):\n",
    "    trajectory = []\n",
    "    for i in range(len(tuples['vnum'])):\n",
    "        vn = tuples['vnum'][i]\n",
    "        if str(vn) == str(vnum):\n",
    "            s = tuples['s'][i]\n",
    "            a = tuples['a'][i]\n",
    "            if sum(a) > 1:\n",
    "                pass\n",
    "            a = np.where(a==1)[0][0]\n",
    "            if a == 0:\n",
    "                a = [0, 0]\n",
    "            elif a in [1, 2, 3, 7, 8]:\n",
    "                a = [0, 10]\n",
    "            else:\n",
    "                a = [10, 0]\n",
    "            ns = tuples['ns'][i]\n",
    "            r = tuples['r'][i]\n",
    "            \n",
    "            trajectory.append((s, a, r, ns, False, group))\n",
    "    \n",
    "    last_tuple = trajectory[-1]\n",
    "    new_last_tuple = (last_tuple[0], last_tuple[1], last_tuple[2], last_tuple[3], True, group)\n",
    "    trajectory = trajectory[:-1]\n",
    "    trajectory.append(new_last_tuple)\n",
    "    return trajectory\n",
    "\n",
    "def rollout_dataset(ds='train', env='g0', init_experience=10):\n",
    "    groups = {'g0': group0_train_Ktuples, 'g1': group1_train_Ktuples, 'g2': group2_train_Ktuples, 'g3': group3_train_Ktuples, 'g4': group4_train_Ktuples, 'g5': group5_train_Ktuples, 'g6': group6_train_Ktuples}\n",
    "    if ds == 'test':\n",
    "        groups = {'g0': group0_test_Ktuples, 'g1': group1_test_Ktuples, 'g2': group2_test_Ktuples, 'g3': group3_test_Ktuples, 'g4': group4_test_Ktuples, 'g5': group5_test_Ktuples, 'g6': group6_test_Ktuples}\n",
    "    rollout = []\n",
    "    for vnum in groups[env]['vnum'][:init_experience]:\n",
    "        traj = generate_rollout(vnum, groups[env], group=int(env[1]))\n",
    "        rollout.extend(traj)\n",
    "    return rollout\n",
    "\n",
    "def normalize_rollouts(rollouts):\n",
    "    min_r = min([r[2] for r in rollouts])\n",
    "    max_r = max([r[2] for r in rollouts])\n",
    "    new_rollout = []\n",
    "    for r in rollouts:\n",
    "        new_reward = (r[2] - min_r)/(max_r - min_r)\n",
    "        new_rollout.append((r[0], r[1], new_reward, r[3], r[4], r[5]))\n",
    "    \n",
    "    sns.distplot([r[2] for r in new_rollout])\n",
    "    return new_rollout"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "id": "D7d04gfFzVd_"
   },
   "outputs": [],
   "source": [
    "# is_contrastive=True\n",
    "# verbose = True\n",
    "# init_experience = 100\n",
    "# # A set of transition tuples. Male is background, female is foreground. \n",
    "# # bg_rollouts = rollout_dataset(ds='train', env='bg', init_experience=init_experience)\n",
    "# # fg_rollouts = rollout_dataset(ds='train', env='fg', init_experience=init_experience)\n",
    "# g0_rollouts = rollout_dataset(ds='train', env='g0', init_experience=init_experience)\n",
    "# g1_rollouts = rollout_dataset(ds='train', env='g1', init_experience=init_experience)\n",
    "# g2_rollouts = rollout_dataset(ds='train', env='g2', init_experience=init_experience)\n",
    "# g3_rollouts = rollout_dataset(ds='train', env='g3', init_experience=init_experience)\n",
    "# g4_rollouts = rollout_dataset(ds='train', env='g4', init_experience=init_experience)\n",
    "# g5_rollouts = rollout_dataset(ds='train', env='g5', init_experience=init_experience)\n",
    "# g6_rollouts = rollout_dataset(ds='train', env='g6', init_experience=init_experience)\n",
    "\n",
    "# g0_rollouts.extend(g1_rollouts)\n",
    "# g0_rollouts.extend(g2_rollouts)\n",
    "# g0_rollouts.extend(g3_rollouts)\n",
    "# g0_rollouts.extend(g4_rollouts)\n",
    "# g0_rollouts.extend(g5_rollouts)\n",
    "# g0_rollouts.extend(g6_rollouts)\n",
    "\n",
    "# all_rollouts = g0_rollouts.copy()\n",
    "# all_rollouts = normalize_rollouts(all_rollouts)\n",
    "# pickle.dump(all_rollouts, open(data_path + '/mimic_iv/all_rollouts.pkl', 'wb'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# load all rollouts\n",
    "all_rollouts = pickle.load(open(data_path + 'all_rollouts.pkl', 'rb'))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(all_rollouts[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Agent:\n",
    "    def __init__(self, nfq_net: nn.Module, optimizer: optim.Optimizer, random_seed: int = 0,\n",
    "                    dir: str = \"model\", mode: str = \"nfq\", verbose: bool = False):\n",
    "        \"\"\"\n",
    "        :param nfq_net: NFQ network\n",
    "        :param optimizer: optimizer\n",
    "        :param random_seed: random seed\n",
    "        :param dir: directory to save the model\n",
    "        :param mode: either \"nfq\" or \"mggp\"\n",
    "        :param verbose: verbose\n",
    "        \"\"\"\n",
    "        self.nfq_net = nfq_net\n",
    "        self.optimizer = optimizer\n",
    "        self.random_seed = random_seed\n",
    "        self.dir = dir\n",
    "        self.mode = mode\n",
    "        self.verbose = verbose\n",
    "        self.trained = False\n",
    "        if self.mode == \"mggp\":\n",
    "            self.RANDOM_SEED = 0\n",
    "            self.key = random.PRNGKey(self.RANDOM_SEED)\n",
    "            self.kernel = MultiGroupRBF()\n",
    "            self.gp_q_est = GP(self.kernel, key = self.key, is_mggp=True)\n",
    "        elif self.mode == \"gp\":\n",
    "            self.RANDOM_SEED = 0\n",
    "            self.kernel = DotProduct() + WhiteKernel()\n",
    "            self.gp_q_est = GaussianProcessRegressor(kernel=self.kernel, alpha=1e-10, \n",
    "                                    n_restarts_optimizer=10, random_state=self.RANDOM_SEED)\n",
    "        \n",
    "    def get_best_action(self, obs: np.ndarray, unique_actions: np.ndarray, group: np.ndarray) -> int:\n",
    "        \"\"\"\n",
    "        :param obs: observation\n",
    "        :param unique_actions: unique actions\n",
    "        :param group: group\n",
    "        :return: best action\n",
    "        \"\"\"\n",
    "        q_list = np.zeros(len(unique_actions))\n",
    "        if self.mode == \"nfq\":\n",
    "            for ii, action in enumerate(unique_actions):\n",
    "                q = self.nfq_net(\n",
    "            torch.cat([torch.FloatTensor(obs), torch.FloatTensor(action)], dim=0))\n",
    "                q_list[ii] = q\n",
    "        elif self.mode == \"mggp\":\n",
    "            if self.trained:\n",
    "                obs = jnp.array(obs)\n",
    "                for ii, action in enumerate(unique_actions):\n",
    "                    x = jnp.concatenate([obs, action])\n",
    "                    x = x.reshape(1, -1)\n",
    "                    q = self.gp_q_est.predict(x, group)\n",
    "                    q_list[ii] = q\n",
    "            else:\n",
    "                raise ValueError(\"Model not trained yet!\")\n",
    "        elif self.mode == \"gp\":\n",
    "            if self.trained:\n",
    "                obs = np.array(obs)\n",
    "                for ii, action in enumerate(unique_actions):\n",
    "                    x = np.concatenate([obs, action])\n",
    "                    x = x.reshape(1, -1)\n",
    "                    q = self.gp_q_est.predict(x)\n",
    "                    q_list[ii] = q\n",
    "            else:\n",
    "                raise ValueError(\"Model not trained yet!\")\n",
    "        return unique_actions[np.argmin(q_list)]\n",
    "\n",
    "    def train(self, pattern_set: tuple) -> float:\n",
    "        if self.mode == \"nfq\":\n",
    "            state_action_b, target_q_values, group_b = pattern_set\n",
    "            predicted_q_values = self.nfq_net(state_action_b).squeeze()\n",
    "            loss = torch.nn.functional.mse_loss(predicted_q_values, target_q_values)\n",
    "            self.optimizer.zero_grad()\n",
    "            loss.backward()\n",
    "            self.optimizer.step()\n",
    "        \n",
    "        elif self.mode == \"mggp\":\n",
    "            x, y, group = pattern_set\n",
    "            x, y, group = jnp.array(x), jnp.array(y), jnp.array(group)\n",
    "            x_train, x_test, y_train, y_test, group_train, group_test = train_test_split(x, y, group, test_size=0.05, random_state=self.RANDOM_SEED)\n",
    "            x_test, _ , y_test, _ , group_test, _ = train_test_split(x_test, y_test, group_test, test_size=0.05, random_state=self.RANDOM_SEED)\n",
    "            self.gp_q_est.fit(x_train, y_train, group_train)\n",
    "            loss = mean_squared_error(y_test, self.gp_q_est.predict(x_test, group_test))\n",
    "            self.trained = True\n",
    "\n",
    "        elif self.mode == \"gp\":\n",
    "            x, y, _ = pattern_set\n",
    "            x, y = np.array(x), np.array(y)\n",
    "            x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.05, random_state=self.RANDOM_SEED)\n",
    "            x_test, _ , y_test, _ = train_test_split(x_test, y_test, test_size=0.05, random_state=self.RANDOM_SEED)\n",
    "            self.gp_q_est.fit(x_train, y_train)\n",
    "            loss = mean_squared_error(y_test, self.gp_q_est.predict(x_test))\n",
    "            self.trained = True\n",
    "\n",
    "        return loss\n",
    "\n",
    "    def save_model(self):\n",
    "        if not os.path.exists(self.dir):\n",
    "            os.makedirs(self.dir)\n",
    "        if self.mode == \"nfq\":\n",
    "            torch.save(self.nfq_net.state_dict(), self.dir + \"/nfq_net.pt\")\n",
    "        elif self.mode == \"mggp\":\n",
    "            pickle.dump(self.gp_q_est, open(self.dir + \"/mggp_net.pkl\", \"wb\"))\n",
    "        elif self.mode == \"gp\":\n",
    "            pickle.dump(self.gp_q_est, open(self.dir + \"/gp_net.pkl\", \"wb\"))\n",
    "\n",
    "    def load_model(self):\n",
    "        if self.mode == \"nfq\":\n",
    "            self.nfq_net.load_state_dict(torch.load(self.dir + \"/nfq_net.pt\"))\n",
    "        elif self.mode == \"mggp\":\n",
    "            self.gp_q_est = pickle.load(open(self.dir + \"/mggp_net.pkl\", \"rb\"))\n",
    "            self.trained = True\n",
    "        elif self.mode == \"gp\":\n",
    "            self.gp_q_est = pickle.load(open(self.dir + \"/gp_net.pkl\", \"rb\"))\n",
    "            self.trained = True\n",
    "\n",
    "    def generate_pattern_set(self, rollouts, gamma: float = 0.95, mode=\"nfq\"):\n",
    "        \"\"\"\n",
    "        Generate pattern set from rollouts\n",
    "        \"\"\"\n",
    "        state_b, action_b, reward_b, next_state_b, done_b, group_b = zip(*rollouts)\n",
    "        if self.mode == \"nfq\":\n",
    "            state_b = torch.FloatTensor(state_b)\n",
    "            action_b = torch.FloatTensor(action_b)\n",
    "            cost_b = torch.FloatTensor(reward_b)\n",
    "            next_state_b = torch.FloatTensor(next_state_b)\n",
    "            done_b = torch.FloatTensor(done_b)\n",
    "            group_b = torch.LongTensor(group_b)\n",
    "            state_action_b = torch.cat([state_b, action_b], dim=1)\n",
    "            group_b = group_b.resize(len(group_b), 1)\n",
    "\n",
    "            next_state_left = torch.cat([next_state_b, torch.zeros(len(rollouts), 1), group_b], 1)\n",
    "            next_state_right = torch.cat([next_state_b, torch.ones(len(rollouts), 1), group_b], 1)\n",
    "\n",
    "            q_next_state_left_b = self.nfq_net(next_state_left).squeeze()\n",
    "            q_next_state_right_b = self.nfq_net(next_state_right).squeeze()\n",
    "            q_next_state_b = torch.min(q_next_state_left_b, q_next_state_right_b)\n",
    "            \n",
    "            with torch.no_grad():\n",
    "                target_q_values = cost_b + gamma * q_next_state_b * (1 - done_b)\n",
    "        \n",
    "        elif self.mode == \"mggp\":\n",
    "            state_b = jnp.array(state_b)\n",
    "            action_b = jnp.array(action_b)\n",
    "            cost_b = jnp.array(cost_b)\n",
    "            next_state_b = jnp.array(next_state_b)\n",
    "            done_b = jnp.array(done_b)\n",
    "            group_b = jnp.array(group_b)\n",
    "            state_action_b = jnp.column_stack([state_b, action_b])\n",
    "            q_values = jnp.zeros(3)\n",
    "            for i in range(3):\n",
    "                q_next_state = self.gp_q_est.predict(jnp.append(state_b, action_b), group_test = group_b)\n",
    "                q_values[i] = q_next_state\n",
    "            \n",
    "            q_next_state_b = jnp.min(q_values)\n",
    "\n",
    "            target_q_values = cost_b + gamma * q_next_state_b * (1 - done_b)\n",
    "\n",
    "        elif self.mode == \"gp\":\n",
    "            state_b = jnp.array(state_b)\n",
    "            action_b = jnp.array(action_b)\n",
    "            cost_b = jnp.array(cost_b)\n",
    "            next_state_b = jnp.array(next_state_b)\n",
    "            done_b = jnp.array(done_b)\n",
    "            group_b = jnp.array(group_b)\n",
    "            state_action_b = jnp.column_stack([state_b, action_b])       \n",
    "            q_values = jnp.zeros(3)\n",
    "            for i in range(3):\n",
    "                q_next_state = self.gp_q_est.predict(jnp.append(state_b, action_b))\n",
    "                q_values[i] = q_next_state\n",
    "            \n",
    "            q_next_state_b = jnp.min(q_values)\n",
    "\n",
    "            target_q_values = cost_b + gamma * q_next_state_b * (1 - done_b)\n",
    "\n",
    "        return state_action_b, target_q_values, group_b\n",
    "\n",
    "    def get_action(self, state, group, mode=\"nfq\"):\n",
    "        \"\"\"\n",
    "        Get action from state\n",
    "        \"\"\"\n",
    "        if mode == \"nfq\":\n",
    "            state = torch.FloatTensor(state)\n",
    "            group = torch.LongTensor(group)\n",
    "            group = group.resize(1, 1)\n",
    "            state_left = torch.cat([state, torch.zeros(1, 1), group], 1)\n",
    "            state_right = torch.cat([state, torch.ones(1, 1), group], 1)\n",
    "            q_left = self.nfq_net(state_left, group).squeeze()\n",
    "            q_right = self.nfq_net(state_right, group).squeeze()\n",
    "            action = torch.argmax(torch.cat([q_left, q_right], dim=0))\n",
    "        elif mode == \"mggp\":\n",
    "            state = jnp.array(state)\n",
    "            group = jnp.array(group)\n",
    "            q_values = jnp.zeros(3)\n",
    "            for i in range(3):\n",
    "                q_values[i] = self.gp_q_est.predict(jnp.append(state, i), group_test = group)\n",
    "            action = jnp.argmin(q_values)\n",
    "        elif mode == \"gp\":\n",
    "            state = jnp.array(state)\n",
    "            group = jnp.array(group)\n",
    "            q_values = jnp.zeros(3)\n",
    "            for i in range(3):\n",
    "                q_values[i] = self.gp_q_est.predict(jnp.append(state, i))\n",
    "            action = jnp.argmin(q_values)\n",
    "\n",
    "        return action\n",
    "\n",
    "\n",
    "    def evaluate(self, eval_env: gym.Env, render=bool) -> Tuple[int, str, float]:\n",
    "        \"\"\"\n",
    "        Evaluate the agent\n",
    "        \"\"\"\n",
    "        episode_length = 0\n",
    "        obs = eval_env.reset()\n",
    "        done = False\n",
    "        info = {\"time_limit\": False}\n",
    "        episode_cost = 0\n",
    "        while not done and not info[\"time_limit\"]:\n",
    "            action = self.get_best_action(obs)\n",
    "            obs, cost, done, info = eval_env.step(action)\n",
    "            episode_cost += cost\n",
    "            episode_length += 1\n",
    "\n",
    "            if render:\n",
    "                eval_env.render()\n",
    "\n",
    "        success = (\n",
    "            episode_length == eval_env.max_steps\n",
    "            and abs(obs[0]) <= eval_env.x_success_range\n",
    "        )\n",
    "        return episode_length, \"success\" if success else \"failure\", episode_cost\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "           \n",
    "        \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 372
    },
    "id": "9MagTo8wzVeG",
    "outputId": "d12d2299-2d2e-4f36-fdf4-78d7e04316e8"
   },
   "outputs": [],
   "source": [
    "nfq_net_mggp = NFQNetwork()\n",
    "optimizer = optim.Rprop(nfq_net_mggp.parameters())\n",
    "mpp_agent = Agent( nfq_net_mggp, optimizer, 24, dir=\"\", mode=\"nfq\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_3989651/2910284219.py:120: UserWarning: Creating a tensor from a list of numpy.ndarrays is extremely slow. Please consider converting the list to a single numpy.ndarray with numpy.array() before converting to a tensor. (Triggered internally at ../torch/csrc/utils/tensor_new.cpp:230.)\n",
      "  state_b = torch.FloatTensor(state_b)\n",
      "/home/pe3955/.local/lib/python3.9/site-packages/torch/_tensor.py:761: UserWarning: non-inplace resize is deprecated\n",
      "  warnings.warn(\"non-inplace resize is deprecated\")\n"
     ]
    }
   ],
   "source": [
    "state_action_b, target_q_values, groups = mpp_agent.generate_pattern_set(all_rollouts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'module' object is not callable",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m/tmp/ipykernel_3989651/582704750.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     14\u001b[0m \u001b[0mepoch\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m100\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     15\u001b[0m \u001b[0mmode\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"nfq\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 16\u001b[0;31m \u001b[0;32mfor\u001b[0m \u001b[0mk\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mepoch\u001b[0m \u001b[0;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtqdm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mepoch\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     17\u001b[0m     \u001b[0mstate_action_b\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtarget_q_values\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgroups\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmpp_agent\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgenerate_pattern_set\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mall_rollouts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmode\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmode\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     18\u001b[0m     \u001b[0mloss_nfq\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmpp_agent\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrain\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstate_action_b\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtarget_q_values\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgroups\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m: 'module' object is not callable"
     ]
    }
   ],
   "source": [
    "#\n",
    "import tqdm\n",
    "nfq_net_mggp = NFQNetwork()\n",
    "optimizer = optim.Rprop(nfq_net_mggp.parameters(), lr=0.01)\n",
    "mpp_agent = Agent( nfq_net_mggp, optimizer, 24, mode=\"nfq\")\n",
    "previous_loss = None\n",
    "delta = 5e-5\n",
    "count_fg = 0\n",
    "count_bg = 0\n",
    "bg_converged = False\n",
    "fg_converged = False\n",
    "\n",
    "losses = []\n",
    "epoch = 100\n",
    "mode = \"nfq\"\n",
    "for k, epoch in enumerate(tqdm(range(epoch + 1))):\n",
    "    state_action_b, target_q_values, groups = mpp_agent.generate_pattern_set(all_rollouts, mode=mode)\n",
    "    loss_nfq = mpp_agent.train((state_action_b, target_q_values, groups))\n",
    "    loss = loss_nfq.detach().numpy()\n",
    "    losses.append(loss)\n",
    "\n",
    "   \n",
    "plt.plot(losses)    \n",
    "    \n",
    "    \n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "SocxKhjezVeJ"
   },
   "source": [
    "# Evaluation\n",
    "* The optimal levels for K are between 3.5 and 4.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "id": "PR-ue3BAzVeL"
   },
   "outputs": [],
   "source": [
    "def state_invtransformer(tstates, transformer='transformer.pkl'):\n",
    "    \n",
    "    scaler = pickle.load(open(transformer, 'rb'))\n",
    "    states = scaler.inverse_transform(tstates)\n",
    "    \n",
    "    return states"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "id": "KvBQMsikzVeL"
   },
   "outputs": [],
   "source": [
    "state_feats = ['anchor_age', 'patientweight',\n",
    "       'ethnicity', 'los', 'gender', 'dod', 'cad', 'afib', 'chf', 'ckd',\n",
    "       'esrd', 'paralysis', 'parathyroid', 'rhabdo', 'sarcoid', 'sepsis',\n",
    "       'dialysis', 'hypokalemia', 'Hyperkalemia', 'Obesity', 'cancer',\n",
    "       'asthma', 'pneumonia', 'diabetics', 'HIV', 'bpdia', 'bpsys', 'hr', 'rr',\n",
    "       'spo2', 'temp', 'alt', 'aniongap', 'bun', 'cpk', 'ca', 'chloride',\n",
    "       'creatinine', 'glucose', 'hgb', 'k', 'ldh', 'mg', 'na', 'p', 'wbc',\n",
    "       'betablockers', 'ca-iv', 'ca-noniv', 'cablockers', 'dextrose',\n",
    "       'hours-dextrose', 'fluids', 'insulin', 'k-iv', 'k-noniv',\n",
    "       'loopdiuretics', 'hours-loopdiuretics', 'mg-iv', 'mg-noniv',\n",
    "       'hours-mg-noniv', 'p-iv', 'p-noniv', 'pnutrition', 'ponutrition',\n",
    "       'tpnutrition', 'vasopressors', 'hours-betablockers', 'hours-cablockers',\n",
    "       'hours-insulin', 'hours-k-iv', 'hours-ca-noniv', 'hours-vasopressors',\n",
    "       'hours-pnutrition', 'hours-tpnutrition', 'hours-p-iv',\n",
    "       'hours-ponutrition', 'hours-fluids', 'hours-ca-iv', 'hours-mg-iv']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "6UcULHvlzVeR"
   },
   "source": [
    "# Heatmap of Actions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "id": "aujhgyoNzVeR"
   },
   "outputs": [],
   "source": [
    "import json\n",
    "def gather_repletion_levels(group_tuple, groupp=1, doctor=False, num_samples=20, r_size= 10,\n",
    "                           start=0):\n",
    "    no_repletion = []\n",
    "    lo_repletion = []\n",
    "    hi_repletion = []\n",
    "    c_levels = []\n",
    "    group = groupp\n",
    "    tuples = group_tuple\n",
    "    end = start + num_samples\n",
    "    dir_ = \"data/\"\n",
    "    filename = f\"{start}_{end}_set.pkl\"\n",
    "\n",
    "    ## This for loop should run \"num_sample x r_size\" times. \n",
    "    # We need to determine how to get meaniful plot by tweaking r_size and num_samples\n",
    "    ## R_size which is the rollout size varies from sample to samples. It is not fixed\n",
    "    n = 0\n",
    "    for j, vn in enumerate(tqdm.tqdm(tuples['vnum'][start:end])): ## Sample any \"num of samples within the tuple list\n",
    "        rollout = generate_rollout(vn, tuples, group=group)\n",
    "        states = [r[0] for r in rollout[0:r_size]] ## Get \"r_size number of states\"\n",
    "        k_measurement_ind = state_feats.index('k')\n",
    "        c_ind = state_feats.index('creatinine')\n",
    "        doctors_actions = [r[1] for r in rollout[0:r_size]]\n",
    "        actions = np.asarray([[0, 0], [0, 10], [10, 0]])\n",
    "        m = 0\n",
    "        for s in states:\n",
    "            s_ = s.reshape(1,-1)\n",
    "            transformed_state = state_invtransformer(s_)\n",
    "            transformed_state = transformed_state.reshape(-1,1)\n",
    "            k = transformed_state[k_measurement_ind]\n",
    "            creatinine = transformed_state[c_ind]\n",
    "            c_levels.append(creatinine)\n",
    "            a = mpp_agent.get_best_action(s, actions, group=group)\n",
    "            a = list(a)\n",
    "            # print(f\"action for state {j} = {a} --- {n} --- {m}\")\n",
    "        \n",
    "            if a == [0, 0]:\n",
    "                no_repletion.append((creatinine, k))\n",
    "            elif a == [0, 10]:\n",
    "                lo_repletion.append((creatinine, k))\n",
    "            elif a == [10, 0]:\n",
    "                hi_repletion.append((creatinine, k))\n",
    "            m = m + 1  \n",
    "        n += 1\n",
    "    c_levels = [i for i in range(0, 11)]\n",
    "    measurements = [i/10 for i in range(26, 75)]\n",
    "    viz = np.zeros((len(c_levels), len(measurements)))\n",
    "    counts = np.zeros((len(c_levels), len(measurements)))\n",
    "    for (c, measurement) in no_repletion:\n",
    "        measurement = round(measurement[0], 1)\n",
    "#         c = round(c, 0)\n",
    "        c = round(c[0], 0)\n",
    "        c = c_levels.index(c)\n",
    "        new_meas = measurements.index(measurement)\n",
    "        viz[c, new_meas] += 0\n",
    "        counts[c, new_meas] += 1\n",
    "    for (c, measurement) in lo_repletion:\n",
    "#         measurement = round(measurement, 1)\n",
    "#         c = round(c, 0)\n",
    "        measurement = round(measurement[0], 1)\n",
    "#         c = round(c, 0)\n",
    "        c = round(c[0], 0)\n",
    "        c = c_levels.index(c)\n",
    "        new_meas = measurements.index(measurement)\n",
    "        viz[c, new_meas] += 1\n",
    "        counts[c, new_meas] += 1\n",
    "    for (c, measurement) in hi_repletion:\n",
    "#         measurement = round(measurement, 1)\n",
    "#         c = round(c, 0)\n",
    "        measurement = round(measurement[0], 1)\n",
    "#         c = round(c, 0)\n",
    "        c = round(c[0], 0)\n",
    "        c = c_levels.index(c)\n",
    "        new_meas = measurements.index(measurement)\n",
    "        viz[c, new_meas] += 2\n",
    "        counts[c, new_meas] += 1\n",
    "\n",
    "    viz = np.divide(viz, counts, out=np.full_like(viz, np.nan), where=counts!=0)\n",
    "    data = {\"viz\":viz.tolist(), \"measurements\":measurements, \"c_levels\":c_levels}\n",
    "    \n",
    "    return viz, measurements, c_levels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "from tqdm import tqdm\n",
    "import numpy as np\n",
    "\n",
    "def gather_repletion_levels(group_tuple, groupp=1, doctor=False, num_samples=20, r_size=10, start=0):\n",
    "    no_repletion = []\n",
    "    lo_repletion = []\n",
    "    hi_repletion = []\n",
    "    c_levels = list(range(0, 11))\n",
    "    measurements = [i/10 for i in range(26, 75)]\n",
    "    viz = np.zeros((len(c_levels), len(measurements)))\n",
    "    counts = np.zeros((len(c_levels), len(measurements)))\n",
    "    group = groupp\n",
    "    tuples = group_tuple\n",
    "    end = start + num_samples\n",
    "\n",
    "    k_measurement_ind = state_feats.index('k')\n",
    "    c_ind = state_feats.index('creatinine')\n",
    "    actions = np.asarray([[0, 0], [0, 10], [10, 0]])\n",
    "\n",
    "    for j, vn in enumerate(tqdm(tuples['vnum'][start:end])):\n",
    "        rollout = generate_rollout(vn, tuples, group=group)\n",
    "        states = [r[0] for r in rollout[0:r_size]]\n",
    "        doctors_actions = [r[1] for r in rollout[0:r_size]]\n",
    "        for s in states:\n",
    "            s_ = s.reshape(1,-1)\n",
    "            transformed_state = state_invtransformer(s_)\n",
    "            k = transformed_state[k_measurement_ind]\n",
    "            creatinine = transformed_state[c_ind]\n",
    "            a = mpp_agent.get_best_action(s, actions, group=group)\n",
    "            a = list(a)\n",
    "        \n",
    "            if a == [0, 0]:\n",
    "                no_repletion.append((creatinine, k))\n",
    "            elif a == [0, 10]:\n",
    "                lo_repletion.append((creatinine, k))\n",
    "            elif a == [10, 0]:\n",
    "                hi_repletion.append((creatinine, k))\n",
    "            \n",
    "    for (c, measurement) in no_repletion:\n",
    "        measurement = round(measurement[0], 1)\n",
    "        c = round(c[0], 0)\n",
    "        c = c_levels.index(c)\n",
    "        new_meas = measurements.index(measurement)\n",
    "        viz[c, new_meas] += 0\n",
    "        counts[c, new_meas] += 1\n",
    "    for (c, measurement) in lo_repletion:\n",
    "        measurement = round(measurement[0], 1)\n",
    "        c = round(c[0], 0)\n",
    "        c = c_levels.index(c)\n",
    "        new_meas = measurements.index(measurement)\n",
    "        viz[c, new_meas] += 1\n",
    "        counts[c, new_meas] += 1\n",
    "    for (c, measurement) in hi_repletion:\n",
    "        measurement = round(measurement[0], 1)\n",
    "        c = round(c[0], 0)\n",
    "        c = c_levels.index(c)        \n",
    "        new_meas = measurements.index(measurement)\n",
    "        viz[c, new_meas] += 2\n",
    "        counts[c, new_meas] += 1\n",
    "    return viz, measurements, c_levels\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [],
   "source": [
    "# n = 0\n",
    "# tuples = group1_test_Ktuples\n",
    "# start, end = 0, 3\n",
    "# r_size = 10\n",
    "# for j, vn in enumerate(tqdm.tqdm(tuples['vnum'][start:end])): ## Sample any \"num of samples within the tuple list\n",
    "#     print(j, vn)\n",
    "# #     rollout = generate_rollout(vn, tuples, group=group)\n",
    "# #     states = [r[0] for r in rollout[0:r_size]] ##"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {
    "id": "aujhgyoNzVeR"
   },
   "outputs": [],
   "source": [
    "\n",
    "def generate_action(vnum, tuples, group, r_size):\n",
    "    rollout = generate_rollout(vnum, tuples, group=group)\n",
    "    states = [r[0] for r in rollout[0:r_size]]\n",
    "    k_ind = state_feats.index('k')\n",
    "    doctors_actions = [r[1] for r in rollout[0:r_size]]\n",
    "    actions = np.asarray([[0,0], [0,10], [10,0]])\n",
    "    m = 0\n",
    "    action_arrays = []\n",
    "    k_array = []\n",
    "    \n",
    "    for s in states:\n",
    "        s_ = s.reshape(1,-1)\n",
    "        transformed_state = state_invtransformer(s_)\n",
    "        transformed_state = transformed_state.reshape(-1,1)\n",
    "        k = transformed_state[k_ind]\n",
    "        k_array.append(float(k[0]))\n",
    "        group = jnp.array([group])\n",
    "        a = mpp_agent.get_best_action(s, actions, group=group)\n",
    "        a = list(a)\n",
    "        # print(f\"action for state {vnum} = {a} --- {n} --- {m}\")\n",
    "        if a == [0, 0]:\n",
    "            #no_repletion.append((creatinine, k))\n",
    "            action_arrays.append(1)\n",
    "        elif a == [0, 10]:\n",
    "            #lo_repletion.append((creatinine, k))\n",
    "            action_arrays.append(2)\n",
    "        elif a == [10, 0]:\n",
    "            #hi_repletion.append((creatinine, k))\n",
    "            action_arrays.append(3)\n",
    "        m = m + 1 \n",
    "    return m, k_array, action_arrays\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# tuples = group1_test_Ktuples\n",
    "# K_ARRAY = []\n",
    "# A_ARRAY = []\n",
    "# flag = 0\n",
    "# END = 1\n",
    "# group= 1\n",
    "# for vn in set(tuples['vnum']):\n",
    "#     m, k_array, action_arrays = generate_action(vn, tuples, group, 100)\n",
    "#     K_ARRAY.extend(k_array)\n",
    "#     A_ARRAY.extend(action_arrays)\n",
    "#     flag += 1\n",
    "#     if flag > END:\n",
    "#         break\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [],
   "source": [
    "# k_level = list(set(K_ARRAY))\n",
    "# heatmap = np.zeros(len(k_level))\n",
    "# num_observations = np.zeros(len(k_level))\n",
    "# for i in range(len(A_ARRAY)):\n",
    "#     potassium_level = K_ARRAY[i]\n",
    "#     action = A_ARRAY[i]\n",
    "#     ind = k_level.index(potassium_level)\n",
    "#     heatmap[ind] += action # keep track of this action. add it to a sum of the actions for this potassium level\n",
    "#     num_observations[ind] += 1\n",
    "\n",
    "# hmap = heatmap/num_observations\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [],
   "source": [
    "# #group 1 single\n",
    "# hmap = hmap.reshape((len(hmap), 1)) # reshape into a 2D vector \n",
    "# ax = sns.heatmap(hmap)                       "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle\n",
    "data_path = '../data-processed'\n",
    "group0_test_Ktuples = pickle.load(open(data_path + '/mimic_iv/group_0_GroupedtestKtuples.pkl', 'rb'))\n",
    "group0_train_Ktuples  = pickle.load(open(data_path + '/mimic_iv/group_0_GroupedtrainKtuples.pkl', 'rb'))\n",
    "group1_test_Ktuples  = pickle.load(open(data_path + '/mimic_iv/group_1_GroupedtestKtuples.pkl', 'rb'))\n",
    "group1_train_Ktuples = pickle.load(open(data_path + '/mimic_iv/group_1_GroupedtrainKtuples.pkl', 'rb'))\n",
    "group2_test_Ktuples  = pickle.load(open(data_path + '/mimic_iv/group_2_GroupedtestKtuples.pkl', 'rb'))\n",
    "group2_train_Ktuples = pickle.load(open(data_path + '/mimic_iv/group_2_GroupedtrainKtuples.pkl', 'rb'))\n",
    "group3_test_Ktuples  = pickle.load(open(data_path + '/mimic_iv/group_3_GroupedtestKtuples.pkl', 'rb'))\n",
    "group3_train_Ktuples = pickle.load(open(data_path + '/mimic_iv/group_3_GroupedtrainKtuples.pkl', 'rb'))\n",
    "group4_test_Ktuples  = pickle.load(open(data_path + '/mimic_iv/group_4_GroupedtestKtuples.pkl', 'rb'))\n",
    "group4_train_Ktuples = pickle.load(open(data_path + '/mimic_iv/group_4_GroupedtrainKtuples.pkl', 'rb'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "from tqdm import tqdm\n",
    "import numpy as np\n",
    "\n",
    "def gather_repletion_levels(group_tuple, groupp=1, doctor=False, num_samples=20, r_size=10, start=0):\n",
    "    no_repletion = []\n",
    "    lo_repletion = []\n",
    "    hi_repletion = []\n",
    "    c_levels = list(range(0, 11))\n",
    "    measurements = [i/10 for i in range(26, 75)]\n",
    "    viz = np.zeros((len(c_levels), len(measurements)))\n",
    "    counts = np.zeros((len(c_levels), len(measurements)))\n",
    "    group = groupp\n",
    "    tuples = group_tuple\n",
    "    end = start + num_samples\n",
    "\n",
    "    k_measurement_ind = state_feats.index('k')\n",
    "    c_ind = state_feats.index('creatinine')\n",
    "    actions = np.asarray([[0, 0], [0, 10], [10, 0]])\n",
    "\n",
    "    for j, vn in enumerate(tqdm(tuples['vnum'][start:end])):\n",
    "        rollout = generate_rollout(vn, tuples, group=group)\n",
    "        states = [r[0] for r in rollout[0:r_size]]\n",
    "        doctors_actions = [r[1] for r in rollout[0:r_size]]\n",
    "        for s in states:\n",
    "            s_ = s.reshape(1,-1)\n",
    "            transformed_state = state_invtransformer(s_)\n",
    "            k = transformed_state[k_measurement_ind]\n",
    "            creatinine = transformed_state[c_ind]\n",
    "            a = mpp_agent.get_best_action(s, actions, group=group)\n",
    "            a = list(a)\n",
    "        \n",
    "            if a == [0, 0]:\n",
    "                no_repletion.append((creatinine, k))\n",
    "            elif a == [0, 10]:\n",
    "                lo_repletion.append((creatinine, k))\n",
    "            elif a == [10, 0]:\n",
    "                hi_repletion.append((creatinine, k))\n",
    "            \n",
    "    for (c, measurement) in no_repletion:\n",
    "        measurement = round(measurement[0], 1)\n",
    "        c = round(c[0], 0)\n",
    "        c = c_levels.index(c)\n",
    "        new_meas = measurements.index(measurement)\n",
    "        viz[c, new_meas] += 0\n",
    "        counts[c, new_meas] += 1\n",
    "    for (c, measurement) in lo_repletion:\n",
    "        measurement = round(measurement[0], 1)\n",
    "        c = round(c[0], 0)\n",
    "        c = c_levels.index(c)\n",
    "        new_meas = measurements.index(measurement)\n",
    "        viz[c, new_meas] += 1\n",
    "        counts[c, new_meas] += 1\n",
    "    for (c, measurement) in hi_repletion:\n",
    "        measurement = round(measurement[0], 1)\n",
    "        c = round(c[0], 0)\n",
    "        c = c_levels.index(c)        \n",
    "        new_meas = measurements.index(measurement)\n",
    "        viz[c, new_meas] += 2\n",
    "        counts[c, new_meas] += 1\n",
    "    return viz, measurements, c_levels\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "a6oPuLbezVeX"
   },
   "outputs": [],
   "source": [
    "viz, measurements, ages = gather_repletion_levels(group_tuple = group0_test_Ktuples, groupp=0,\n",
    "                                                  num_samples=200, r_size=12,start=0)\n",
    "plt.figure(figsize=(14, 5))\n",
    "sns.heatmap(viz, xticklabels=measurements, yticklabels=ages)\n",
    "plt.ylabel(\"Creatinine\")\n",
    "plt.xlabel(\"Potassium Level in Blood (mmol/L)\")\n",
    "plt.title(\"Evaluating Group 0 Patients\")\n",
    "plt.savefig(\"Group0patients.png\")\n",
    "# viz, measurements, ages = gather_repletion_levels(renal=True)\n",
    "# plt.figure(figsize=(14, 5))\n",
    "# sns.heatmap(viz, xticklabels=measurements, yticklabels=ages)\n",
    "# plt.ylabel(\"Creatinine\")\n",
    "# plt.xlabel(\"Potassium Level in Blood (mmol/L)\")\n",
    "# plt.title(\"Evaluating Renal Patients\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 504/504 [00:03<00:00, 137.44it/s]\n"
     ]
    }
   ],
   "source": [
    "import json\n",
    "\n",
    "no_repletion = []\n",
    "lo_repletion = []\n",
    "hi_repletion = []\n",
    "c_levels = []\n",
    "group = 0\n",
    "tuples = group5_test_Ktuples\n",
    "end = 10000\n",
    "start = 0\n",
    "r_size = 12\n",
    "\n",
    "## This for loop should run \"num_sample x r_size\" times. \n",
    "# We need to determine how to get meaniful plot by tweaking r_size and num_samples\n",
    "## R_size which is the rollout size varies from sample to samples. It is not fixed\n",
    "n = 0\n",
    "for j, vn in enumerate(tqdm(tuples['vnum'])): ## Sample any \"num of samples within the tuple list\n",
    "    rollout = generate_rollout(vn, tuples, group=group)\n",
    "    states = [r[0] for r in rollout] ## Get \"r_size number of states\"\n",
    "    k_measurement_ind = state_feats.index('k')\n",
    "    c_ind = state_feats.index('creatinine')\n",
    "    doctors_actions = [r[1] for r in rollout[0:r_size]]\n",
    "    actions = np.asarray([[0, 0], [0, 10], [10, 0]])\n",
    "    m = 0\n",
    "    for s in states:\n",
    "        s_ = s.reshape(1,-1)\n",
    "        transformed_state = state_invtransformer(s_)\n",
    "        transformed_state = transformed_state.reshape(-1,1)\n",
    "        k = transformed_state[k_measurement_ind]\n",
    "        creatinine = transformed_state[c_ind]\n",
    "        c_levels.append(creatinine)\n",
    "        a = mpp_agent.get_best_action(s, actions, group=group)\n",
    "        a = list(a)\n",
    "        # print(f\"action for state {j} = {a} --- {n} --- {m}\")\n",
    "    \n",
    "        if a == [0, 0]:\n",
    "            no_repletion.append((creatinine, k))\n",
    "        elif a == [0, 10]:\n",
    "            lo_repletion.append((creatinine, k))\n",
    "        elif a == [10, 0]:\n",
    "            hi_repletion.append((creatinine, k))\n",
    "        m = m + 1  \n",
    "    n += 1\n",
    "c_levels = [i for i in range(0, 11)]\n",
    "measurements = [i/10 for i in range(26, 75)]\n",
    "viz = np.zeros((len(c_levels), len(measurements)))\n",
    "counts = np.zeros((len(c_levels), len(measurements)))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {},
   "outputs": [],
   "source": [
    "# save the data\n",
    "grouppp = 'group5'\n",
    "data = {\"lo_repletion\": lo_repletion, \"hi_repletion\": hi_repletion, \"no_repletion\": no_repletion, \"c_levels\": c_levels, \"measurements\": measurements, \"viz\": viz, \"counts\": counts}\n",
    "\n",
    "# save data as pickle\n",
    "with open(f'{grouppp}_data.pickle', 'wb') as handle:\n",
    "    pickle.dump(data, handle, protocol=pickle.HIGHEST_PROTOCOL)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {},
   "outputs": [],
   "source": [
    "grouppp = 'group5'\n",
    "# load data as pickle\n",
    "with open(f'{grouppp}_data.pickle', 'rb') as handle:\n",
    "    data = pickle.load(handle)\n",
    "\n",
    "lo_repletion = data['lo_repletion']\n",
    "hi_repletion = data['hi_repletion']\n",
    "no_repletion = data['no_repletion']\n",
    "c_levels = data['c_levels']\n",
    "measurements = data['measurements']\n",
    "viz = data['viz']\n",
    "counts = data['counts']\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [],
   "source": [
    "c_levels = [i for i in range(0, 11)]\n",
    "measurements = [i/10 for i in range(25, 75)]\n",
    "viz = np.zeros((len(c_levels), len(measurements)))\n",
    "counts = np.zeros((len(c_levels), len(measurements)))\n",
    "\n",
    "for (c, measurement) in no_repletion:\n",
    "    measurement = round(measurement[0], 1)\n",
    "    c = round(c[0], 0)\n",
    "    c = c_levels.index(c)\n",
    "    new_meas = measurements.index(measurement)\n",
    "    viz[c, new_meas] += 0\n",
    "    counts[c, new_meas] += 1\n",
    "for (c, measurement) in lo_repletion:\n",
    "    measurement = round(measurement[0], 1)\n",
    "    c = round(c[0], 0)\n",
    "    if c <= 10 and 2.5 <= measurement <= 7.5:\n",
    "        c = c_levels.index(c)\n",
    "        new_meas = measurements.index(measurement)\n",
    "        viz[c, new_meas] += 1\n",
    "        counts[c, new_meas] += 1\n",
    "for (c, measurement) in hi_repletion:\n",
    "    measurement = round(measurement[0], 1)\n",
    "    c = round(c[0], 0)\n",
    "    if c <= 10 and 2.5 <= measurement <= 7.5:\n",
    "        c = c_levels.index(c)\n",
    "        new_meas = measurements.index(measurement)\n",
    "        viz[c, new_meas] += 2\n",
    "        counts[c, new_meas] += 1\n",
    "\n",
    "viz = np.divide(viz, counts, out=np.full_like(viz, np.nan), where=counts!=0)\n",
    "data = {\"viz\":viz.tolist(), \"measurements\":measurements, \"c_levels\":c_levels}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1400x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(14, 5))\n",
    "sns.heatmap(viz, xticklabels=measurements, yticklabels=ages)\n",
    "plt.ylabel(\"Creatinine\")\n",
    "plt.xlabel(\"Potassium Level in Blood (mmol/L)\")\n",
    "plt.title(\"Evaluating Group 5 Patients\")\n",
    "plt.savefig(grouppp+ \"patients.png\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "rqp8WkyYzVeZ"
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "name": "elo_mimic-iv_experiments.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.7"
  },
  "vscode": {
   "interpreter": {
    "hash": "e8656658b91e58fc427d957c511da0a238718ef3a47a940e73158e087ae07829"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}