05_prioritised_replay_noisy_duelling_ddqn_simple_hospital_sim_1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Prioritised Replay Noisy Duelling Double Deep Q Learning - A simple hospital model\n",
    "\n",
    "In this example we take the previous example of Noisy Duelling Double Q Learning and add a *Prioritised Replay* memory. Using this type of memory, state/actions that have the highest loss (error) when training our policy network are sampled more frequently than state/actions that have low loss. \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",
    "## Noisy layers\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",
    "## Prioritised replay\n",
    "\n",
    "In standard DQN samples are taken randomly from the memory (replay buffer). In *prioritised replay* samples are taken in proportion to their loss when training the network; where the network has the greatest error in predicting the target valur of a state/action, then those samples will be sampled more frequently (which will reduce the error in the network until the sample is not prioritised). In other words, the training focuses more heavenly on samples it gets most wrong, and spends less time training on samples that it can acurately predict already.\n",
    "\n",
    "This priority may also be used as a weight for training the network, but this i snot implemented here; we use loss just for sampling.\n",
    "\n",
    "When we use the loss for priority we add a small value (1e-5) t the loss. This avoids any sample having zero priority (and never having a chance of being sampled). For frequency of sampling we also raise the loss to the power of 'alpha' (default value of 0.6). Smaller values of alpha will compress the differences between samples, making the priority weighting less significant in the frequency of sampling.\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",
    "Duelling DDQN:\n",
    "Wang Z, Schaul T, Hessel M, et al. (2016) Dueling Network Architectures for Deep Reinforcement Learning. arXiv:151106581 http://arxiv.org/abs/1511.06581\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",
    "Prioritised replay:\n",
    "Schaul T, Quan J, Antonoglou I, et al (2016). Prioritized Experience Replay. arXiv:151105952 http://arxiv.org/abs/1511.05952\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 = 250"
   ]
  },
  {
   "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 = memory.sample(BATCH_SIZE)\n",
    "\n",
    "    for state, action, reward, state_next, terminal, index 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 net 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 replay buffer (add 1e-5 to loss to avoid zero priority with no\n",
    "        # chance of being sampled).\n",
    "        loss_numpy = loss_v.data.numpy()\n",
    "        memory.update_priorities(index, loss_numpy + 1e-5)\n",
    "        # Update network gradients\n",
    "        policy_net.optimizer.step()  \n",
    "\n",
    "    return"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "################################################################################\n",
    "#                  5 Define prioritised replay memory class                    #\n",
    "################################################################################\n",
    "\n",
    "\n",
    "class NaivePrioritizedBuffer():\n",
    "    \"\"\"\n",
    "    Based on code from https://github.com/higgsfield/RL-Adventure\n",
    "    \n",
    "    Each sample (state, action, reward, next_state, done) has an associated\n",
    "    priority, which is the loss from training the policy network. The priority\n",
    "    is used to adjust the frequency of sampling.    \n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self, capacity=MEMORY_SIZE, prob_alpha=0.6):\n",
    "        self.prob_alpha = prob_alpha\n",
    "        self.capacity = capacity\n",
    "        self.buffer = []\n",
    "        self.pos = 0\n",
    "        self.priorities = np.zeros((capacity,), dtype=np.float32)\n",
    "    \n",
    "    def remember(self, state, action, reward, next_state, done):\n",
    "        \"\"\"\n",
    "        Add sample (state, action, reward, next_state, done) to memory, or\n",
    "        replace oldest sample if memory full\"\"\"\n",
    "\n",
    "        max_prio = self.priorities.max() if self.buffer else 1.0\n",
    "        \n",
    "        if len(self.buffer) < self.capacity:\n",
    "            # Add new sample when room in memory\n",
    "            self.buffer.append((state, action, reward, next_state, done))\n",
    "        else:\n",
    "            # Replace sample when memory full\n",
    "            self.buffer[self.pos] = (state, action, reward, next_state, done)\n",
    "        \n",
    "        # Set maximum priority present\n",
    "        self.priorities[self.pos] = max_prio\n",
    "        # Increment replacement position\n",
    "        self.pos = (self.pos + 1) % self.capacity\n",
    "    \n",
    "    def sample(self, batch_size, beta=0.4):\n",
    "        # Get priorities\n",
    "        if len(self.buffer) == self.capacity:\n",
    "            prios = self.priorities\n",
    "        else:\n",
    "            prios = self.priorities[:self.pos]\n",
    "        \n",
    "        # Raise priorities by the square of 'alpha' \n",
    "        # (lower alpha compresses differences)\n",
    "        probs  = prios ** self.prob_alpha\n",
    "        \n",
    "        # Normlaise priorities\n",
    "        probs /= probs.sum()\n",
    "        \n",
    "        # Sample using priorities for relative sampling frequency\n",
    "        indices = np.random.choice(len(self.buffer), batch_size, p=probs)\n",
    "        samples = [self.buffer[idx] for idx in indices]\n",
    "        \n",
    "        # Add index to sample (used to update priority after getting new loss)\n",
    "        batch = []        \n",
    "        for index, sample in enumerate(samples):\n",
    "            sample = list(sample)\n",
    "            sample.append(indices[index])\n",
    "            batch.append(sample)\n",
    "        \n",
    "        return batch\n",
    "    \n",
    "    def update_priorities(self, index, priority):\n",
    "        \"\"\"Update sample priority with new loss\"\"\"\n",
    "        self.priorities[index] = priority\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.buffer)"
   ]
  },
  {
   "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);\n",
    "    "
   ]
  },
  {
   "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_net = DQN(observation_space, action_space)\n",
    "    target_net = DQN(observation_space, action_space)\n",
    "    \n",
    "    # Set loss function and optimizer\n",
    "    policy_net.optimizer = optim.Adam(\n",
    "            params=policy_net.parameters(), lr=LEARNING_RATE)\n",
    "    \n",
    "    # Copy weights from policy_net to target\n",
    "    target_net.load_state_dict(policy_net.state_dict())\n",
    "    \n",
    "    # Set target net to eval rather than training mode\n",
    "    # We do not train target net - ot is copied from policy net at intervals\n",
    "    target_net.eval()\n",
    "    \n",
    "    ############################################################################\n",
    "    #                            10 Set up memory                              #\n",
    "    ############################################################################\n",
    "        \n",
    "    # Set up memomry\n",
    "    memory = NaivePrioritizedBuffer()\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 action to take (use evalulation mode)\n",
    "            policy_net.eval()\n",
    "            action = policy_net.act(state)\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",
    "                # Get exploration rate\n",
    "                exploration = policy_net.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",
    "                \n",
    "                # Add to results lists\n",
    "                results_run.append(run)\n",
    "                results_exploration.append(exploration)\n",
    "                results_score.append(total_reward)\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) > REPLAY_START_SIZE:\n",
    "        \n",
    "                # Update policy net\n",
    "                optimize(policy_net, target_net, 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",
    "                    target_net.load_state_dict(policy_net.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: 250, Exploration:  0.000, Average reward: -45.2                           "
     ]
    },
    {
     "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     17.0\n",
      "days over capacity     346.0\n",
      "average patients       502.0\n",
      "average beds           565.0\n",
      "% occupancy             89.0\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
}