recurrent_event.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "metadata": {}
   },
   "outputs": [],
   "source": [
    "import torch\n",
    "import numpy as np\n",
    "from deepreevent import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "set_seed(42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "metadata": {}
   },
   "outputs": [],
   "source": [
    "# set device\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "metadata": {}
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ayush/DeepReEvent/src/data.py:47: FutureWarning: The provided callable <built-in function max> is currently using SeriesGroupBy.max. In a future version of pandas, the provided callable will be used directly. To keep current behavior pass the string \"max\" instead.\n",
      "  data['max_time'] = data.groupby('id')['t.stop'].transform(max)\n"
     ]
    }
   ],
   "source": [
    "x, t, e, d = _load_readmission_dataset(sequential=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "metadata": {}
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ayush/DeepReEvent/src/helper_functions.py:86: 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:261.)\n",
      "  x = torch.tensor(x, dtype=torch.float32)\n"
     ]
    }
   ],
   "source": [
    "readmission_tensor = _prepare_rt_tensors(x, t, e, d)\n",
    "locals().update(readmission_tensor) # create variables from dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "metadata": {}
   },
   "outputs": [],
   "source": [
    "# model and training parameters\n",
    "\n",
    "input_size = len(x[0]) \n",
    "output_size = int(max(t))\n",
    "hidden_size = 8   # Number of units in the RNN layer\n",
    "\n",
    "model = SimpleGRU(input_size, hidden_size, output_size, 1, 0.1)\n",
    "\n",
    "# Instantiate the model\n",
    "\n",
    "num_epochs = 10000\n",
    "patience = 3  # Number of epochs to wait for improvement before stopping\n",
    "best_val_loss = float('inf')\n",
    "wait = 0\n",
    "loss_function = recurrent_loss\n",
    "\n",
    "model = model.to(device)\n",
    "optimizer = torch.optim.Adam(model.parameters(),  lr=1e-4, weight_decay=1e-7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "metadata": {}
   },
   "outputs": [],
   "source": [
    "#prepare data loaders\n",
    "\n",
    "train_dataloader, val_dataloader, test_dataloader = _prepare_dataloaders(readmission_tensor, batch_size=32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "metadata": {}
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0   Training loss: 3.0064   Validation loss: 2.8554\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 10   Training loss: 2.9716   Validation loss: 2.8452\n",
      "Epoch: 20   Training loss: 2.9328   Validation loss: 2.8378\n",
      "Epoch: 30   Training loss: 2.8771   Validation loss: 2.8335\n",
      "Epoch: 40   Training loss: 2.8732   Validation loss: 2.8312\n",
      "Epoch: 50   Training loss: 2.8580   Validation loss: 2.8306\n",
      "Epoch: 60   Training loss: 2.8378   Validation loss: 2.8302\n",
      "Early stopping\n"
     ]
    }
   ],
   "source": [
    "train_validate_recurrent_model(model, train_dataloader, val_dataloader, loss_function, optimizer, num_epochs, patience, print_every=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "metadata": {}
   },
   "outputs": [],
   "source": [
    "test_predictions = model(x_test).squeeze(-1)\n",
    "\n",
    "recurrent_predictions = test_predictions.squeeze(-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Time 1': 0.7904290429042904,\n",
       " 'Time 2': 0.5367063492063492,\n",
       " 'Time 3': 0.4127382146439318,\n",
       " 'Time 4': 0.4967391304347826,\n",
       " 'Time 5': 0.5266524520255863,\n",
       " 'Time 6': 0.5266524520255863}"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recurrent_cindex(recurrent_predictions, e_test, t_test, max_time = 6, horizons = \"all\", tolerance = 0.1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.utils import resample\n",
    "\n",
    "nsamples = 100  # Number of bootstrap samples\n",
    "survival_cis = []\n",
    "recurrent_cis = []\n",
    "\n",
    "for sample in range(nsamples):\n",
    "    \n",
    "    # Resample the test data\n",
    "    x_test_resampled, t_test_resampled, e_test_resampled, d_test_resampled = resample(x_test, t_test, e_test, d_test, replace=True)\n",
    "    \n",
    "    # Make predictions on the resampled test data\n",
    "    test_predictions = model(x_test_resampled).squeeze(-1)\n",
    "    \n",
    "    recurrent_predictions = test_predictions.squeeze(-1)\n",
    "    try: \n",
    "        # Calculate metrics for the resampled test data\n",
    "        recurrent_cis.append(recurrent_cindex(recurrent_predictions, e_test_resampled, t_test_resampled, 6))\n",
    "    except: \n",
    "        continue"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_metric_ci(cis, time_key, rounding = 2):\n",
    "    cis_time = [cis[i][time_key] for i in range(len(cis))]\n",
    "    survival_ci_mean = np.mean(cis_time)\n",
    "    survival_ci_std = np.std(np.array(cis_time))\n",
    "    return round(survival_ci_mean, rounding), round(survival_ci_std, rounding)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time 1: Mean = 0.82, Std = 0.03\n",
      "Time 2: Mean = 0.51, Std = 0.07\n",
      "Time 3: Mean = 0.44, Std = 0.06\n",
      "Time 4: Mean = 0.46, Std = 0.06\n",
      "Time 5: Mean = 0.48, Std = 0.07\n",
      "Time 6: Mean = 0.48, Std = 0.07\n"
     ]
    }
   ],
   "source": [
    "recurrent_cis_1_mean, recurrent_cis_1_std = compute_metric_ci(recurrent_cis, \"Time 1\")\n",
    "recurrent_cis_2_mean, recurrent_cis_2_std = compute_metric_ci(recurrent_cis, \"Time 2\")\n",
    "recurrent_cis_3_mean, recurrent_cis_3_std = compute_metric_ci(recurrent_cis, \"Time 3\")\n",
    "recurrent_cis_4_mean, recurrent_cis_4_std = compute_metric_ci(recurrent_cis, \"Time 4\")\n",
    "recurrent_cis_5_mean, recurrent_cis_5_std = compute_metric_ci(recurrent_cis, \"Time 5\")\n",
    "recurrent_cis_6_mean, recurrent_cis_6_std = compute_metric_ci(recurrent_cis, \"Time 6\")\n",
    "\n",
    "print(f\"Time 1: Mean = {recurrent_cis_1_mean}, Std = {recurrent_cis_1_std}\")\n",
    "print(f\"Time 2: Mean = {recurrent_cis_2_mean}, Std = {recurrent_cis_2_std}\")\n",
    "print(f\"Time 3: Mean = {recurrent_cis_3_mean}, Std = {recurrent_cis_3_std}\")\n",
    "print(f\"Time 4: Mean = {recurrent_cis_4_mean}, Std = {recurrent_cis_4_std}\")\n",
    "print(f\"Time 5: Mean = {recurrent_cis_5_mean}, Std = {recurrent_cis_5_std}\")\n",
    "print(f\"Time 6: Mean = {recurrent_cis_6_mean}, Std = {recurrent_cis_6_std}\")"
   ]
  }
 ],
 "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.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}