PoissonNB.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import datetime as dt\n",
    "from datetime import  timedelta\n",
    "import pandas as pd\n",
    "import math\n",
    "import scipy.stats as stats"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 1: Defining a Poisson Simulator\n",
    "To simulate a Poisson process of mean $\\lambda t$, we recognize:\n",
    "\n",
    "1. that the time between arrivals is exponentially distributed with parameter $\\frac{1}{\\lambda}$.\n",
    "\n",
    "2. arrivals only increment the process by 1.\n",
    "\n",
    "3. Our output will be a list of timestamps noting when the random arrival occurred, and another list of the running sum $N(t)$ denoting how many total arrivals\n",
    "have occurred since the process began.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# poisson process \n",
    "from cmath import log\n",
    "from copy import copy\n",
    "class Poisson():\n",
    "    \"\"\"\n",
    "    Atributtes\n",
    "    ----------\n",
    "    lam : float\n",
    "        set defect arrival rate lambda.\n",
    "    period_length : float\n",
    "        length of HCPP simulation in seconds.\n",
    "    now : datetime object\n",
    "        time when class is initiated, referece 0 time. \n",
    "    timestamps : list\n",
    "        list of timestamps of Poisson arrvials.\n",
    "    process = list\n",
    "        list of cumulative sum of Poisson process. \n",
    "\n",
    "    Methods\n",
    "    -------\n",
    "    get_hcpp_arrival()\n",
    "        Generates Poisson arrival with timestamp.\n",
    "    get_hcpp_sequence()\n",
    "        Generates a sequence of Poisson arrivals.\n",
    "    convert_tstamp_to_sec()\n",
    "        Converts list of timestamps, self.timestamps to a list of timepoints in seconds.\n",
    "    mle_est()\n",
    "        computes MLE estimate for lambda.\n",
    "    \"\"\"\n",
    "    def __init__(self):\n",
    "        self.lam = 1.0\n",
    "        self.period_length = 60.0\n",
    "        self.now = dt.datetime.now()\n",
    "        self.timestamps = [copy(self.now)]\n",
    "        self.process = [0]\n",
    "        \n",
    "    def get_arrival(self):\n",
    "        arrival_time = (-1/self.lam)*math.log(np.random.default_rng().uniform())\n",
    "        self.now += dt.timedelta(seconds = arrival_time)\n",
    "        return self.now\n",
    "\n",
    "    def get_sequence(self):\n",
    "        period_end = copy(self.now) + dt.timedelta(seconds = self.period_length)\n",
    "        while self.now < period_end:\n",
    "            arrivaltime = self.get_arrival()\n",
    "            hcpp_proc = self.process[-1] + 1\n",
    "            self.timestamps.append(arrivaltime)\n",
    "            self.process.append(hcpp_proc)\n",
    "        #self.now = period_end\n",
    "\n",
    "    def mle_est(self):\n",
    "        return self.process[-1]/self.period_length\n",
    "\n",
    "def convert_tstamp_to_sec(timestamps):\n",
    "    \"\"\"\n",
    "    Converts list of timestamps, self.timestamps to a list of timepoints in seconds.\n",
    "    \"\"\"\n",
    "    return [(tstamp - timestamps[0]).total_seconds() for tstamp in timestamps]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 2: Generating a Sequence of Poisson Random Variables (RV)\n",
    "For $\\lambda = 1$, we simulate a Poisson Process for 5 seconds, and plot the results below. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The mean size and number of the defects were estimated to be 0.6847 defects per second.\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "pois_inst = Poisson()\n",
    "pois_inst.period_length = 30\n",
    "pois_inst.get_sequence()\n",
    "\n",
    "print(\n",
    "    \"The mean size and number of the defects were estimated to be {} defects per second.\".format(\n",
    "        round((len(pois_inst.process)-1)/(pois_inst.timestamps[-1]-pois_inst.timestamps[0]).total_seconds(),4)\n",
    "    ))\n",
    "timepoints = convert_tstamp_to_sec(pois_inst.timestamps)\n",
    "arrivals = pois_inst.process\n",
    "\n",
    "def plot_Poisson_Process(timepoints, arrivals, ticksize=5,params='\\u03BB = 1.0,',figtitle=\"fig1\"):\n",
    "    plt.scatter(x=timepoints, y=arrivals, s=2)\n",
    "    plt.title(\"Simulated Poisson Process with parameter {}\".format(params))\n",
    "    plt.xticks(np.arange(min(timepoints), max(timepoints), ticksize))\n",
    "    plt.xlabel(\"time (seconds)\")\n",
    "    plt.ylabel(\"HCPP Process (Defect Size = mm)\")\n",
    "    plt.savefig(figtitle,dpi=100)\n",
    "    plt.show()\n",
    "\n",
    "plot_Poisson_Process(timepoints, arrivals, figtitle=\"fig_1_Poisson_process.png\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 3: Testing Goodness of Fit (GOF) for Simulated HCPP.\n",
    "To confirm whether the HCPP process follows each individual distribution we use:\n",
    "\n",
    "MLE estimator and $\\chi^2$ Goodness of Fit test for parameter, $\\lambda$,\n",
    "\n",
    "For the $\\chi^2$ test where the MLE estimate of the mean No. of defects in a period length $t$ is $\\hat \\lambda t$ the Hypotheses are:\n",
    "\n",
    "$\\qquad H_0$: The mean rate of order arrival in a 1s increment $ = \\hat \\lambda t$.\n",
    "\n",
    "$\\qquad H_1$: The mean rate of order arrival in a 1s increment $ \\neq \\hat \\lambda t$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "chi square value determined by formula : 20.47272727272728\n",
      "chi square critical value at alpha = 0.05: 46.19425952027847\n"
     ]
    }
   ],
   "source": [
    "def compute_gof(poisson_inst,alpha):\n",
    "    df = pd.Series(poisson_inst.process, index = poisson_inst.timestamps)\n",
    "    Obs = df.resample('s').count()\n",
    "    hatlamt = pois_inst.mle_est()\n",
    "    Exp = [hatlamt]*len(Obs)\n",
    "    chi_square_test_stat = 0\n",
    "    for i in range(len(Obs)):\n",
    "        chi_square_test_stat += (np.square(Obs[i]-Exp[i]))/Exp[i]\n",
    "    print('chi square value determined by formula : ' + str(chi_square_test_stat))     \n",
    "    print('chi square critical value at alpha = {}: {}'.format(alpha, stats.chi2.ppf(1-alpha, df=len(Obs)-1)))\n",
    "\n",
    "#Chi-Sq for Poisson\n",
    "compute_gof(pois_inst,0.05)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Evaluating Results from GOF tests:\n",
    "We see that $\\chi^2_{stat}$ did not exceed its critical value at an $\\alpha = 0.05$.\n",
    "We can conclude for now that we can\n",
    "\n",
    "1. simulate a Poisson process $N(t)$ with parameter $\\lambda > 0$,\n",
    "\n",
    "2. We can estimate, and assess goodness of fit of\n",
    "  \n",
    "    * the mean no of defects $\\hat \\lambda t$ using the $\\chi^2$ GOF test.\n",
    "\n",
    "## Step 4: Simulating a Poisson with a changepoint to an increased rate of Defect Arrivals\n",
    "Next we will simulate a Poisson process that:\n",
    "    \n",
    "1. Begins at an initial $\\lambda_0 = 1$ Defect/s,\n",
    "    \n",
    "2. proceeds with this $\\lambda_0$ for 15 seconds,\n",
    "    \n",
    "3. changes its rate of Defect arrival to $\\lambda_1 = 5$ Defects/s,\n",
    "    \n",
    "4. finally proceeds with this $\\lambda_0$ for 15 seconds."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "poisson_inst = Poisson()\n",
    "poisson_inst.period_length = 15\n",
    "poisson_inst.get_sequence()\n",
    "lam_est = pois_inst.mle_est\n",
    "poisson_inst.lam = 5\n",
    "poisson_inst.get_sequence()\n",
    "lam_est = poisson_inst.process[-1]/(poisson_inst.timestamps[-1]-poisson_inst.timestamps[0]).total_seconds()\n",
    "timepoints = convert_tstamp_to_sec(poisson_inst.timestamps)\n",
    "plot_Poisson_Process(timepoints, poisson_inst.process, ticksize=10,params=\"(\\u03BB 0 = 1) and (\\u03BB 1 = 5) \",figtitle=\"fig_2_changing_poisson.png\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "chi square value determined by formula : 491.2848484848485\n",
      "chi square critical value at alpha = 0.05: 44.98534328036513\n"
     ]
    }
   ],
   "source": [
    "# #Poisson \n",
    "compute_gof(poisson_inst,0.05)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 6: GOF test results\n",
    "We see that only the $\\chi^2$ statistic exceeded its critical values at an $\\alpha = 0.05$.\n",
    "\n",
    "This creates a new problem! Suppose at some unknown time $\\nu$, the rate of Defect arrival changes from $\\lambda_0$ to $\\lambda_1$.\n",
    "How do develop a change point detection scheme to identify when this change occurs. \n",
    "## Step 7: CUSUM Changepoint Detection Scheme \n",
    "Starting again with our Poisson process, $\\{N(t)\\}_{t\\geq0}$ with mean $\\lambda_0 t$, where $\\lambda_1^+=(1+\\epsilon)\\lambda_0$, $\\lambda_1^-= (1-\\epsilon)\\lambda_0$, $\\{h, \\lambda_0, \\epsilon \\} \\in \\mathbb{R^+}$ we can define the CUSUM class that generates 6 processes:\n",
    "\n",
    "1.$ u^+_t (\\lambda_0)$; The SPRT process to detect a change from a upward change.\n",
    "\n",
    "2.$ m^+_t (\\lambda_0)$; The running minimum of the upward SPRT process, $u^+_t$.\n",
    "\n",
    "3.$u^-_t (\\lambda_0)$; The SPRT process to detect a change from a downward change.\n",
    "                \n",
    "4.$m^-_t (\\lambda_0)$; The running minimum of the downward SPRT process, $u^-_t$.\n",
    "\n",
    "5.$y^+_t (\\lambda_0)$; The CUSUM process for an upward change.\n",
    "\n",
    "6.$y^-_t (\\lambda_0)$; The CUSUM process for an downward change.\n",
    "\n",
    "This CUSUM detection scheme will identify the CUSUM stopping time $\\tau$:\n",
    "$$ \\tau = \\inf \\{ t \\geq 0; y^+_t(\\lambda_0) \\lor y^-_t(\\lambda_0) \\geq h\\}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "class CUSUM(): \n",
    "    def __init__(self, timestamp=dt.datetime(1900,1,1), l0=1.0, epsilon = 0.01, h = 0.0001):\n",
    "        # from args\n",
    "        self.l0 = l0\n",
    "        self.deltatime = 0.0\n",
    "        self.h = h\n",
    "        self.epsilon = epsilon\n",
    "        self.alarm_up,self.alarm_dn = False, False \n",
    "        self.timestamp = timestamp\n",
    "        self.entries = []\n",
    "        #derived\n",
    "        self.SPRT_dn, self.SPRT_up = 0.0, 0.0\n",
    "        self.run_min_dn, self.run_min_up = 0.0, 0.0\n",
    "        self.CUSUM_dn, self.CUSUM_up = 0.0, 0.0\n",
    "        self.write_to_df()\n",
    "\n",
    "    def pmf_poisson(self,lam,deltatime,arrival):\n",
    "        return (((lam*deltatime) ** arrival)*math.exp(-lam*deltatime))/(arrival)\n",
    "\n",
    "    def reset_CUSUM(self):\n",
    "        self.SPRT_dn, self.SPRT_up = 0.0, 0.0\n",
    "        self.run_min_dn, self.run_min_up = 0.0, 0.0\n",
    "        self.CUSUM_dn, self.CUSUM_up = 0.0, 0.0\n",
    "        self.alarm_up,self.alarm_dn = False, False \n",
    "\n",
    "    def compute_stats(self, arrival, deltatime, timestamp):\n",
    "        self.timestamp = timestamp\n",
    "        l0= copy(self.l0)\n",
    "        l1p = l0*(1+self.epsilon)\n",
    "        l1m = l0*(1-self.epsilon)\n",
    "        if arrival >=1: \n",
    "            self.SPRT_up +=  math.log(1+self.epsilon) - (l1p - l0)*deltatime\n",
    "            self.SPRT_dn += arrival*math.log(1-self.epsilon) - (l1m - l0)*deltatime\n",
    "        else:\n",
    "            self.SPRT_up -=  deltatime*(l1p-l0)\n",
    "            self.SPRT_dn -=  deltatime*(l1m-l0)\n",
    "        self.run_min_up = min(self.run_min_up, self.SPRT_up)\n",
    "        self.run_min_dn = min(self.run_min_dn, self.SPRT_dn)\n",
    "        self.CUSUM_up = self.SPRT_up - self.run_min_up\n",
    "        self.CUSUM_dn = self.SPRT_dn - self.run_min_dn\n",
    "    \n",
    "    def check_alarms(self):\n",
    "        if self.CUSUM_dn > self.h:\n",
    "            self.alarm_dn = True\n",
    "            self.l0 = self.l0*(1-self.epsilon)\n",
    "        else:\n",
    "            self.alarm_dn = False\n",
    "\n",
    "        if self.CUSUM_up > self.h:\n",
    "            self.alarm_up = True \n",
    "            self.l0 = self.l0*(1+self.epsilon)\n",
    "        else:\n",
    "            self.alarm_up = False\n",
    "\n",
    "    \n",
    "    def write_to_df(self):\n",
    "        record_to_insert = {\n",
    "                    'timestamp':self.timestamp,\n",
    "                    'SPRTup':self.SPRT_up,\n",
    "                    'runminup':self.run_min_up,\n",
    "                    'CUSUMup':self.CUSUM_up,\n",
    "                    'SPRTdn':self.SPRT_dn,\n",
    "                    'runmindn':self.run_min_dn,\n",
    "                    'CUSUMdn':self.CUSUM_dn, \n",
    "                    'alarmup':self.alarm_up,\n",
    "                    'alarmdn':self.alarm_dn,\n",
    "        } \n",
    "        self.entries.append(record_to_insert)\n",
    "\n",
    "    def Update(self, deltatime,arrival, timestamp):\n",
    "        self.compute_stats( arrival=arrival,deltatime=deltatime,timestamp=timestamp)\n",
    "        self.check_alarms()\n",
    "        self.write_to_df()\n",
    "        if self.alarm_up or self.alarm_dn:\n",
    "            self.reset_CUSUM()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 8: Trying Out our CUSUM Changepoint Detection Scheme\n",
    "Lets try to use our change point detection scheme to identify a stopping time $\\tau$ where we can say the simulated Poisson no longer has the mean rate $\\lambda0$. We will:\n",
    "    \n",
    "1. Generate a Poisson process with $\\lambda_0 = 1$ Defect/s, that runs for 15 seconds.\n",
    "\n",
    "2. Record estimates for $\\hat \\lambda_0 t$ for that initial run.\n",
    "\n",
    "3. Start recording out CUSUM statistics, \n",
    "\n",
    "4. Continue simulating the Poisson process for 15 more seconds,\n",
    "\n",
    "4. changes the poisson rate of Defect arrival to $\\lambda_1 = 5$ Defects/s,\n",
    "    \n",
    "5. proceeds with this $\\lambda_1$ for 15 seconds.\n",
    "\n",
    "from this data, we will generate a table of the CUSUM statistics.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9333333333333333\n"
     ]
    }
   ],
   "source": [
    "## lets try this test\n",
    "pois_inst = Poisson()\n",
    "pois_inst.period_length = 15 # \n",
    "pois_inst.get_sequence() # End of Step 1\n",
    "lamtest = pois_inst.mle_est()\n",
    "pois_inst.epsilon = 0.2\n",
    "print(lamtest)\n",
    "\n",
    "pois_inst.__init__()\n",
    "pois_inst.period_length = 15\n",
    "pois_inst.get_sequence()\n",
    "pois_inst.lam=5\n",
    "pois_inst.get_sequence()\n",
    "CUSUM_inst = CUSUM(timestamp = pois_inst.timestamps[0], l0=lamtest)\n",
    "CUSUM_inst.h = 0.05\n",
    "times = convert_tstamp_to_sec(pois_inst.timestamps)\n",
    "for i in range(1,len(times)):\n",
    "    deltatime = times[i] - times[i-1]\n",
    "    arrival = pois_inst.process[i]-pois_inst.process[i-1]\n",
    "    CUSUM_inst.Update(arrival=arrival, deltatime=deltatime,timestamp=pois_inst.timestamps[i])\n",
    "    \n",
    "df = pd.DataFrame(CUSUM_inst.entries)\n",
    "df['time'] = convert_tstamp_to_sec(df['timestamp'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 9 Plotting CUSUM Processes "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def CUSUM_SPRT_runmin_chart(df):\n",
    "    fig, ax = plt.subplots(3, sharex=True)\n",
    "    df_alarm = df[df['alarmup'] == True]\n",
    "    #top graph\n",
    "    ax[0].title.set_text('Defect CUSUMs Process')\n",
    "    ax[0].scatter(df['time'], df['CUSUMup'], s=1, color='purple', label='CUSUM up')\n",
    "    ax[0].scatter(df['time'], df['CUSUMdn'], s=1, color='green', label='CUSUM dn')\n",
    "    ax[0].bar(df_alarm['time'], max(df['CUSUMup']), width = 0.0000001, label='alarm', color='orange')\n",
    "    #middle graph\n",
    "    ax[1].title.set_text('SPRT processes')\n",
    "    ax[1].scatter(df['time'], df['SPRTup'], s=1, color='red', label='SPRT up')\n",
    "    ax[1].scatter(df['time'], df['SPRTdn'], s=1, color='blue', label='SPRT dn')\n",
    "    #bottom graph\n",
    "    ax[2].title.set_text('running min processes')\n",
    "    ax[2].scatter(df['time'], df['runminup'], s=1, color='blue', label='runmin up')\n",
    "    ax[2].scatter(df['time'], df['runmindn'], s=1, color='gold', label='runmin dn')\n",
    "    #label settings\n",
    "    ax[0].set_xlabel(\"Time (s)\")\n",
    "    ax[1].set_xlabel(\"Time (s)\")\n",
    "    ax[2].set_xlabel(\"Time (s)\")\n",
    "    plt.xlim(df['time'].iloc[0], df['time'].iloc[-1])\n",
    "    ax[0].set_ylabel(\"CUSUM Statistic\")\n",
    "    ax[1].set_ylabel(\"SPRT Statistic\")\n",
    "    ax[2].set_ylabel(\"runmin Statistic\")\n",
    "    #display options\n",
    "    for _ in range(3):\n",
    "        ax[_].legend(loc= 'center left',bbox_to_anchor=(1,0.5) )\n",
    "    plt.tight_layout()\n",
    "    plt.savefig(\"fig_3_CUSUM_construction.png\")\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "CUSUM_SPRT_runmin_chart(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Appendix:\n",
    "### Simple log SPRT \n",
    "We demonstrate the log SPRT for a sequence of Poisson RVs. This script will\n",
    "\n",
    "1. Generate a path for a Poisson process at an initial rate $\\lambda_0 = 1$ defect/second for period length 1 second.\n",
    "\n",
    "2. continue simulating the Poisson process at an elevated rate $\\lambda_1 = 4$ defects/second for a period of 1 second.\n",
    "\n",
    "3. Generate a 3 subplot graph illustrating the Poisson process, and SPRT up and SPRT down. \n",
    "\n",
    "4. Generate a 3 subplot graph illustrating how the CUSUM is the SPRT minus its running minimum.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from time import time\n",
    "pois_inst = Poisson()\n",
    "# to have a simple poisson\n",
    "pois_inst.lam = 1\n",
    "pois_inst.period_length = 1\n",
    "pois_inst.get_sequence()\n",
    "pois_inst.lam = 4\n",
    "pois_inst.get_sequence()\n",
    "dfs = pd.Series(pois_inst.process,index=pois_inst.timestamps).resample('10ms').sum()\n",
    "dfs = dfs.cumsum().reset_index()\n",
    "dfs.columns = ['timestamp', 'Proc']\n",
    "lam_est = pois_inst.mle_est()\n",
    "CUSUM_inst = CUSUM(timestamp = dfs['timestamp'].iloc[0], l0=lam_est)\n",
    "CUSUM_inst.h = 1\n",
    "CUSUM_inst.epsilon = 0.01\n",
    "times = convert_tstamp_to_sec(list(dfs['timestamp']))\n",
    "\n",
    "for i in range(1,len(times)):\n",
    "    deltatime = times[i] - times[i-1]\n",
    "    arrival = dfs['Proc'][i] - dfs['Proc'][i-1]\n",
    "    CUSUM_inst.Update(deltatime,arrival,dfs['timestamp'].iloc[i])\n",
    "    \n",
    "df = pd.DataFrame(CUSUM_inst.entries)\n",
    "df['time'] = convert_tstamp_to_sec(df['timestamp'])\n",
    "df['Proc'] = dfs['Proc']\n",
    "def SPRT_chart(df):\n",
    "    fig, ax = plt.subplots(3, sharex=True)\n",
    "    #top graph\n",
    "    ax[0].title.set_text('Poisson Process')\n",
    "    ax[0].scatter(df['time'], df['Proc'], s=1, label='Poisson Process')\n",
    "    #middle graph\n",
    "    ax[1].title.set_text('SPRT up process')\n",
    "    ax[1].scatter(df['time'], df['SPRTup'], s=1, color='red', label='SPRT up')\n",
    "    #bottom graph\n",
    "    ax[2].title.set_text('SPRT down process')\n",
    "    ax[2].scatter(df['time'], df['SPRTdn'], s=1, color='blue', label='SPRT dn')\n",
    "    #label settings\n",
    "    ax[0].set_xlabel(\"Time (s)\")\n",
    "    ax[1].set_xlabel(\"Time (s)\")\n",
    "    ax[2].set_xlabel(\"Time (s)\")\n",
    "    plt.xlim(df['time'].iloc[0], df['time'].iloc[-1])\n",
    "    ax[0].set_ylabel(\"No. of Arrivals\")\n",
    "    ax[1].set_ylabel(\"SPRT Statistic\")\n",
    "    ax[2].set_ylabel(\"SPRT Statistic\")\n",
    "    #display options\n",
    "    for _ in range(3):\n",
    "        ax[_].legend(loc= 'center left',bbox_to_anchor=(1,0.5) )\n",
    "    plt.tight_layout()\n",
    "    plt.savefig(\"fig_2_SPRT_Example.png\")\n",
    "    plt.show()\n",
    "\n",
    "SPRT_chart(df)\n",
    "CUSUM_SPRT_runmin_chart(df)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.10.6 64-bit",
   "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.10.6"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "b0fa6594d8f4cbf19f97940f81e996739fb7646882a419484c72d19e05852a7e"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}