2-Waiting-for-the-Bus.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "# multidimensional arrays\n",
    "import numpy as np\n",
    "import math\n",
    "\n",
    "# inline plots\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "# nicer figures\n",
    "import matplotlib as mpl\n",
    "mpl.rcParams['axes.titlesize'] = 16\n",
    "mpl.rcParams['axes.labelsize'] = 14\n",
    "mpl.rcParams['legend.fontsize'] = 12\n",
    "mpl.rcParams['xtick.labelsize'] = 12\n",
    "mpl.rcParams['ytick.labelsize'] = 12\n",
    "mpl.rcParams['axes.spines.right'] = False\n",
    "mpl.rcParams['axes.spines.top'] = False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Waiting for the bus\n",
    "### Exercise 2.1\n",
    "Suppose you are at the bus stop, waiting for the bus. Assume that, at any moment in time, the probability of the next bus arriving in exactly $t$ minutes is given by:\n",
    "$$\n",
    "P(t) = \\lambda e^{-\\lambda t}\n",
    "$$\n",
    "where $t > 0$ is a continous variable and $\\lambda > 0$ is a parameter.\n",
    "\n",
    "1. What is the probability that you have to wait 10 minutes *or more* for the next bus?\n",
    "   \n",
    "2. What is the probability that it takes $T$ minutes *or less* for the next bus to arrive?\n",
    "   \n",
    "3. If the last bust arrived 15 minutes ago, does the answer to questions 1 and 2 change? Explain why / why not.\n",
    "   \n",
    "4. If you sit at the bus stop for $T$ minutes, what is the probability that you will see $k$ buses passing by? **Hint**: You might want to divide $T$ into many small time intervals. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 2.2\n",
    "The take-home message of the previous exercise is that **exponential** waiting times between events imply **Poisson** number of events in a given time interval. What are the events? In our exercise they were bus arrivals, but they could be anything.\n",
    "\n",
    "We will start by generating exponential random numbers. In the [previous session](1.1-Generating-Random-Numbers.ipynb) we learnt howe to generate random numbers with a given distribution via **inverse sampling**. Today, however, we will use functions from `numpy.random`.\n",
    "\n",
    "Find a `numpy.random` function that generates numbers drawn from the exponential distribution. You might simply google \"numpy random exponential\" or browse [numpy's website]()."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Function's documentation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using the `?` command, you will get a quick view of a functions documentation. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.exponential?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Well-documented python functions, such as most found in numpy, follow a standardized format. The most important parts of a function's documentation are:\n",
    "\n",
    "The *first line*: gives a briev description of what the function does. It is followed by a more lengthy and detailed paragraph, but the first line should be enough to undersand what a function does.\n",
    "\n",
    "The *Parameters* section, which tells you what are the arguments or parameters of the function. It tells you what `type` they should be: a string, a float, and integer, etc. Notice that in python, parameters can be almost anything: you can pass a function to another function, you can pass an array, or a whole class, or any kind of python object.\n",
    "\n",
    "The *Returns* section is also very important, because it tells you what the function returns. Sometimes it is obvious, sometimes not, specially with functions that compute and return more than one thing."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 2.3\n",
    "\n",
    "Using numpy's functions, write a function called `get_waiting_times` of your own that has as input arguments an integer `size` and a float `lam`, and returns `size` samples from an exponential distribution with $\\lambda=$`lam`. The probability density function of an exponential random variable is:\n",
    "$$\n",
    "f(x) = \\lambda e^{-\\lambda x}\n",
    "$$\n",
    "Make sure you check what do the parameters of numpy's random exponential function mean!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x2b9ce16ee80>]"
      ]
     },
     "execution_count": 62,
     "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": [
    "#definisco la funzione che generi i numeri con una distribuzione esponenziale\n",
    "\n",
    "def get_waiting_times(size: int, lam: float): #definisco una funzione che mi dia i tempi di attesa\n",
    "    #gli argomenti sono (un intero - , un float per la costante di decadimento)\n",
    "    \n",
    "    w_times = np.random.exponential(1/lam, size)\n",
    "    return w_times\n",
    "\n",
    "\"\"\"mi sta restituendo l'intervallo di tempo tra due eventi e la distribuzione di questi intervvalli è una distribuzione esponenziale\n",
    "gli intervalli di tempo sono le dimension\"\"\"\n",
    "\n",
    "\n",
    "#definisco la funzione di controllo per l'esponenziale\n",
    "\n",
    "def exp_pdf(x, lam: float):\n",
    "    if x >= 0:\n",
    "        return lam*(math.exp(-lam*x))\n",
    "    else : \n",
    "        return 0\n",
    "\n",
    "x = np.linspace(start=0, stop=1.5, num=1000)\n",
    "pdf_x = np.array([exp_pdf(t,lam)\n",
    "                     for t in x\n",
    "                ])\n",
    "#print(pdf_x)\n",
    "\n",
    "\"\"\"\"x = np.linspace(start=0, stop=1.5, num=1000)\n",
    "pdf_x =np.array([lam*np.exp(-lam*t)\n",
    "                for t in x\n",
    "                ])\"\"\"\n",
    "\n",
    "\n",
    "#plotto l'istogramma\n",
    "lam=5\n",
    "size=1000\n",
    "data = get_waiting_times(size, lam)\n",
    "bins = np.linspace(0, 1.5, num=50)\n",
    "\n",
    "fig, ax = plt.subplots(1, 1, figsize=(6, 4))\n",
    "ax.hist(\n",
    "    data, #inserisco i dati\n",
    "    bins=bins, #ampiezza della colonna per l'istogramma\n",
    "    density=True, #solo per normalizzare\n",
    "    label = 'Empirical'\n",
    ");\n",
    "\n",
    "ax.set_xlabel(r\"$x$\")\n",
    "ax.set_ylabel(r\"Density, $f(x)$\")\n",
    "ax.set_title(f\"The exponential distribution $\\lambda$=5\");\n",
    "\n",
    "#plotto il confronto con l'esponenziale\n",
    "ax.plot(x, pdf_x, color = \"red\", label = 'Thoretical')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## From exponential to Poisson\n",
    "The rest of the exercise consists in verifying computationally that exponential waiting times between events imply Poisson number of events in a given time period, as we already showed analytically during last lecture. So, in case you didn't find the proof convincing, now you get a chance to see for yourself!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 2.4\n",
    "Write a function that computes the event times. Your function should call the `get_waiting_times` function, and should have the same parameters. In case it is not clear, the event times $t_i$ are computed from the waiting times $w_i$ as\n",
    "$$\n",
    "t_i = \\sum_{k=1}^{i} w_k\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "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": [
    "\"\"\" devo calcolare l'istante a cui avviene un evento, ho calcolato i w_k - in generale variabili - che sono i tempi di attesa, ovvero \n",
    "l'intervvallo di tempo che trascorrre tra due eventi. Quindi se sommo i tempi di attesa fino ad i ho l'istante in cui avviene l'iesimo evento.\n",
    "\"\"\"\n",
    "def get_event_times(size: int, lam: float):\n",
    "    waiting_times = get_waiting_times(size,lam)\n",
    "    # we simply do a cumulative sum of the waiting times\n",
    "    # find a numpy function that does cumulatives sums\n",
    "    event_times = np.cumsum(waiting_times) #mi restituisce un vettore che ha per ciascuna componente il valore della somma del vettore argomento fino alla componente con il medesimo indice\n",
    "    return event_times\n",
    "\n",
    "\n",
    "#plotto l'istogramma\n",
    "fig, ax = plt.subplots(1, 1, figsize=(6, 4))\n",
    "ax.hist(\n",
    "    data, #inserisco i dati\n",
    "    bins=bins, #ampiezza della colonna per l'istogramma\n",
    "    density=True, #solo per normalizzare\n",
    "    label = 'waiting_times'\n",
    ");\n",
    "\n",
    "data1 = get_event_times(size,lam)\n",
    "\n",
    "ax.hist(\n",
    "    data1, #inserisco i dati\n",
    "    bins=bins, #ampiezza della colonna per l'istogramma\n",
    "    density=True, #solo per normalizzare\n",
    "    label = 'event_times'\n",
    ");\n",
    "\n",
    "ax.set_xlabel(r\"$x$\")\n",
    "ax.set_ylabel(r\"Density, $f(x)$\")\n",
    "ax.set_title(f\"The exponential distribution $\\lambda$=5\");\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we need to count the number of events in a given time interval. There is a practical problem, since we don't know how many events to generate."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 2.5\n",
    "Device a strategy to make sure you generate enough events. That is, given a time period $T$ and the rate $\\lambda$ of the exponential, how many events $N(T, \\lambda)$ should you generate to make sure that $t_N > T$ ? \n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Assertions\n",
    "The `assert` statement is used to verify conditions that we expect to be `True`. For instance:\n",
    "```python\n",
    "assert 4 > 1 #True\n",
    "assert \"a\" in [\"a\", \"b\", \"c\"] #True\n",
    "assert 1 >= 2 #AssertionError\n",
    "```\n",
    "If the condition after `assert` is `False`, then an error is raised. But otherwise, nothing happens. Think of `assert` as \"make sure\": we don't want to do anything if the condition is `True`, we just want to make sure it is not `False`. A typical use case is to make sure that the passed arguments have some properties. For instance:\n",
    "\n",
    "```python\n",
    "def polar_to_cartesian(r, phi):\n",
    "    \"\"\"\n",
    "    Transform polar to cartesian coordinates.\n",
    "    \"\"\"\n",
    "    # let's make sure r is positive\n",
    "    assert r >= 0\n",
    "  \n",
    "    # then compute the coordinates\n",
    "    x = r * np.cos(phi)\n",
    "    y = r * np.sin(phi)\n",
    "    \n",
    "    return x, y\n",
    "```\n",
    "\n",
    "Notice that, without the assertion, the function would work for negative radius without complaining, and that is something we want to avoid."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 2.6\n",
    "Write a function that counts the events in a given time period. The input parameters should be `time_period` and `lam`. Your function should call the `get_event_times` function. The output should be an integer, the number of events in the time period.\n",
    "\n",
    "Add an `assert` statement to make sure that we have generate enough events."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.stats import poisson\n",
    "\n",
    "def count_events(time_period, lam):\n",
    "    # make sure everything is fine\n",
    "    assert time_period > 0\n",
    "    assert lam > 0\n",
    "    \n",
    "    # estimate number of events necessary\n",
    "    num_events = int( poisson(mu=time_period * lam).isf(1e-6)) #survival function di poisson (per avere questa probabilità devo avere almeno tot eventi)\n",
    "\n",
    "    # generate event times\n",
    "    event_times = get_event_times(size=num_events, lam=lam)\n",
    "        \n",
    "    # make sure that the last event is outside the time period\n",
    "    # you can access the last element of an array 'x' with 'x[-1]'\n",
    "    assert event_times[-1] > time_period\n",
    "    \n",
    "    # see which events are inside the time period\n",
    "    event_inside = event_times < time_period #event_times è un vettore\n",
    "    #la riga di codice sopra costruisce un vettore inserendoci solo alcuni eventi, quelli che avvengono nel periodo considerato\n",
    "    \n",
    "    # count how many are inside\n",
    "    num_inside = np.count_nonzero(event_inside==True)\n",
    "    \n",
    "    return num_inside"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "x = count_events(5, 0.5)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Checking your results\n",
    "To make sure your functions work correctly, you can use the code below, which compares the number of intervals in a given interval with a Poisson distribution. If everything went well, the histrograms should be one on top of the other!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test_with_numpy(time_period, lam, num_samples):\n",
    "    # generate our results\n",
    "    sample = [\n",
    "        count_events(time_period=time_period, lam=lam)\n",
    "        for _ in range(num_samples)\n",
    "    ]\n",
    "    # compare with real poisson sample\n",
    "    sample_ground_truth = np.random.poisson(lam=lam * time_period, size=num_samples)\n",
    "    return sample, sample_ground_truth"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x720 with 9 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "lams = [0.5, 1, 2.4]\n",
    "time_periods = [0.3, 1, 5]\n",
    "\n",
    "fig, axx = plt.subplots(3, 3, figsize=(16, 10), tight_layout=True)\n",
    "axx = axx.reshape(-1)\n",
    "i = 0\n",
    "for lam in lams:\n",
    "    for time_period in time_periods:\n",
    "        \n",
    "        ax = axx[i]\n",
    "        i = i+1\n",
    "        \n",
    "        sample, sample_true = test_with_numpy(time_period=time_period, lam=lam, num_samples=10000)\n",
    "        M = max(max(sample), max(sample_true))\n",
    "        ax.set_title(f\"$\\lambda$ = {lam}\\n$T$ =  {time_period}\")\n",
    "        ax.hist(\n",
    "            sample,\n",
    "            bins=np.arange(-0.5, M + 0.5),\n",
    "            alpha=0.4,\n",
    "            label=\"results\"\n",
    "        );\n",
    "        ax.hist(\n",
    "            sample_true,\n",
    "            bins=np.arange(-0.5, M + 0.5),\n",
    "            alpha=0.3,\n",
    "            label=\"numpy\"\n",
    "        );\n",
    "        ax.set_xlabel(r\"Num events, $k$\")\n",
    "        ax.set_ylabel(f\"$P(k)$\")\n",
    "        ax.legend(loc=(1, 0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}