2.2 preclass work.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import heapq\n",
    "import matplotlib.pyplot as plt \n",
    "import numpy as np\n",
    "import scipy.stats as sts\n",
    "class Event:\n",
    "    '''\n",
    "    Store the properties of one event in the Schedule class defined below. Each\n",
    "    event has a time at which it needs to run, a function to call when running\n",
    "    the event, along with the arguments and keyword arguments to pass to that\n",
    "    function.\n",
    "    '''\n",
    "    def __init__(self, timestamp, function, *args, **kwargs):\n",
    "        self.timestamp = timestamp\n",
    "        self.function = function\n",
    "        self.args = args\n",
    "        self.kwargs = kwargs\n",
    "\n",
    "    def __lt__(self, other):\n",
    "        '''\n",
    "        This overloads the less-than operator in Python. We need it so the\n",
    "        priority queue knows how to compare two events. We want events with\n",
    "        earlier (smaller) times to go first.\n",
    "        '''\n",
    "        return self.timestamp < other.timestamp\n",
    "\n",
    "    def run(self, schedule):\n",
    "        '''\n",
    "        Run an event by calling the function with its arguments and keyword\n",
    "        arguments. The first argument to any event function is always the\n",
    "        schedule in which events are being tracked. The schedule object can be\n",
    "        used to add new events to the priority queue.\n",
    "        '''\n",
    "        self.function(schedule, *self.args, **self.kwargs)\n",
    "\n",
    "\n",
    "class Schedule:\n",
    "    '''\n",
    "    Implement an event schedule using a priority queue. You can add events and\n",
    "    run the next event.\n",
    "    \n",
    "    The `now` attribute contains the time at which the last event was run.\n",
    "    '''\n",
    "    \n",
    "    def __init__(self):\n",
    "        self.now = 0  # Keep track of the current simulation time\n",
    "        self.priority_queue = []  # The priority queue of events to run\n",
    "    \n",
    "    def add_event_at(self, timestamp, function, *args, **kwargs):\n",
    "        # Add an event to the schedule at a particular point in time.\n",
    "        heapq.heappush(\n",
    "            self.priority_queue,\n",
    "            Event(timestamp, function, *args, **kwargs))\n",
    "    \n",
    "    def add_event_after(self, interval, function, *args, **kwargs):\n",
    "        # Add an event to the schedule after a specified time interval.\n",
    "        self.add_event_at(self.now + interval, function, *args, **kwargs)\n",
    "    \n",
    "    def next_event_time(self):\n",
    "        return self.priority_queue[0].timestamp\n",
    "\n",
    "    def run_next_event(self):\n",
    "        # Get the next event from the priority queue and run it.\n",
    "        event = heapq.heappop(self.priority_queue)\n",
    "        self.now = event.timestamp\n",
    "        event.run(self)\n",
    "        \n",
    "    def __repr__(self):\n",
    "        return (\n",
    "            f'Schedule() at time {self.now} ' +\n",
    "            f'with {len(self.priority_queue)} events in the queue')\n",
    "    \n",
    "    def print_events(self):\n",
    "        print(repr(self))\n",
    "        for event in sorted(self.priority_queue):\n",
    "            print(f'   {event.timestamp}: {event.function.__name__}')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# M/D/1 queue\n",
    "\n",
    "import scipy.stats as sts\n",
    "\n",
    "\n",
    "class Queue:\n",
    "    def __init__(self, service_rate):\n",
    "        # Store the deterministic service time for an M/D/1 queue\n",
    "        self.service_time = 1 / service_rate\n",
    "        # We start with an empty queue and the server not busy\n",
    "        self.people_in_queue = 0\n",
    "        self.people_being_served = 0\n",
    "\n",
    "    def add_customer(self, schedule):\n",
    "        # Add the customer to the queue\n",
    "        self.people_in_queue += 1\n",
    "        if self.people_being_served < 1:\n",
    "            # This customer can be served immediately\n",
    "            schedule.add_event_after(0, self.start_serving_customer)\n",
    "            \n",
    "    def start_serving_customer(self, schedule):\n",
    "        # Move the customer from the queue to a server\n",
    "        self.people_in_queue -= 1\n",
    "        self.people_being_served += 1\n",
    "        # Schedule when the server will be done with the customer\n",
    "        schedule.add_event_after(\n",
    "            self.service_time,\n",
    "            self.finish_serving_customer)\n",
    "            \n",
    "    def finish_serving_customer(self, schedule):\n",
    "        # Remove the customer from the server\n",
    "        self.people_being_served -= 1\n",
    "        if self.people_in_queue > 0:\n",
    "            # There are more people in the queue so serve the next customer\n",
    "            schedule.add_event_after(0, self.start_serving_customer)\n",
    "\n",
    "\n",
    "class GroceryStore:\n",
    "    \n",
    "    def __init__(self, arrival_rate, service_rate):\n",
    "        self.queue = Queue(service_rate)\n",
    "        self.arrival_distribution = sts.expon(scale=1/arrival_rate)\n",
    "\n",
    "    def add_customer(self, schedule):\n",
    "        # Add this customer to the queue\n",
    "        self.queue.add_customer(schedule)\n",
    "        # Schedule when to add another customer\n",
    "        schedule.add_event_after(\n",
    "            self.arrival_distribution.rvs(),\n",
    "            self.add_customer)\n",
    "\n",
    "    def run(self, schedule):\n",
    "        # Schedule when the first customer arrives\n",
    "        schedule.add_event_after(\n",
    "            self.arrival_distribution.rvs(),\n",
    "            self.add_customer)\n",
    "        \n",
    "\n",
    "def run_simulation(arrival_rate, service_rate, run_until):\n",
    "    schedule = Schedule()\n",
    "    grocery_store = GroceryStore(arrival_rate, service_rate)\n",
    "    grocery_store.run(schedule)\n",
    "    while schedule.next_event_time() < run_until:\n",
    "        schedule.run_next_event()\n",
    "    return grocery_store"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## First Experiment: 100 trials"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    a. To compute empirical estimates in this simulation, you should run the simulation for\n",
    "    at least 100 units of time. This is needed to make sure the simulation is in its\n",
    "    equilibrium state. “Equilibrium state” essentially means you reach a state where the\n",
    "    initial conditions of the simulation don't matter anymore and the same average\n",
    "    behavior is observed for the rest of the time.\n",
    "\n",
    "    b. After 100 units of time, record the queue length at that point in time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There are 0 people in the queue\n"
     ]
    }
   ],
   "source": [
    "grocery_store = run_simulation(arrival_rate=0.8, service_rate=1, run_until=100)\n",
    "print(f'There are {grocery_store.queue.people_in_queue} people in the queue')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    c. Repeat the process above 100 times. This will give you 100 measurements of the\n",
    "    queue length in the simulation. These are the results of your experiment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There are 10 people in the queue\n",
      "There are 1 people in the queue\n",
      "There are 0 people in the queue\n",
      "There are 0 people in the queue\n",
      "There are 2 people in the queue\n",
      "There are 3 people in the queue\n",
      "There are 0 people in the queue\n",
      "There are 2 people in the queue\n",
      "There are 0 people in the queue\n",
      "There are 0 people in the queue\n",
      "There are 1 people in the queue\n",
      "There are 2 people in the queue\n",
      "There are 0 people in the queue\n",
      "There are 0 people in the queue\n",
      "There are 2 people in the queue\n",
      "There are 1 people in the queue\n",
      "There are 0 people in the queue\n",
      "There are 0 people in the queue\n",
      "There are 4 people in the queue\n",
      "There are 1 people in the queue\n",
      "There are 0 people in the queue\n",
      "There are 1 people in the queue\n",
      "There are 0 people in the queue\n",
      "There are 0 people in the queue\n",
      "There are 0 people in the queue\n",
      "There are 5 people in the queue\n",
      "There are 1 people in the queue\n",
      "There are 0 people in the queue\n",
      "There are 2 people in the queue\n",
      "There are 7 people in the queue\n",
      "There are 0 people in the queue\n",
      "There are 3 people in the queue\n",
      "There are 0 people in the queue\n",
      "There are 2 people in the queue\n",
      "There are 3 people in the queue\n",
      "There are 1 people in the queue\n",
      "There are 17 people in the queue\n",
      "There are 1 people in the queue\n",
      "There are 0 people in the queue\n",
      "There are 1 people in the queue\n",
      "There are 5 people in the queue\n",
      "There are 1 people in the queue\n",
      "There are 2 people in the queue\n",
      "There are 8 people in the queue\n",
      "There are 2 people in the queue\n",
      "There are 3 people in the queue\n",
      "There are 3 people in the queue\n",
      "There are 0 people in the queue\n",
      "There are 1 people in the queue\n",
      "There are 0 people in the queue\n",
      "There are 1 people in the queue\n",
      "There are 0 people in the queue\n",
      "There are 0 people in the queue\n",
      "There are 1 people in the queue\n",
      "There are 0 people in the queue\n",
      "There are 2 people in the queue\n",
      "There are 1 people in the queue\n",
      "There are 0 people in the queue\n",
      "There are 1 people in the queue\n",
      "There are 0 people in the queue\n",
      "There are 6 people in the queue\n",
      "There are 0 people in the queue\n",
      "There are 1 people in the queue\n",
      "There are 0 people in the queue\n",
      "There are 4 people in the queue\n",
      "There are 0 people in the queue\n",
      "There are 0 people in the queue\n",
      "There are 0 people in the queue\n",
      "There are 0 people in the queue\n",
      "There are 5 people in the queue\n",
      "There are 0 people in the queue\n",
      "There are 2 people in the queue\n",
      "There are 0 people in the queue\n",
      "There are 1 people in the queue\n",
      "There are 4 people in the queue\n",
      "There are 0 people in the queue\n",
      "There are 2 people in the queue\n",
      "There are 6 people in the queue\n",
      "There are 3 people in the queue\n",
      "There are 1 people in the queue\n",
      "There are 7 people in the queue\n",
      "There are 0 people in the queue\n",
      "There are 0 people in the queue\n",
      "There are 0 people in the queue\n",
      "There are 3 people in the queue\n",
      "There are 0 people in the queue\n",
      "There are 3 people in the queue\n",
      "There are 1 people in the queue\n",
      "There are 7 people in the queue\n",
      "There are 2 people in the queue\n",
      "There are 1 people in the queue\n",
      "There are 1 people in the queue\n",
      "There are 0 people in the queue\n",
      "There are 1 people in the queue\n",
      "There are 0 people in the queue\n",
      "There are 0 people in the queue\n",
      "There are 0 people in the queue\n",
      "There are 0 people in the queue\n",
      "There are 3 people in the queue\n",
      "There are 0 people in the queue\n"
     ]
    }
   ],
   "source": [
    "# This list will be used later for plotting the histogram \n",
    "simulation_lst = []\n",
    "for i in range(100):\n",
    "    grocery_store = run_simulation(arrival_rate=0.8, service_rate=1, run_until=100)\n",
    "    simulation_lst.append(grocery_store.queue.people_in_queue)\n",
    "    print(f'There are {grocery_store.queue.people_in_queue} people in the queue')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    d.Plot a histogram of the results to visualize the distribution over the queue length."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "(array([65., 21.,  6.,  2.,  4.,  1.,  0.,  0.,  0.,  1.]),\n",
       " array([ 0. ,  1.7,  3.4,  5.1,  6.8,  8.5, 10.2, 11.9, 13.6, 15.3, 17. ]),\n",
       " <a list of 10 Patch objects>)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure()\n",
    "plt.show()\n",
    "plt.xlabel(\"Queue Length\")\n",
    "plt.hist(simulation_lst)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "e. Compute an empirical estimate of the mean queue length for this M/D/1 queue with\n",
    "arrival rate 0.8 and service rate 1, including a 95% confidence interval of the mean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sample mean: 1.68\n",
      "Standard error of the mean: 0.2589333208501074\n",
      "95% confidence interval of population mean: [1.1724906911337896, 2.1875093088662103]\n"
     ]
    }
   ],
   "source": [
    "# Computing the mean of the queue length \n",
    "m = np.mean(simulation_lst)\n",
    "print('Sample mean:', m)\n",
    "\n",
    "t = sts.sem(simulation_lst) # standard error s/squareroot(n)\n",
    "print('Standard error of the mean:', t)\n",
    "print('95% confidence interval of population mean:', [m - 1.96*t, m + 1.96*t])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Second Experiment: 1000 trials"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There are 0 people in the queue\n"
     ]
    }
   ],
   "source": [
    "# a) & b)\n",
    "grocery_store = run_simulation(arrival_rate=0.8, service_rate=1, run_until=1000)\n",
    "print(f'There are {grocery_store.queue.people_in_queue} people in the queue')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# c)\n",
    "# This list will be used later for plotting the histogram \n",
    "simulation_1000_trials = []\n",
    "for i in range(1000):\n",
    "    grocery_store = run_simulation(arrival_rate=0.8, service_rate=1, run_until=1000)\n",
    "    simulation_1000_trials.append(grocery_store.queue.people_in_queue)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "(array([634., 209.,  87.,  22.,  27.,  13.,   3.,   2.,   2.,   1.]),\n",
       " array([ 0. ,  1.7,  3.4,  5.1,  6.8,  8.5, 10.2, 11.9, 13.6, 15.3, 17. ]),\n",
       " <a list of 10 Patch objects>)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# d)\n",
    "plt.figure()\n",
    "plt.show()\n",
    "plt.xlabel(\"Queue Length\")\n",
    "plt.hist(simulation_1000_trials)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sample mean: 1.62\n",
      "Standard error of the mean: 0.07331422082362313\n",
      "95% confidence interval of population mean: [1.4763041271856987, 1.7636958728143015]\n"
     ]
    }
   ],
   "source": [
    "# e)\n",
    "# Computing the mean of the queue length \n",
    "m = np.mean(simulation_1000_trials)\n",
    "print('Sample mean:', m)\n",
    "\n",
    "t = sts.sem(simulation_1000_trials) # standard error s/squareroot(n)\n",
    "print('Standard error of the mean:', t)\n",
    "print('95% confidence interval of population mean:', [m - 1.96*t, m + 1.96*t])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comparing results from the two experiments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "a. From the two histograms, we can see that the two experiments give approximately similar distributions (and it's worth mentioning that the second histogram has more counts/frequency for different queue lengths since it was run 1000 trials as opposed to just 100 in the first experiment)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "b. The average queue length is approximately the same (1.76 in the first trial vs 1.67 in the second one)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "c. The confidence interval changed from [1.3, 2.2] to [1.5, 1.8], and we observe that the two intervals overlap."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Repeating the experiment but for different values of the arrival rate."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The average queue length exceeds 5 people at the arrival and service rate 1.0, 2.2 respectively \n"
     ]
    }
   ],
   "source": [
    "# Intial arrival rate at the start of the experiment \n",
    "arrival_rate = 0.8\n",
    "\n",
    "# Arrival rate list\n",
    "arrival_rate_list = []\n",
    "# To store average queue length for each arrival rate \n",
    "avg_queue_lengths = [] \n",
    "# To store cofidence interval for each arrival rate\n",
    "conf_interval_lst = []\n",
    "\n",
    "flag = False # Flag that we exceeded 5\n",
    "\n",
    "\n",
    "# Terminate when the arrival rate is equal to or more than 5\n",
    "while arrival_rate < 2:\n",
    "    arrival_rate_list.append(arrival_rate)\n",
    "    # The queue lengths for each experiment (for each arrival rate)\n",
    "    simulation_result = []\n",
    "    \n",
    "    # Run each experiment 100 times \n",
    "    for i in range(100):\n",
    "        grocery_store = run_simulation(arrival_rate, 1, 100)\n",
    "        simulation_result.append(grocery_store.queue.people_in_queue) # Store the result \n",
    "        \n",
    "    m = np.mean(simulation_result) # Calculate avg queue length \n",
    "    avg_queue_lengths.append(m)  #store the result \n",
    "\n",
    "    t = sts.sem(simulation_result) # standard error s/squareroot(n)\n",
    "    conf_interval_lst.append([m - 1.96*t, m + 1.96*t]) # Store the confidence interval \n",
    "    \n",
    "    # To mark the point where the average queue length exceeds 5 people   \n",
    "    if not flag and m > 5:\n",
    "        print(f\"The average queue length exceeds 5 people at the arrival and service rate {arrival_rate}, 2.2 respectively \")\n",
    "        flag = True \n",
    "    \n",
    "    arrival_rate += 0.1 # Increment the value of arrival rate to terminate while loop \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = arrival_rate_list\n",
    "y = avg_queue_lengths\n",
    "\n",
    "y_error = [interval[1]-interval[0] for interval in conf_interval_lst]\n",
    "\n",
    "plt.figure()\n",
    "plt.xlabel(\"Arrival rates\")\n",
    "plt.ylabel(\"Average queue length\")\n",
    "plt.errorbar(\n",
    "x, y, y_error,\n",
    "color='black', marker='.', capsize=5, linestyle='--', linewidth=2) # Make an error plot\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reflection"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1) #EmpiricalAnalysis: In this pre-class work, I employed multiple concepts and empirical methods that fall under this LO and were helpful in analyzing how the length of the queue grows when the arrival rate changes. In particular, I calculated the average queue length for several arrival rates as well as the confidence interval associated with each arrival rate. I also ran the simulation under different conditions and recorded my observation regarding how the average queue length varies.\n",
    "\n",
    "2) #Professionalism: Here, I used various plots (histograms and error plots) to visualize how the queue length changes over time in each experiment in addition to its behavior when the arrival rate changes. \n",
    "I also tried to add labels to make the plots more comprehensible for any audience. I also divided the preclass work into several sections (and utilized headers and commented the code) to make the report easy to follow, clean, and organized. \n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}