11_qambo_noisy_bagging_prioritised_3dqn.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Nosy Bagging Duelling Prioritised Replay Double Deep Q Learning - A simple ambulance dispatch point allocation model\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",
    "## 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",
    "## 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",
    "The memory stores the priority/loss of state/action/Next_state/reward, and this is particular to each network, so we create a separate memory for each network.\n",
    "\n",
    "## References\n",
    "\n",
    "Double DQN:\n",
    "\n",
    "Mnih, V., Kavukcuoglu, K., Silver, D. et al. Human-level control through deep reinforcement learning. Nature 518, 529–533 (2015). https://doi.org/10.1038/nature14236\n",
    "\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",
    "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",
    "\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",
    "\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 amboworld.environment import Env\n",
    "\n",
    "import math\n",
    "import matplotlib.pyplot as plt\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",
    "\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.99\n",
    "# Learing rate for neural network\n",
    "LEARNING_RATE = 0.003\n",
    "# Maximum number of game steps (state, action, reward, next state) to keep\n",
    "MEMORY_SIZE = 10000000\n",
    "# Sample batch size for policy network update\n",
    "BATCH_SIZE = 5\n",
    "# Number of game steps to play before starting training (all random actions)\n",
    "REPLAY_START_SIZE = 50000\n",
    "# Number of steps between policy -> target network update\n",
    "SYNC_TARGET_STEPS = 1000\n",
    "# Exploration rate (epsilon) is probability of choosing 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",
    "# Training episodes\n",
    "TRAINING_EPISODES = 50\n",
    "\n",
    "# Set number of parallel networks\n",
    "NUMBER_OF_NETS = 5\n",
    "# Results filename\n",
    "RESULTS_NAME = 'bagging_pr_noisy_d3qn'\n",
    "\n",
    "# SIM PARAMETERS\n",
    "RANDOM_SEED = 42\n",
    "SIM_DURATION = 5000\n",
    "NUMBER_AMBULANCES = 3\n",
    "NUMBER_INCIDENT_POINTS = 1\n",
    "INCIDENT_RADIUS = 2\n",
    "NUMBER_DISPTACH_POINTS = 25\n",
    "AMBOWORLD_SIZE = 50\n",
    "INCIDENT_INTERVAL = 60\n",
    "EPOCHS = 2\n",
    "AMBO_SPEED = 60\n",
    "AMBO_FREE_FROM_HOSPITAL = False"
   ]
  },
  {
   "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):\n",
    "        \"\"\"Constructor method. Set up neural nets.\"\"\"\n",
    "        \n",
    "        # nerurones per hidden layer = 2 * max of observations or actions\n",
    "        neurons_per_layer = 2 * max(observation_space, action_space)\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, mean_call_to_arrival, \n",
    "                 mean_assignment_to_arrival):\n",
    "    \"\"\"Plot and report results at end of run\"\"\"\n",
    "\n",
    "    # Set up chart (ax1 and ax2 share x-axis to combine two plots on one graph)\n",
    "    fig = plt.figure(figsize=(6,6))\n",
    "    ax1 = fig.add_subplot(111)\n",
    "    ax2 = ax1.twinx()\n",
    "\n",
    "    # Plot results\n",
    "    lns1 = ax1.plot(\n",
    "        run, exploration, label='exploration', color='g', linestyle=':')\n",
    "\n",
    "    lns2 = ax2.plot(run, mean_call_to_arrival,\n",
    "             label='call to arrival', color='r')\n",
    "    lns3 = ax2.plot(run, mean_assignment_to_arrival,\n",
    "             label='assignment to arrival', color='b', linestyle='--')\n",
    "\n",
    "    # Get combined legend\n",
    "    lns = lns1 + lns2 + lns3\n",
    "    labs = [l.get_label() for l in lns]\n",
    "    ax1.legend(lns, labs, loc='upper center', bbox_to_anchor=(0.5, -0.1), ncol=3)\n",
    "        \n",
    "    # Set axes\n",
    "    ax1.set_xlabel('run')\n",
    "    ax1.set_ylabel('exploration')\n",
    "    ax2.set_ylabel('Response time')\n",
    "    filename = 'output/' + RESULTS_NAME +'.png'\n",
    "    plt.savefig(filename, dpi=300)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "################################################################################\n",
    "#                                 7 Main program                               #\n",
    "################################################################################\n",
    "\n",
    "def qambo():\n",
    "    \"\"\"Main program loop\"\"\"\n",
    "\n",
    "    ############################################################################\n",
    "    #                          8 Set up environment                            #\n",
    "    ############################################################################\n",
    "\n",
    "    # Set up game environemnt\n",
    "    sim = Env(\n",
    "        random_seed = RANDOM_SEED,\n",
    "        duration_incidents = SIM_DURATION,\n",
    "        number_ambulances = NUMBER_AMBULANCES,\n",
    "        number_incident_points = NUMBER_INCIDENT_POINTS,\n",
    "        incident_interval = INCIDENT_INTERVAL,\n",
    "        number_epochs = EPOCHS,\n",
    "        number_dispatch_points = NUMBER_DISPTACH_POINTS,\n",
    "        incident_range = INCIDENT_RADIUS,\n",
    "        max_size = AMBOWORLD_SIZE,\n",
    "        ambo_kph = AMBO_SPEED,\n",
    "        ambo_free_from_hospital = AMBO_FREE_FROM_HOSPITAL\n",
    "    )\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_number\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",
    "    best_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 = [NaivePrioritizedBuffer() for i in range(NUMBER_OF_NETS)]\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",
    "    best_reward = -np.inf\n",
    "\n",
    "    # Set up list for results\n",
    "    results_run = []\n",
    "    results_exploration = []\n",
    "    results_score = []\n",
    "    results_mean_call_to_arrival = []\n",
    "    results_mean_assignment_to_arrival = []\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",
    "        # Reset total reward and rewards list\n",
    "        total_reward = 0\n",
    "        rewards = []\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",
    "            rewards.append(reward)\n",
    "\n",
    "            # Reshape state into 2D array with state observations 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",
    "            for i in range(NUMBER_OF_NETS):\n",
    "                memory[i].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_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 = np.mean(rewards)\n",
    "                print(f'Average reward: {average_reward:4.1f}, ', end='')\n",
    "                mean_assignment_to_arrival = np.mean(info['assignment_to_arrival'])\n",
    "                print(f'Mean assignment to arrival: {mean_assignment_to_arrival:4.1f}, ', end='')\n",
    "                mean_call_to_arrival = np.mean(info['call_to_arrival'])\n",
    "                print(f'Mean call to arrival: {mean_call_to_arrival:4.1f}, ', end='')\n",
    "                demand_met = info['fraction_demand_met']\n",
    "                print(f'Demand met {demand_met:0.3f}')\n",
    "\n",
    "                # Add to results lists\n",
    "                results_run.append(run)\n",
    "                results_exploration.append(exploration)\n",
    "                results_score.append(total_reward)\n",
    "                results_mean_call_to_arrival.append(mean_call_to_arrival)\n",
    "                results_mean_assignment_to_arrival.append(mean_assignment_to_arrival)\n",
    "\n",
    "                # Save model if best reward\n",
    "                total_reward = np.sum(rewards)\n",
    "                if total_reward > best_reward:\n",
    "                    best_reward = total_reward\n",
    "                    # Copy weights to best net\n",
    "                    for i in range(NUMBER_OF_NETS):\n",
    "                        best_nets[i].load_state_dict(policy_nets[i].state_dict())\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",
    "            #                        19 Update policy net                      #\n",
    "            ####################################################################\n",
    "            \n",
    "            # Avoid training model if memory is not of sufficient length\n",
    "            if len(memory[0]) > 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[i])\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 and save results                 #\n",
    "    ############################################################################\n",
    "\n",
    "    # Target reached. Plot results\n",
    "    plot_results(results_run, results_exploration, results_score,\n",
    "                 results_mean_call_to_arrival, results_mean_assignment_to_arrival)\n",
    "    \n",
    "    # SAVE RESULTS \n",
    "    run_details = pd.DataFrame()\n",
    "    run_details['run'] = results_run\n",
    "    run_details['exploration '] = results_exploration\n",
    "    run_details['mean_call_to_arrival'] = results_mean_call_to_arrival\n",
    "    run_details['mean_assignment_to_arrival'] = results_mean_assignment_to_arrival\n",
    "    filename = 'output/' + RESULTS_NAME + '.csv'\n",
    "    run_details.to_csv(filename, index=False)\n",
    "\n",
    "    ############################################################################\n",
    "    #                             Test best model                              #\n",
    "    ############################################################################\n",
    "    \n",
    "    print()\n",
    "    print('Test Model')\n",
    "    print('----------')\n",
    "    \n",
    "    for i in range(NUMBER_OF_NETS):\n",
    "        best_nets[i].eval()\n",
    "        best_nets[i].exploration_rate = 0\n",
    "\n",
    "    # Set up results dictionary\n",
    "    results = dict()\n",
    "    results['call_to_arrival'] = []\n",
    "    results['assign_to_arrival'] = []\n",
    "    results['demand_met'] = []\n",
    "\n",
    "    # Replicate model runs\n",
    "    for run in range(30):\n",
    "\n",
    "        # Reset game environment and get first state observations\n",
    "        state = sim.reset()\n",
    "        state = np.reshape(state, [1, observation_space])\n",
    "\n",
    "        # Continue loop until episode complete\n",
    "        while True:\n",
    "            # Get actions to take (use evalulation mode)\n",
    "            actions = []\n",
    "            for i in range(NUMBER_OF_NETS):\n",
    "                actions.append(best_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",
    "            # Act\n",
    "            state_next, reward, terminal, info = sim.step(action)\n",
    "            # Reshape state into 2D array with state observations as first 'row'\n",
    "            state_next = np.reshape(state_next, [1, observation_space])\n",
    "            # Update state\n",
    "            state = state_next\n",
    "            if terminal:\n",
    "                print(f'Run: {run}, ', end='')\n",
    "                mean_assignment_to_arrival = np.mean(info['assignment_to_arrival'])\n",
    "                print(f'Mean assignment to arrival: {mean_assignment_to_arrival:4.1f}, ', end='')\n",
    "                mean_call_to_arrival = np.mean(info['call_to_arrival'])\n",
    "                print(f'Mean call to arrival: {mean_call_to_arrival:4.1f}, ', end='')\n",
    "                demand_met = info['fraction_demand_met']\n",
    "                print(f'Demand met: {demand_met:0.3f}')\n",
    "\n",
    "                # Add to results\n",
    "                results['call_to_arrival'].append(mean_call_to_arrival)\n",
    "                results['assign_to_arrival'].append(mean_assignment_to_arrival)\n",
    "                results['demand_met'].append(demand_met)\n",
    "                \n",
    "                # End episode loop\n",
    "                break\n",
    "\n",
    "    results = pd.DataFrame(results)\n",
    "    filename = './output/results_' + RESULTS_NAME +'.csv'\n",
    "    results.to_csv(filename, index=False)\n",
    "    print()\n",
    "    print(results.describe())    \n",
    "\n",
    "    return run_details"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Run: 1, Exploration:  1.000, Average reward: -710.7, Mean assignment to arrival: 24.7, Mean call to arrival: 30.5, Demand met 0.999\n",
      "Run: 2, Exploration:  1.000, Average reward: -709.4, Mean assignment to arrival: 24.7, Mean call to arrival: 30.6, Demand met 1.000\n",
      "Run: 3, Exploration:  1.000, Average reward: -716.9, Mean assignment to arrival: 24.8, Mean call to arrival: 30.4, Demand met 1.000\n",
      "Run: 4, Exploration:  1.000, Average reward: -718.5, Mean assignment to arrival: 24.8, Mean call to arrival: 29.7, Demand met 1.000\n",
      "Run: 5, Exploration:  1.000, Average reward: -723.5, Mean assignment to arrival: 24.9, Mean call to arrival: 31.0, Demand met 1.000\n",
      "Run: 6, Exploration:  1.000, Average reward: -722.0, Mean assignment to arrival: 24.9, Mean call to arrival: 30.4, Demand met 0.999\n",
      "Run: 7, Exploration:  1.000, Average reward: -712.1, Mean assignment to arrival: 24.7, Mean call to arrival: 29.9, Demand met 1.000\n",
      "Run: 8, Exploration:  1.000, Average reward: -720.5, Mean assignment to arrival: 24.8, Mean call to arrival: 30.5, Demand met 0.999\n",
      "Run: 9, Exploration:  1.000, Average reward: -724.3, Mean assignment to arrival: 24.9, Mean call to arrival: 30.7, Demand met 1.000\n",
      "Run: 10, Exploration:  1.000, Average reward: -701.1, Mean assignment to arrival: 24.4, Mean call to arrival: 29.6, Demand met 1.000\n",
      "Run: 11, Exploration:  0.000, Average reward: -252.4, Mean assignment to arrival: 13.9, Mean call to arrival: 17.0, Demand met 1.000\n",
      "Run: 12, Exploration:  0.000, Average reward: -343.1, Mean assignment to arrival: 16.7, Mean call to arrival: 20.3, Demand met 1.000\n",
      "Run: 13, Exploration:  0.000, Average reward: -342.1, Mean assignment to arrival: 17.0, Mean call to arrival: 20.3, Demand met 1.000\n",
      "Run: 14, Exploration:  0.000, Average reward: -571.0, Mean assignment to arrival: 22.1, Mean call to arrival: 26.5, Demand met 1.000\n",
      "Run: 15, Exploration:  0.000, Average reward: -457.7, Mean assignment to arrival: 19.8, Mean call to arrival: 24.4, Demand met 1.000\n",
      "Run: 16, Exploration:  0.000, Average reward: -468.2, Mean assignment to arrival: 20.3, Mean call to arrival: 25.0, Demand met 1.000\n",
      "Run: 17, Exploration:  0.000, Average reward: -369.7, Mean assignment to arrival: 16.9, Mean call to arrival: 20.4, Demand met 1.000\n",
      "Run: 18, Exploration:  0.000, Average reward: -334.9, Mean assignment to arrival: 15.8, Mean call to arrival: 19.5, Demand met 1.000\n",
      "Run: 19, Exploration:  0.000, Average reward: -408.0, Mean assignment to arrival: 18.0, Mean call to arrival: 22.1, Demand met 1.000\n",
      "Run: 20, Exploration:  0.000, Average reward: -328.1, Mean assignment to arrival: 15.6, Mean call to arrival: 19.2, Demand met 1.000\n",
      "Run: 21, Exploration:  0.000, Average reward: -303.6, Mean assignment to arrival: 14.9, Mean call to arrival: 18.5, Demand met 1.000\n",
      "Run: 22, Exploration:  0.000, Average reward: -333.7, Mean assignment to arrival: 15.4, Mean call to arrival: 18.5, Demand met 1.000\n",
      "Run: 23, Exploration:  0.000, Average reward: -374.7, Mean assignment to arrival: 17.4, Mean call to arrival: 21.6, Demand met 1.000\n",
      "Run: 24, Exploration:  0.000, Average reward: -304.5, Mean assignment to arrival: 15.5, Mean call to arrival: 19.5, Demand met 1.000\n",
      "Run: 25, Exploration:  0.000, Average reward: -318.7, Mean assignment to arrival: 15.9, Mean call to arrival: 19.2, Demand met 1.000\n",
      "Run: 26, Exploration:  0.000, Average reward: -337.1, Mean assignment to arrival: 15.8, Mean call to arrival: 19.5, Demand met 1.000\n",
      "Run: 27, Exploration:  0.000, Average reward: -299.0, Mean assignment to arrival: 15.5, Mean call to arrival: 18.8, Demand met 1.000\n",
      "Run: 28, Exploration:  0.000, Average reward: -362.3, Mean assignment to arrival: 16.9, Mean call to arrival: 20.4, Demand met 1.000\n",
      "Run: 29, Exploration:  0.000, Average reward: -483.2, Mean assignment to arrival: 20.0, Mean call to arrival: 24.6, Demand met 1.000\n",
      "Run: 30, Exploration:  0.000, Average reward: -398.8, Mean assignment to arrival: 17.7, Mean call to arrival: 21.3, Demand met 1.000\n",
      "Run: 31, Exploration:  0.000, Average reward: -427.0, Mean assignment to arrival: 18.3, Mean call to arrival: 22.1, Demand met 1.000\n",
      "Run: 32, Exploration:  0.000, Average reward: -338.3, Mean assignment to arrival: 16.2, Mean call to arrival: 19.9, Demand met 1.000\n",
      "Run: 33, Exploration:  0.000, Average reward: -445.8, Mean assignment to arrival: 18.7, Mean call to arrival: 22.4, Demand met 1.000\n",
      "Run: 34, Exploration:  0.000, Average reward: -365.8, Mean assignment to arrival: 17.0, Mean call to arrival: 20.4, Demand met 1.000\n",
      "Run: 35, Exploration:  0.000, Average reward: -358.7, Mean assignment to arrival: 16.4, Mean call to arrival: 20.3, Demand met 1.000\n",
      "Run: 36, Exploration:  0.000, Average reward: -359.4, Mean assignment to arrival: 16.8, Mean call to arrival: 20.4, Demand met 1.000\n",
      "Run: 37, Exploration:  0.000, Average reward: -376.7, Mean assignment to arrival: 17.5, Mean call to arrival: 21.1, Demand met 1.000\n",
      "Run: 38, Exploration:  0.000, Average reward: -363.2, Mean assignment to arrival: 16.6, Mean call to arrival: 20.2, Demand met 1.000\n",
      "Run: 39, Exploration:  0.000, Average reward: -364.2, Mean assignment to arrival: 17.1, Mean call to arrival: 20.9, Demand met 1.000\n",
      "Run: 40, Exploration:  0.000, Average reward: -452.8, Mean assignment to arrival: 19.0, Mean call to arrival: 22.6, Demand met 1.000\n",
      "Run: 41, Exploration:  0.000, Average reward: -387.0, Mean assignment to arrival: 17.4, Mean call to arrival: 21.0, Demand met 1.000\n",
      "Run: 42, Exploration:  0.000, Average reward: -402.4, Mean assignment to arrival: 18.2, Mean call to arrival: 22.1, Demand met 1.000\n",
      "Run: 43, Exploration:  0.000, Average reward: -395.8, Mean assignment to arrival: 17.5, Mean call to arrival: 21.9, Demand met 1.000\n",
      "Run: 44, Exploration:  0.000, Average reward: -411.7, Mean assignment to arrival: 18.0, Mean call to arrival: 21.9, Demand met 1.000\n",
      "Run: 45, Exploration:  0.000, Average reward: -369.3, Mean assignment to arrival: 16.8, Mean call to arrival: 20.4, Demand met 1.000\n",
      "Run: 46, Exploration:  0.000, Average reward: -359.2, Mean assignment to arrival: 16.6, Mean call to arrival: 20.2, Demand met 1.000\n",
      "Run: 47, Exploration:  0.000, Average reward: -388.2, Mean assignment to arrival: 17.7, Mean call to arrival: 21.1, Demand met 1.000\n",
      "Run: 48, Exploration:  0.000, Average reward: -390.6, Mean assignment to arrival: 18.1, Mean call to arrival: 21.7, Demand met 1.000\n",
      "Run: 49, Exploration:  0.000, Average reward: -411.2, Mean assignment to arrival: 18.1, Mean call to arrival: 22.4, Demand met 1.000\n",
      "Run: 50, Exploration:  0.000, Average reward: -351.1, Mean assignment to arrival: 16.7, Mean call to arrival: 20.5, Demand met 1.000\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x432 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Test Model\n",
      "----------\n",
      "Run: 0, Mean assignment to arrival: 11.8, Mean call to arrival: 14.3, Demand met: 1.000\n",
      "Run: 1, Mean assignment to arrival: 11.9, Mean call to arrival: 14.8, Demand met: 1.000\n",
      "Run: 2, Mean assignment to arrival: 11.8, Mean call to arrival: 14.6, Demand met: 1.000\n",
      "Run: 3, Mean assignment to arrival: 11.9, Mean call to arrival: 14.5, Demand met: 1.000\n",
      "Run: 4, Mean assignment to arrival: 12.1, Mean call to arrival: 15.1, Demand met: 1.000\n",
      "Run: 5, Mean assignment to arrival: 11.6, Mean call to arrival: 14.2, Demand met: 1.000\n",
      "Run: 6, Mean assignment to arrival: 11.9, Mean call to arrival: 14.6, Demand met: 1.000\n",
      "Run: 7, Mean assignment to arrival: 11.8, Mean call to arrival: 14.4, Demand met: 1.000\n",
      "Run: 8, Mean assignment to arrival: 11.9, Mean call to arrival: 14.7, Demand met: 1.000\n",
      "Run: 9, Mean assignment to arrival: 11.9, Mean call to arrival: 14.3, Demand met: 1.000\n",
      "Run: 10, Mean assignment to arrival: 11.9, Mean call to arrival: 14.9, Demand met: 1.000\n",
      "Run: 11, Mean assignment to arrival: 12.1, Mean call to arrival: 14.8, Demand met: 1.000\n",
      "Run: 12, Mean assignment to arrival: 12.1, Mean call to arrival: 14.8, Demand met: 1.000\n",
      "Run: 13, Mean assignment to arrival: 11.9, Mean call to arrival: 14.9, Demand met: 1.000\n",
      "Run: 14, Mean assignment to arrival: 12.0, Mean call to arrival: 15.0, Demand met: 1.000\n",
      "Run: 15, Mean assignment to arrival: 11.8, Mean call to arrival: 14.6, Demand met: 1.000\n",
      "Run: 16, Mean assignment to arrival: 11.7, Mean call to arrival: 14.3, Demand met: 1.000\n",
      "Run: 17, Mean assignment to arrival: 11.9, Mean call to arrival: 14.4, Demand met: 1.000\n",
      "Run: 18, Mean assignment to arrival: 12.0, Mean call to arrival: 14.7, Demand met: 1.000\n",
      "Run: 19, Mean assignment to arrival: 11.9, Mean call to arrival: 14.4, Demand met: 1.000\n",
      "Run: 20, Mean assignment to arrival: 11.9, Mean call to arrival: 14.6, Demand met: 1.000\n",
      "Run: 21, Mean assignment to arrival: 11.9, Mean call to arrival: 14.4, Demand met: 1.000\n",
      "Run: 22, Mean assignment to arrival: 11.9, Mean call to arrival: 14.9, Demand met: 1.000\n",
      "Run: 23, Mean assignment to arrival: 12.0, Mean call to arrival: 14.8, Demand met: 1.000\n",
      "Run: 24, Mean assignment to arrival: 12.1, Mean call to arrival: 14.9, Demand met: 1.000\n",
      "Run: 25, Mean assignment to arrival: 11.8, Mean call to arrival: 14.2, Demand met: 1.000\n",
      "Run: 26, Mean assignment to arrival: 12.0, Mean call to arrival: 15.1, Demand met: 1.000\n",
      "Run: 27, Mean assignment to arrival: 11.8, Mean call to arrival: 14.6, Demand met: 1.000\n",
      "Run: 28, Mean assignment to arrival: 12.2, Mean call to arrival: 15.1, Demand met: 1.000\n",
      "Run: 29, Mean assignment to arrival: 11.8, Mean call to arrival: 14.5, Demand met: 1.000\n",
      "\n",
      "       call_to_arrival  assign_to_arrival  demand_met\n",
      "count        30.000000          30.000000        30.0\n",
      "mean         14.645584          11.908241         1.0\n",
      "std           0.270341           0.122491         0.0\n",
      "min          14.151021          11.640640         1.0\n",
      "25%          14.417269          11.825642         1.0\n",
      "50%          14.620088          11.896471         1.0\n",
      "75%          14.861994          11.978078         1.0\n",
      "max          15.095944          12.209181         1.0\n"
     ]
    }
   ],
   "source": [
    "######################## MODEL ENTRY POINT #####################################\n",
    "\n",
    "# Run model and return last run results\n",
    "last_run = qambo()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}