07_noisy_bagging_duelling_ddqn_simple_hospital_sim_1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Noisy Bootstrapped Aggregation ('Bagging') Duelling Double Deep Q Learning - A simple hospital model\n",
    "\n",
    "In this example we take the previous example of Bagging Duelling Double Q Learning and add 'noisy layers' to the estimatin of advantage. Adding noise within the network is an alterantive to epsilon-greedy exploration. As the performance of the system improves the amount of noise will reduce in the network, as noise is a parameter in the network which is optimised through the normal network optimization procedure. \n",
    "\n",
    "## A simple hospital simulation model\n",
    "\n",
    "This is an example of a simple hospital bed model where a Reinforcement learning (RL) agent has to learn how to manage the bed stock:\n",
    "\n",
    "    • Default arrivals = 50/day\n",
    "    • Weekend arrival numbers are 50% average arrival numbers\n",
    "    • Weekday arrival numbers are 120% average arrival numbers\n",
    "    • Distribution of inter-arrival time is inverse exponential\n",
    "    • Average length of stay is 7 days (default)\n",
    "    • Distribution of length of stay is inverse exponential\n",
    "    • The RL agent may request a change in bed numbers once a day (default)\n",
    "    • The allowed bed change requests are -20, -10, 0, 10, 20\n",
    "    • Bed changes take 2 days to occur (default)\n",
    "    • The RL agent receives a reward at each action based on the number of free beds or number of patients without a bed\n",
    "    • The simulation is loaded with the average number of patients present\n",
    "    \n",
    "The RL agent must learn to maximise the long term reward (return). The maximum reward = 0, so the agent is learning to minimise the loss for each unoccupied bed or patient without bed.\n",
    "\n",
    "## Reinforcement learning introduction\n",
    "\n",
    "### RL involves:\n",
    "* Trial and error search\n",
    "* Receiving and maximising reward (often delayed)\n",
    "* Linking state -> action -> reward\n",
    "* Must be able to sense something of their environment\n",
    "* Involves uncertainty in sensing and linking action to reward\n",
    "* Learning -> improved choice of actions over time\n",
    "* All models find a way to balance best predicted action vs. exploration\n",
    "\n",
    "### Elements of RL\n",
    "* *Environment*: all observable and unobservable information relevant to us\n",
    "* *Observation*: sensing the environment\n",
    "* *State*: the perceived (or perceivable) environment \n",
    "* *Agent*: senses environment, decides on action, receives and monitors rewards\n",
    "* *Action*: may be discrete (e.g. turn left) or continuous (accelerator pedal)\n",
    "* *Policy* (how to link state to action; often based on probabilities)\n",
    "* *Reward signal*: aim is to accumulate maximum reward over time\n",
    "* *Value function* of a state: prediction of likely/possible long-term reward\n",
    "* *Q*: prediction of likely/possible long-term reward of an *action*\n",
    "* *Advantage*: The difference in Q between actions in a given state (sums to zero for all actions)\n",
    "* *Model* (optional): a simulation of the environment\n",
    "\n",
    "### Types of model\n",
    "\n",
    "* *Model-based*: have model of environment (e.g. a board game)\n",
    "* *Model-free*: used when environment not fully known\n",
    "* *Policy-based*: identify best policy directly\n",
    "* *Value-based*: estimate value of a decision\n",
    "* *Off-policy*: can learn from historic data from other agent\n",
    "* *On-policy*: requires active learning from current decisions\n",
    "\n",
    "\n",
    "## Duelling Deep Q Networks for Reinforcement Learning\n",
    "\n",
    "Q = The expected future rewards discounted over time. This is what we are trying to maximise.\n",
    "\n",
    "The aim is to teach a network to take the current state observations and recommend the action with greatest Q.\n",
    "\n",
    "Duelling is very similar to Double DQN, except that the policy net splits into two. One component reduces to a single value, which will model the state *value*. The other component models the *advantage*, the difference in Q between different actions (the mean value is subtracted from all values, so that the advtantage always sums to zero). These are aggregated to produce Q for each action. \n",
    "\n",
    "<img src=\"./images/duelling_dqn.png\" width=\"500\"/>\n",
    "\n",
    "Q is learned through the Bellman equation, where the Q of any state and action is the immediate reward achieved + the discounted maximum Q value (the best action taken) of next best action, where gamma is the discount rate.\n",
    "\n",
    "$$Q(s,a)=r + \\gamma.maxQ(s',a')$$\n",
    "\n",
    "## Key DQN components\n",
    "\n",
    "<img src=\"./images/dqn_components.png\" width=\"700\"/>\n",
    "\n",
    "\n",
    "## General method for Q learning:\n",
    "\n",
    "Overall aim is to create a neural network that predicts Q. Improvement comes from improved accuracy in predicting 'current' understood Q, and in revealing more about Q as knowledge is gained (some rewards only discovered after time).\n",
    "\n",
    "<img src=\"./images/dqn_process.png\" width=\"600|\"/>\n",
    "    \n",
    "Target networks are used to stabilise models, and are only updated at intervals. Changes to Q values may lead to changes in closely related states (i.e. states close to the one we are in at the time) and as the network tries to correct for errors it can become unstable and suddenly lose signficiant performance. Target networks (e.g. to assess Q) are updated only infrequently (or gradually), so do not have this instability problem.\n",
    "\n",
    "## Training networks\n",
    "\n",
    "Double DQN contains two networks. This ammendment, from simple DQN, is to decouple training of Q for current state and target Q derived from next state which are closely correlated when comparing input features.\n",
    "\n",
    "The *policy network* is used to select action (action with best predicted Q) when playing the game.\n",
    "\n",
    "When training, the predicted best *action* (best predicted Q) is taken from the *policy network*, but the *policy network* is updated using the predicted Q value of the next state from the *target network* (which is updated from the policy network less frequently). So, when training, the action is selected using Q values from the *policy network*, but the the *policy network* is updated to better predict the Q value of that action from the *target network*. The *policy network* is copied across to the *target network* every *n* steps (e.g. 1000).\n",
    "\n",
    "<img src=\"./images/dqn_training.png\" width=\"700|\"/>\n",
    "\n",
    "## Bagging (Bootstrap Aggregation)\n",
    "\n",
    "Each network is trained from the same memory, but have different starting weights and are trained on different bootstrap samples from that memory. In this example actions are chosen randomly from each of the networks (an alternative could be to take the most common action recommended by the networks, or an average output). This bagging method may also be used to have some measure of uncertainty of action by looking at the distribution of actions recommended from the different nets. Bagging may also be used to aid exploration during stages where networks are providing different suggested action.\n",
    "\n",
    "<img src=\"./images/bagging.png\" width=\"800|\"/>\n",
    "\n",
    "## Noisy layers\n",
    "\n",
    "Noisy layers are an alternative to epsilon-greedy exploration (here, we leave the epsilon-greedy code in the model, but set it to reduce to zero immediately after the period of fully random action choice).\n",
    "\n",
    "For every weight in the layer we have a random value that we draw from the normal distribution. This random value is used to add noise to the output. The parameters for the extent of noise for each weight, sigma, are stored within the layer and get trained as part of the standard back-propogation.\n",
    "\n",
    "A modification to normal nosiy layers is to use layers with ‘factorized gaussian noise’. This reduces the number of random numbers to be sampled (so is less computationally expensive). There are two random vectors, one with the size of the input, and the other with the size of the output. A random matrix is created by calculating the outer product of the two vectors.\n",
    "\n",
    "## References\n",
    "\n",
    "Double DQN: \n",
    "van Hasselt H, Guez A, Silver D. (2015) Deep Reinforcement Learning with Double Q-learning. arXiv:150906461 http://arxiv.org/abs/1509.06461\n",
    "\n",
    "Bagging:\n",
    "Osband I, Blundell C, Pritzel A, et al. (2016) Deep Exploration via Bootstrapped DQN. arXiv:160204621 http://arxiv.org/abs/1602.04621\n",
    "\n",
    "Noisy networks:\n",
    "Fortunato M, Azar MG, Piot B, et al. (2019) Noisy Networks for Exploration. arXiv:170610295 http://arxiv.org/abs/1706.10295\n",
    "\n",
    "Code for the nosiy layers comes from:\n",
    "\n",
    "Lapan, M. (2020). Deep Reinforcement Learning Hands-On: Apply modern RL methods to practical problems of chatbots, robotics, discrete optimization, web automation, and more, 2nd Edition. Packt Publishing.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Code structure\n",
    "\n",
    "<img src=\"./images/dqn_program_structure.png\" width=\"700|\"/>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "################################################################################\n",
    "#                           1 Import packages                                  #\n",
    "################################################################################\n",
    "\n",
    "from simpy_envs.env_simple_hospital_bed_1 import HospGym\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import math\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import random\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "from torch.nn import functional as F\n",
    "\n",
    "# Use a double ended queue (deque) for memory\n",
    "# When memory is full, this will replace the oldest value with the new one\n",
    "from collections import deque\n",
    "\n",
    "# Supress all warnings (e.g. deprecation warnings) for regular use\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "################################################################################\n",
    "#                           2 Define model parameters                          #\n",
    "################################################################################\n",
    "\n",
    "# Set whether to display on screen (slows model)\n",
    "DISPLAY_ON_SCREEN = False\n",
    "# Discount rate of future rewards\n",
    "GAMMA = 0.95\n",
    "# Learing rate for neural network\n",
    "LEARNING_RATE = 0.0003\n",
    "# Maximum number of game steps (state, action, reward, next state) to keep\n",
    "MEMORY_SIZE = 1000000\n",
    "# Sample batch size for policy network update\n",
    "BATCH_SIZE = 3\n",
    "# Number of game steps to play before starting training (all random actions)\n",
    "REPLAY_START_SIZE = 365 * 5\n",
    "# Time step between actions\n",
    "TIME_STEP = 1\n",
    "# Number of steps between policy -> target network update\n",
    "SYNC_TARGET_STEPS = 365\n",
    "# Exploration rate (episolon) is probability of choosign a random action\n",
    "EXPLORATION_MAX = 1.0\n",
    "EXPLORATION_MIN = 0.0\n",
    "# Reduction in epsilon with each game step\n",
    "EXPLORATION_DECAY = 0.0\n",
    "# Simulation duration\n",
    "SIM_DURATION = 365\n",
    "# Training episodes\n",
    "TRAINING_EPISODES = 100\n",
    "# Set number of parallel networks\n",
    "NUMBER_OF_NETS = 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "################################################################################\n",
    "#                 3 Define DQN (Duelling Deep Q Network) class                 #\n",
    "#                    (Used for both policy and target nets)                    #\n",
    "################################################################################\n",
    "\n",
    "\"\"\"\n",
    "Code for nosiy layers comes from:\n",
    "\n",
    "Lapan, M. (2020). Deep Reinforcement Learning Hands-On: Apply modern RL methods \n",
    "to practical problems of chatbots, robotics, discrete optimization, \n",
    "web automation, and more, 2nd Edition. Packt Publishing.\n",
    "\"\"\"\n",
    "\n",
    "\n",
    "class NoisyLinear(nn.Linear):\n",
    "    \"\"\"\n",
    "    Noisy layer for network.\n",
    "    \n",
    "    For every weight in the layer we have a random value that we draw from the\n",
    "    normal distribution.Paraemters for the noise, sigma, are stored within the\n",
    "    layer and get trained as part of the standard back-propogation.\n",
    "    \n",
    "    'register_buffer' is used to create tensors in the network that are not\n",
    "    updated during back-propogation. They are used to create normal \n",
    "    distributions to add noise (multiplied by sigma which is a paramater in the\n",
    "    network).\n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self, in_features, out_features,\n",
    "                 sigma_init=0.017, bias=True):\n",
    "        super(NoisyLinear, self).__init__(\n",
    "            in_features, out_features, bias=bias)\n",
    "        w = torch.full((out_features, in_features), sigma_init)\n",
    "        self.sigma_weight = nn.Parameter(w)\n",
    "        z = torch.zeros(out_features, in_features)\n",
    "        self.register_buffer(\"epsilon_weight\", z)\n",
    "        if bias:\n",
    "            w = torch.full((out_features,), sigma_init)\n",
    "            self.sigma_bias = nn.Parameter(w)\n",
    "            z = torch.zeros(out_features)\n",
    "            self.register_buffer(\"epsilon_bias\", z)\n",
    "        self.reset_parameters()\n",
    "\n",
    "    def reset_parameters(self):\n",
    "        std = math.sqrt(3 / self.in_features)\n",
    "        self.weight.data.uniform_(-std, std)\n",
    "        self.bias.data.uniform_(-std, std)\n",
    "\n",
    "    def forward(self, input):\n",
    "        self.epsilon_weight.normal_()\n",
    "        bias = self.bias\n",
    "        if bias is not None:\n",
    "            self.epsilon_bias.normal_()\n",
    "            bias = bias + self.sigma_bias * \\\n",
    "                   self.epsilon_bias.data\n",
    "        v = self.sigma_weight * self.epsilon_weight.data + self.weight\n",
    "        return F.linear(input, v, bias)\n",
    "    \n",
    "\n",
    "class NoisyFactorizedLinear(nn.Linear):\n",
    "    \"\"\"\n",
    "    NoisyNet layer with factorized gaussian noise. This reduces the number of\n",
    "    random numbers to be sampled (so less computationally expensive). There are \n",
    "    two random vectors. One with the size of the input, and the other with the \n",
    "    size of the output. A random matrix is create by calculating the outer \n",
    "    product of the two vectors.\n",
    "    \n",
    "    'register_buffer' is used to create tensors in the network that are not\n",
    "    updated during back-propogation. They are used to create normal \n",
    "    distributions to add noise (multiplied by sigma which is a paramater in the\n",
    "    network).\n",
    "    \"\"\"\n",
    "    def __init__(self, in_features, out_features,\n",
    "                 sigma_zero=0.4, bias=True):\n",
    "        super(NoisyFactorizedLinear, self).__init__(\n",
    "            in_features, out_features, bias=bias)\n",
    "        sigma_init = sigma_zero / math.sqrt(in_features)\n",
    "        w = torch.full((out_features, in_features), sigma_init)\n",
    "        self.sigma_weight = nn.Parameter(w)\n",
    "        z1 = torch.zeros(1, in_features)\n",
    "        self.register_buffer(\"epsilon_input\", z1)\n",
    "        z2 = torch.zeros(out_features, 1)\n",
    "        self.register_buffer(\"epsilon_output\", z2)\n",
    "        if bias:\n",
    "            w = torch.full((out_features,), sigma_init)\n",
    "            self.sigma_bias = nn.Parameter(w)\n",
    "\n",
    "    def forward(self, input):\n",
    "        self.epsilon_input.normal_()\n",
    "        self.epsilon_output.normal_()\n",
    "\n",
    "        func = lambda x: torch.sign(x) * torch.sqrt(torch.abs(x))\n",
    "        eps_in = func(self.epsilon_input.data)\n",
    "        eps_out = func(self.epsilon_output.data)\n",
    "\n",
    "        bias = self.bias\n",
    "        if bias is not None:\n",
    "            bias = bias + self.sigma_bias * eps_out.t()\n",
    "        noise_v = torch.mul(eps_in, eps_out)\n",
    "        v = self.weight + self.sigma_weight * noise_v\n",
    "        return F.linear(input, v, bias)\n",
    "\n",
    "class DQN(nn.Module):\n",
    "\n",
    "    \"\"\"Deep Q Network. Udes for both policy (action) and target (Q) networks.\"\"\"\n",
    "\n",
    "    def __init__(self, observation_space, action_space, neurons_per_layer=48):\n",
    "        \"\"\"Constructor method. Set up neural nets.\"\"\"\n",
    "\n",
    "        # Set starting exploration rate\n",
    "        self.exploration_rate = EXPLORATION_MAX\n",
    "        \n",
    "        # Set up action space (choice of possible actions)\n",
    "        self.action_space = action_space\n",
    "              \n",
    "        \n",
    "        # First layerswill be common to both Advantage and value\n",
    "        super(DQN, self).__init__()\n",
    "        self.feature = nn.Sequential(\n",
    "            nn.Linear(observation_space, neurons_per_layer),\n",
    "            nn.ReLU()            \n",
    "            )\n",
    "        \n",
    "        # Advantage has same number of outputs as the action space\n",
    "        self.advantage = nn.Sequential(\n",
    "            NoisyFactorizedLinear(neurons_per_layer, neurons_per_layer),\n",
    "            nn.ReLU(),\n",
    "            NoisyFactorizedLinear(neurons_per_layer, action_space)\n",
    "            )\n",
    "        \n",
    "        # State value has only one output (one value per state)\n",
    "        self.value = nn.Sequential(\n",
    "            nn.Linear(neurons_per_layer, neurons_per_layer),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(neurons_per_layer, 1)\n",
    "            )        \n",
    "        \n",
    "    def act(self, state):\n",
    "        \"\"\"Act either randomly or by redicting action that gives max Q\"\"\"\n",
    "        \n",
    "        # Act randomly if random number < exploration rate\n",
    "        if np.random.rand() < self.exploration_rate:\n",
    "            action = random.randrange(self.action_space)\n",
    "            \n",
    "        else:\n",
    "            # Otherwise get predicted Q values of actions\n",
    "            q_values = self.forward(torch.FloatTensor(state))\n",
    "            # Get index of action with best Q\n",
    "            action = np.argmax(q_values.detach().numpy()[0])\n",
    "        \n",
    "        return  action\n",
    "        \n",
    "  \n",
    "    def forward(self, x):\n",
    "        x = self.feature(x)\n",
    "        advantage = self.advantage(x)\n",
    "        value = self.value(x)\n",
    "        action_q = value + advantage - advantage.mean()\n",
    "        return action_q"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "################################################################################\n",
    "#                    4 Define policy net training function                     #\n",
    "################################################################################\n",
    "\n",
    "def optimize(policy_net, target_net, memory):\n",
    "    \"\"\"\n",
    "    Update  model by sampling from memory.\n",
    "    Uses policy network to predict best action (best Q).\n",
    "    Uses target network to provide target of Q for the selected next action.\n",
    "    \"\"\"\n",
    "      \n",
    "    # Do not try to train model if memory is less than reqired batch size\n",
    "    if len(memory) < BATCH_SIZE:\n",
    "        return    \n",
    " \n",
    "    # Reduce exploration rate (exploration rate is stored in policy net)\n",
    "    policy_net.exploration_rate *= EXPLORATION_DECAY\n",
    "    policy_net.exploration_rate = max(EXPLORATION_MIN, \n",
    "                                      policy_net.exploration_rate)\n",
    "    # Sample a random batch from memory\n",
    "    batch = random.sample(memory, BATCH_SIZE)\n",
    "    for state, action, reward, state_next, terminal in batch:\n",
    "        \n",
    "        state_action_values = policy_net(torch.FloatTensor(state))\n",
    "        \n",
    "        # Get target Q for policy net update\n",
    "       \n",
    "        if not terminal:\n",
    "            # For non-terminal actions get Q from policy net\n",
    "            expected_state_action_values = policy_net(torch.FloatTensor(state))\n",
    "            # Detach next state values from gradients to prevent updates\n",
    "            expected_state_action_values = expected_state_action_values.detach()\n",
    "            # Get next state action with best Q from the policy net (double DQN)\n",
    "            policy_next_state_values = policy_net(torch.FloatTensor(state_next))\n",
    "            policy_next_state_values = policy_next_state_values.detach()\n",
    "            best_action = np.argmax(policy_next_state_values[0].numpy())\n",
    "            # Get target net next state\n",
    "            next_state_action_values = target_net(torch.FloatTensor(state_next))\n",
    "            # Use detach again to prevent target net gradients being updated\n",
    "            next_state_action_values = next_state_action_values.detach()\n",
    "            best_next_q = next_state_action_values[0][best_action].numpy()\n",
    "            updated_q = reward + (GAMMA * best_next_q)      \n",
    "            expected_state_action_values[0][action] = updated_q\n",
    "        else:\n",
    "            # For termal actions Q = reward (-1)\n",
    "            expected_state_action_values = policy_net(torch.FloatTensor(state))\n",
    "            # Detach values from gradients to prevent gradient update\n",
    "            expected_state_action_values = expected_state_action_values.detach()\n",
    "            # Set Q for all actions to reward (-1)\n",
    "            expected_state_action_values[0] = reward\n",
    " \n",
    "        # Set network to training mode\n",
    "        policy_net.train()\n",
    "        # Reset net gradients\n",
    "        policy_net.optimizer.zero_grad()  \n",
    "        # calculate loss\n",
    "        loss_v = nn.MSELoss()(state_action_values, expected_state_action_values)\n",
    "        # Backpropogate loss\n",
    "        loss_v.backward()\n",
    "        # Update network gradients\n",
    "        policy_net.optimizer.step()  \n",
    "\n",
    "    return"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "################################################################################\n",
    "#                            5 Define memory class                             #\n",
    "################################################################################\n",
    "\n",
    "class Memory():\n",
    "    \"\"\"\n",
    "    Replay memory used to train model.\n",
    "    Limited length memory (using deque, double ended queue from collections).\n",
    "      - When memory full deque replaces oldest data with newest.\n",
    "    Holds, state, action, reward, next state, and episode done.\n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self):\n",
    "        \"\"\"Constructor method to initialise replay memory\"\"\"\n",
    "        self.memory = deque(maxlen=MEMORY_SIZE)\n",
    "\n",
    "    def remember(self, state, action, reward, next_state, done):\n",
    "        \"\"\"state/action/reward/next_state/done\"\"\"\n",
    "        self.memory.append((state, action, reward, next_state, done))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "################################################################################\n",
    "#                       6  Define results plotting function                    #\n",
    "################################################################################\n",
    "\n",
    "def plot_results(run, exploration, score, run_details):\n",
    "    \"\"\"Plot and report results at end of run\"\"\"\n",
    "    \n",
    "    # Get beds and patients from run_detals DataFrame\n",
    "    beds = run_details['beds']\n",
    "    patients = run_details['patients']    \n",
    "    \n",
    "    # Set up chart (ax1 and ax2 share x-axis to combine two plots on one graph)\n",
    "    fig = plt.figure(figsize=(9,5))\n",
    "    ax1 = fig.add_subplot(121)\n",
    "    ax2 = ax1.twinx()\n",
    "    \n",
    "    # Plot results\n",
    "    average_rewards = np.array(score)/SIM_DURATION\n",
    "    ax1.plot(run, exploration, label='exploration', color='g')\n",
    "    ax2.plot(run, average_rewards, label='average reward', color='r')\n",
    "    \n",
    "    # Set axes\n",
    "    ax1.set_xlabel('run')\n",
    "    ax1.set_ylabel('exploration', color='g')\n",
    "    ax2.set_ylabel('average reward', color='r')\n",
    "    \n",
    "    # Show last run tracker of beds and patients\n",
    "\n",
    "    ax3 = fig.add_subplot(122)\n",
    "    day = np.arange(len(beds))*TIME_STEP\n",
    "    ax3.plot(day, beds, label='beds', color='g')\n",
    "    ax3.plot(day, patients, label='patients', color='r')\n",
    "    \n",
    "    # Set axes\n",
    "    ax3.set_xlabel('day')\n",
    "    ax3.set_ylabel('beds/patients')\n",
    "    ax3.set_ylim(0)\n",
    "    ax3.legend()\n",
    "    ax3.grid()\n",
    "    # Show\n",
    "    \n",
    "    plt.tight_layout(pad=2)\n",
    "    plt.show()\n",
    "    \n",
    "    # Calculate summary results\n",
    "    results = pd.Series()\n",
    "    beds = np.array(beds)\n",
    "    patients = np.array(patients)\n",
    "    results['days under capacity'] = np.sum(patients > beds)\n",
    "    results['days over capacity'] = np.sum(beds > patients)\n",
    "    results['average patients'] = np.round(np.mean(patients), 0)\n",
    "    results['average beds'] = np.round(np.mean(beds), 0)\n",
    "    results['% occupancy'] = np.round((patients.sum() / beds.sum() * 100), 1)\n",
    "    print (results);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "################################################################################\n",
    "#                                 7 Main program                               #\n",
    "################################################################################\n",
    "\n",
    "\n",
    "def hosp_bed_management():\n",
    "    \"\"\"Main program loop\"\"\"\n",
    "    \n",
    "    ############################################################################\n",
    "    #                          8 Set up environment                            #\n",
    "    ############################################################################\n",
    "        \n",
    "    # Set up game environemnt\n",
    "    sim = HospGym(sim_duration=SIM_DURATION, time_step=TIME_STEP)\n",
    "\n",
    "    # Get number of observations returned for state\n",
    "    observation_space = sim.observation_size\n",
    "    \n",
    "    # Get number of actions possible\n",
    "    action_space = sim.action_size\n",
    "    \n",
    "    ############################################################################\n",
    "    #                    9 Set up policy and target nets                       #\n",
    "    ############################################################################\n",
    "    \n",
    "    # Set up policy and target neural nets\n",
    "    policy_nets = [DQN(observation_space, action_space)\n",
    "                   for i in range(NUMBER_OF_NETS)]\n",
    "    target_nets = [DQN(observation_space, action_space)\n",
    "                   for i in range(NUMBER_OF_NETS)]\n",
    "    \n",
    "    # Set optimizer, copy weights from policy_net to target, and \n",
    "    for i in range(NUMBER_OF_NETS):\n",
    "        # Set optimizer\n",
    "        policy_nets[i].optimizer = optim.Adam(\n",
    "            params=policy_nets[i].parameters(), lr=LEARNING_RATE)\n",
    "        # Copy weights from policy -> target\n",
    "        target_nets[i].load_state_dict(policy_nets[i].state_dict())\n",
    "        # Set target net to eval rather than training mode\n",
    "        target_nets[i].eval() \n",
    "    \n",
    "    ############################################################################\n",
    "    #                            10 Set up memory                              #\n",
    "    ############################################################################\n",
    "        \n",
    "    # Set up memomry\n",
    "    memory = Memory()\n",
    "    \n",
    "    ############################################################################\n",
    "    #                     11 Set up + start training loop                      #\n",
    "    ############################################################################\n",
    "    \n",
    "    # Set up run counter and learning loop    \n",
    "    run = 0\n",
    "    all_steps = 0\n",
    "    continue_learning = True\n",
    "    \n",
    "    # Set up list for results\n",
    "    results_run = []\n",
    "    results_exploration = []\n",
    "    results_score = []\n",
    "    \n",
    "    # Continue repeating games (episodes) until target complete\n",
    "    while continue_learning:\n",
    "        \n",
    "        ########################################################################\n",
    "        #                           12 Play episode                            #\n",
    "        ########################################################################\n",
    "        \n",
    "        # Increment run (episode) counter\n",
    "        run += 1\n",
    "        \n",
    "        ########################################################################\n",
    "        #                             13 Reset game                            #\n",
    "        ########################################################################\n",
    "        \n",
    "        # Reset game environment and get first state observations\n",
    "        state = sim.reset()\n",
    "        \n",
    "        # Trackers for state\n",
    "        weekday = []\n",
    "        beds = []\n",
    "        patients = []\n",
    "        spare_beds = []\n",
    "        pending_change = []\n",
    "        rewards = [] \n",
    "        \n",
    "        # Reset total reward\n",
    "        total_reward = 0    \n",
    "   \n",
    "        # Reshape state into 2D array with state obsverations as first 'row'\n",
    "        state = np.reshape(state, [1, observation_space])\n",
    "        \n",
    "        # Continue loop until episode complete\n",
    "        while True:\n",
    "            \n",
    "        ########################################################################\n",
    "        #                       14 Game episode loop                           #\n",
    "        ########################################################################\n",
    "\n",
    "            ####################################################################\n",
    "            #                       15 Get action                              #\n",
    "            ####################################################################\n",
    "            \n",
    "            # Get actions to take (use evalulation mode)\n",
    "            actions = []\n",
    "            for i in range(NUMBER_OF_NETS):\n",
    "                policy_nets[i].eval()\n",
    "                actions.append(policy_nets[i].act(state))\n",
    "                \n",
    "            # Randomly choose an action from net actions\n",
    "            random_index = random.randint(0, NUMBER_OF_NETS - 1)\n",
    "            action = actions[random_index]     \n",
    "            \n",
    "            ####################################################################\n",
    "            #                 16 Play action (get S', R, T)                    #\n",
    "            ####################################################################\n",
    "            \n",
    "            # Act\n",
    "            state_next, reward, terminal, info = sim.step(action)\n",
    "            total_reward += reward\n",
    "            \n",
    "            # Update trackers\n",
    "            weekday.append(state_next[0])\n",
    "            beds.append(state_next[1])\n",
    "            patients.append(state_next[2])\n",
    "            spare_beds.append(state_next[3])\n",
    "            pending_change.append(state_next[4])\n",
    "            rewards.append(reward)\n",
    "                                                          \n",
    "            # Reshape state into 2D array with state obsverations as first 'row'\n",
    "            state_next = np.reshape(state_next, [1, observation_space])\n",
    "            \n",
    "            # Update display if needed\n",
    "            if DISPLAY_ON_SCREEN:\n",
    "                sim.render()\n",
    "            \n",
    "            ####################################################################\n",
    "            #                  17 Add S/A/R/S/T to memory                      #\n",
    "            ####################################################################\n",
    "            \n",
    "            # Record state, action, reward, new state & terminal\n",
    "            memory.remember(state, action, reward, state_next, terminal)\n",
    "            \n",
    "            # Update state\n",
    "            state = state_next\n",
    "            \n",
    "            ####################################################################\n",
    "            #                  18 Check for end of episode                     #\n",
    "            ####################################################################\n",
    "            \n",
    "            # Actions to take if end of game episode\n",
    "            if terminal:\n",
    "                # Print results\n",
    "                # Get exploration rate\n",
    "                exploration = policy_nets[0].exploration_rate\n",
    "                # Clear print row content\n",
    "                clear_row = '\\r' + ' '*79 + '\\r'\n",
    "                print (clear_row, end ='')\n",
    "                print (f'Run: {run}, ', end='')\n",
    "                print (f'Exploration: {exploration: .3f}, ', end='')\n",
    "                average_reward = total_reward/SIM_DURATION\n",
    "                print (f'Average reward: {average_reward:4.1f}', end='')\n",
    "                # Add results to lists\n",
    "                results_run.append(run)\n",
    "                results_exploration.append(exploration)\n",
    "                results_score.append(total_reward)\n",
    "\n",
    "                \n",
    "                ################################################################\n",
    "                #             18b Check for end of learning                    #\n",
    "                ################################################################\n",
    "                \n",
    "                if run == TRAINING_EPISODES:\n",
    "                    continue_learning = False\n",
    "                \n",
    "                # End episode loop\n",
    "                break\n",
    "            \n",
    "            \n",
    "            ####################################################################\n",
    "            #                        19 Update policy net                      #\n",
    "            ####################################################################\n",
    "            \n",
    "            # Avoid training model if memory is not of sufficient length\n",
    "            if len(memory.memory) > REPLAY_START_SIZE:\n",
    "        \n",
    "                # Update policy net\n",
    "                for i in range(NUMBER_OF_NETS):\n",
    "                    optimize(policy_nets[i], target_nets[i], memory.memory)\n",
    "\n",
    "                ################################################################\n",
    "                #             20 Update target net periodically                #\n",
    "                ################################################################\n",
    "                \n",
    "                # Use load_state_dict method to copy weights from policy net\n",
    "                if all_steps % SYNC_TARGET_STEPS == 0:\n",
    "                    for i in range(NUMBER_OF_NETS):\n",
    "                        target_nets[i].load_state_dict(\n",
    "                            policy_nets[i].state_dict())\n",
    "                \n",
    "    ############################################################################\n",
    "    #                      21 Learning complete - plot results                 #\n",
    "    ############################################################################\n",
    "\n",
    "    # Add last run to DataFrame. summarise, and return\n",
    "    run_details = pd.DataFrame()\n",
    "    run_details['weekday'] = weekday \n",
    "    run_details['beds'] = beds\n",
    "    run_details['patients'] = patients\n",
    "    run_details['spare_beds'] = spare_beds\n",
    "    run_details['pending_change'] = pending_change\n",
    "    run_details['reward'] = rewards    \n",
    "        \n",
    "    # Target reached. Plot results\n",
    "    plot_results(\n",
    "        results_run, results_exploration, results_score, run_details)\n",
    "    \n",
    "    return run_details"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Run: 100, Exploration:  0.000, Average reward: -40.1                           "
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x360 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "days under capacity    116.0\n",
      "days over capacity     245.0\n",
      "average patients       496.0\n",
      "average beds           526.0\n",
      "% occupancy             94.3\n",
      "dtype: float64\n"
     ]
    }
   ],
   "source": [
    "# Run model and return last run results by day\n",
    "last_run = hosp_bed_management()"
   ]
  }
 ],
 "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}