capacity_simulator_v0.0.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Hospital Capacity Simulator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import datetime\n",
    " \n",
    "from numpy import random\n",
    "from ipywidgets import interact, Layout, Button, Box, FloatText, Textarea, Dropdown, Label, IntSlider, DatePicker, interactive\n",
    "from ipywidgets import FloatSlider, HBox, VBox, Output\n",
    "from IPython.display import display"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "- Set general hospital stats\n",
    "- Set patient generator stats\n",
    "- Plot sample days\n",
    "- Select date range and generate random admissions\n",
    "- Calculate and graph hourly metrics "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Set general stats:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def b(Beds): return"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_beds = interactive(b, Beds=IntSlider(value=312, min=100, max=500));"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "538bb5a509cd4abeb4f9145e2477db02",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Box(children=(VBox(children=(Label(value='Total Beds:'), interactive(children=(IntSlider(value=312, descriptio…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "gen_stats_layout = Layout(display='flex',flex_flow='column',border='solid 1px',align_items='flex-start', width='75%')\n",
    "\n",
    "gen_stats_items = [VBox([Label('Total Beds:'), num_beds])]\n",
    "\n",
    "stats_form = Box(gen_stats_items, layout=gen_stats_layout)\n",
    "\n",
    "display(stats_form)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Set patient generator stats & plot sample days"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def r(Rate): return\n",
    "def p(avg, std): return\n",
    "def b(avg_bias, std_bias): return\n",
    "def c(adm_std_bias): return"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# style = {'description_width': 'initial'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "unplan_adm_rate = interactive(r, Rate=FloatSlider(value=0.3, min=0.0, max=1.0, step=0.05));\n",
    "\n",
    "unplan_adm_rate.kwargs = {'Rate': 0.3}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "pl_los = interactive(p, avg=FloatSlider(value=36.0, min=0.0, max=120.0, step=0.5), \n",
    "                     std=FloatSlider(value=8.0, min=0.0, max=60.0, step=0.1))\n",
    "\n",
    "pl_los.kwargs = {'avg': 36.0, 'std': 8.0}\n",
    "\n",
    "unpl_los = interactive(p, avg=FloatSlider(value=48.0, min=0.0, max=120.0, step=0.5), \n",
    "                       std=FloatSlider(value=12.0, min=0.0, max=60.0, step=0.1))\n",
    "\n",
    "unpl_los.kwargs = {'avg': 48.0, 'std': 12.0}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "pl_adm_bias = interactive(b, avg_bias=FloatSlider(value=0.0, min=-10.0, max=10.0, step=0.5), \n",
    "                           std_bias=FloatSlider(value=0.0, min=-10.0, max=10.0, step=0.1))\n",
    "\n",
    "pl_adm_bias.kwargs = {'avg_bias': 0.0, 'std_bias': 0.0}\n",
    "\n",
    "unpl_adm_bias = interactive(b, avg_bias=FloatSlider(value=0.0, min=-10.0, max=10.0, step=0.5),\n",
    "                           std_bias=FloatSlider(value=0.0, min=-10.0, max=10.0, step=0.1))\n",
    "\n",
    "unpl_adm_bias.kwargs = {'avg_bias': 0.0, 'std_bias': 0.0}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "plan_hrly_means = np.array([[0.2, 0.2, 0.2, 0.2, 0.2, 3.5, 9.0, 13.0, 12.0, 12.0, 11.0, 11, 11, 11, 11, 10, 9, 6, 3, 1, \n",
    "                             0.2, 0.2, 0.2, 0.2]]).T\n",
    "\n",
    "plan_hrly_std = np.array([[2.5, 2.1, 1.7, 1.6, 1.4, 1.35, 1.2, 3.5, 4.9, 5.7, 5.5, 4.4, 4.6, 4.8, 4.7, 4.6, 4.3, 4.2, 4.3, \n",
    "                            5, 5.5, 4.2, 3.3, 2.9]]).T\n",
    "\n",
    "unplan_hrly_means = np.array([2.5, 2.1 ,1.7, 1.6, 1.4, 1.35, 1.2, 3.5, 4.9, 5.7, 5.5, 4.4, 4.6, 4.8, 4.7, 4.6, 4.3, 4.2, 4.3, 5,\n",
    "                         5.5, 4.2, 3.3, 2.9])\n",
    "\n",
    "unplan_hrly_std = np.array([0.05, 0.05, 0.05, 0.05, 0.05, 0.875, 1.5, 3, 2.75, 2.5, 3.25, 3.25, 3, 2.75, 3, 1.75, 2, 1, 0.75, 0.25, \n",
    "                        0.05, 0.05, 0.05, 0.05])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "bias_form_items = [VBox([Label('Unplanned Admission Rate (%):'), unplan_adm_rate]),\n",
    "                   HBox([VBox([Label('Planned LOS:'), pl_los, Label('Planned Admission:'), pl_adm_bias]),\n",
    "                         VBox([Label('Unplanned LOS:'), unpl_los, Label('Unplanned Admission:'), unpl_adm_bias])])]\n",
    "\n",
    "bias_form = Box(bias_form_items, \n",
    "                layout=Layout(display='flex-grow',\n",
    "                              flex_flow='column',\n",
    "                              border='solid 1px',\n",
    "                              align_items='flex-start',\n",
    "                              justify_content='space-between',\n",
    "                              width='75%'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gen_day_normal(hrly_means, hrly_std, bias, rate=None):\n",
    "    if not rate: rate=1.0\n",
    "    patients = [int(random.normal(loc=m.item(), scale=s.item())*rate) for m,s in zip(hrly_means + bias, hrly_std)]\n",
    "    return [p if p>=0 else 0 for p in patients]\n",
    "\n",
    "def gen_day(hrly_means, bias, rate=None):\n",
    "    if rate:\n",
    "        return [int(random.poisson(lam=m.item())*rate) for m in hrly_means + bias]\n",
    "    else: \n",
    "        return [random.poisson(lam=m.item()) for m in hrly_means + bias]\n",
    "\n",
    "def plot_one_day():\n",
    "    for i in range(1):\n",
    "        ax = sns.barplot(x=np.arange(0,24,1), y=gen_day_normal(plan_hrly_means, \n",
    "                                                               plan_hrly_std, \n",
    "                                                               pl_adm_bias.kwargs['avg_bias']));\n",
    "        ax.set(xlabel='Hour of the Day', ylabel='# of Patients')\n",
    "        ax.set_title(\"Random Planned Admissions per Hour\")\n",
    "        plt.show();\n",
    "    \n",
    "    for i in range(1):\n",
    "        ax = sns.barplot(x=np.arange(0,24,1), \n",
    "                         y=gen_day_normal(unplan_hrly_means, \n",
    "                                          unplan_hrly_std, \n",
    "                                          unpl_adm_bias.kwargs['avg_bias'], \n",
    "                                          unplan_adm_rate.kwargs['Rate']));\n",
    "        ax.set(xlabel='Hour of the Day', ylabel='# of Patients')\n",
    "        ax.set_title(\"Random Unplanned Admissions per Hour\")\n",
    "        plt.show();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "button = Button(description=\"Plot Sample Days\")\n",
    "output = Output()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def on_button_clicked(b):\n",
    "    output.clear_output()\n",
    "    with output:\n",
    "        plot_one_day()\n",
    "\n",
    "button.on_click(on_button_clicked)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plot admissions and hrly calculations for select dates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "today = datetime.date.today()\n",
    "start = DatePicker( description='Begin:', disabled=False)\n",
    "start.value = today-datetime.timedelta(days=7)\n",
    "end = DatePicker(description='End:', disabled=False)\n",
    "end.value = today"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "dates_form = Box([HBox([start, end])], \n",
    "                 layout=Layout(display='flex', \n",
    "                      flex_flow='row',\n",
    "                      border='solid 1px',\n",
    "                      height='75px',\n",
    "                      align_items='center', \n",
    "                      width='75%'))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def count_days(start, end):\n",
    "    if start.value and end.value:\n",
    "        delta = end.value - start.value\n",
    "        return delta.days"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def autolabel(ax, rects, xpos='center'):\n",
    "    ha = {'center': 'center', 'right': 'left', 'left': 'right'}\n",
    "    offset = {'center': 0, 'right': 1, 'left': -1}\n",
    "\n",
    "    for rect in rects:\n",
    "        height = rect.get_height()\n",
    "        ax.annotate('{}'.format(height),\n",
    "                    xy=(rect.get_x() + rect.get_width() / 2, height),\n",
    "                    xytext=(offset[xpos]*3, 3),  # use 3 points offset\n",
    "                    textcoords=\"offset points\",  # in both directions\n",
    "                    ha=ha[xpos], va='bottom')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gen_random_admissions(num_days):\n",
    "    tot_planned, tot_unplanned = [],[]\n",
    "    hrly_pln, hrly_unpln = [],[]\n",
    "    \n",
    "    for day in range(num_days):\n",
    "        rand_plan = gen_day(plan_hrly_means, pl_adm_bias.kwargs['avg_bias'])\n",
    "        rand_unplan = gen_day(unplan_hrly_means, unpl_adm_bias.kwargs['avg_bias'], unplan_adm_rate.kwargs['Rate'])\n",
    "        \n",
    "        hrly_pln.append(rand_plan)\n",
    "        hrly_unpln.append(rand_unplan)\n",
    "        tot_unplanned.append(sum(rand_unplan))\n",
    "        tot_planned.append(sum(rand_plan))\n",
    "    \n",
    "    return tot_planned, tot_unplanned, hrly_pln, hrly_unpln"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_random_admission(start_date, end_date):\n",
    "    num_days = count_days(start_date, end_date)\n",
    "    string_dates = [(start_date.value + datetime.timedelta(days=i)).isoformat() for i in range(0,num_days)]\n",
    "    tot_planned, tot_unplanned, hrly_pl, hrly_upl = gen_random_admissions(num_days)\n",
    "    return string_dates, tot_planned, tot_unplanned, hrly_pl, hrly_upl"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_admissions(string_dates, tot_planned, tot_unplanned):\n",
    "    \n",
    "    ind = np.arange(len(tot_planned))  # the x locations for the groups\n",
    "    width = 0.35  # the width of the bars\n",
    "\n",
    "    fig, ax = plt.subplots(figsize=(12, 7))\n",
    "    rects1 = ax.bar(ind - width/2, tot_planned, width, label='Planned')\n",
    "    rects2 = ax.bar(ind + width/2, tot_unplanned, width, label='Unplanned')\n",
    "\n",
    "    # Add some text for labels, title and custom x-axis tick labels, etc.\n",
    "    ax.set_ylabel('# of patients')\n",
    "    ax.set_title('Admissions Per Day')\n",
    "    ax.set_xticks(ind)\n",
    "    ax.set_xticklabels(string_dates)\n",
    "    fig.autofmt_xdate()\n",
    "    ax.legend()\n",
    "\n",
    "    autolabel(ax, rects1, \"left\")\n",
    "    autolabel(ax, rects2, \"right\")\n",
    "    \n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gen_hrly_los(tot_p, tot_up):\n",
    "    p_los = [[int(random.normal(loc=pl_los.kwargs['avg'], scale=pl_los.kwargs['std'])) for x in range(a)] for a in tot_p]\n",
    "    up_los = [[int(random.normal(loc=unpl_los.kwargs['avg'], scale=unpl_los.kwargs['std'])) for x in range(a)] for a in tot_p]\n",
    "    return p_los, up_los"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "string_dates, tot_pl, tot_unpl, hrly_pl, hrly_upl = get_random_admission(start, end)\n",
    "p_los, up_los = gen_hrly_los(tot_pl, tot_unpl)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "def adm_dis_times(los):\n",
    "    admit = [random.choice(np.arange(0,23,1), 1).item() for i in range(len(los))]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def on_change(b):\n",
    "    output2.clear_output()\n",
    "    with output2:\n",
    "        string_dates, tot_pl, tot_unpl, hrly_pl, hrly_upl = get_random_admission(start, end)\n",
    "        plot_admissions(string_dates, tot_pl, tot_unpl)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "gen_button = Button(description=\"Generate\")\n",
    "output2 = Output()        \n",
    "        \n",
    "gen_button.on_click(on_change)\n",
    "\n",
    "start.observe(on_change)\n",
    "end.observe(on_change)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "192cbe558f57477897874670bffd09e5",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Box(children=(VBox(children=(Label(value='Unplanned Admission Rate (%):'), interactive(children=(FloatSlider(v…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f3dd969616d94754912e08668afea803",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Button(description='Plot Sample Days', style=ButtonStyle())"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2801b803c629428497cc830ab19a1b4f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ab8802c7f1f34860b5ec3277a8e0f2d0",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Box(children=(HBox(children=(DatePicker(value=datetime.date(2020, 8, 31), description='Begin:'), DatePicker(va…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "876aa5dc126d4f5787490b3498ee4ee9",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Button(description='Generate', style=ButtonStyle())"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "94808b0a246543cdb4913fd0d1aa6235",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "display(bias_form, button, output, dates_form, gen_button, output2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import networkx as nx\n",
    "\n",
    "# def random_lobster(n, m, k, p):\n",
    "#     return nx.random_lobster(n, p, p / m)\n",
    "\n",
    "# def powerlaw_cluster(n, m, k, p):\n",
    "#     return nx.powerlaw_cluster_graph(n, m, p)\n",
    "\n",
    "# def erdos_renyi(n, m, k, p):\n",
    "#     return nx.erdos_renyi_graph(n, p)\n",
    "\n",
    "# def newman_watts_strogatz(n, m, k, p):\n",
    "#     return nx.newman_watts_strogatz_graph(n, k, p)\n",
    "\n",
    "# def plot_random_graph(n, m, k, p, generator):\n",
    "#     g = generator(n, m, k, p)\n",
    "#     nx.draw(g)\n",
    "#     plt.show()\n",
    "\n",
    "# interact(plot_random_graph, n=(2,30), m=(1,10), k=(1,10), p=(0.0, 1.0, 0.001),\n",
    "#          generator={\n",
    "#              'lobster': random_lobster,\n",
    "#              'power law': powerlaw_cluster,\n",
    "#              'Newman-Watts-Strogatz': newman_watts_strogatz,\n",
    "#              u'Erdős-Rényi': erdos_renyi,\n",
    "#          });"
   ]
  }
 ],
 "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.4"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}