20_approximate_Bayesian_for_estimation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# ICS 434: DATA SCIENCE FUNDAMENTALS\n",
    "\n",
    "## Bayesian Parameter Estimation\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "#!pip install ipywidgets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from scipy.stats import gaussian_kde\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Recall: A/B Testing Example\n",
    "\n",
    "* In an A/B test, we are interested in comparing two versions of a webpage\n",
    "  * We would like to determine which one performs better at a task `X`\n",
    "    \n",
    "* Ex.: Is Version A (new) or Version B (old) better at signing up new users?\n",
    "\n",
    "<center><img src=\"https://www.dropbox.com/scl/fi/52igd0ue8eqzkhln4ilqh/ab.jpg?rlkey=3mq5tqtyj0qwzek9l1avp078u&dl=1\" alt=\"drawing\" style=\"width:600px\"></center>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Bayesian Parameter Estimation\n",
    "\n",
    "* Consider the generative model for the A/B testing experiment in the previous slide \n",
    "* For one person and one webpage prototype, the generative process can be described with the following illustration\n",
    "  * Suppose that a user is equally likely to sign up or forgo signing up ($p=0.5$)\n",
    "<center><img src=\"https://www.dropbox.com/s/9qlph5xr00m1a0b/ab_user.jpg?dl=1\"></center>\n",
    "* Say we are selecting 8 individuals to try Version A, what does the generative process look like?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "cellView": "form",
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 445
    },
    "colab_type": "code",
    "id": "bAL20h-or_eb",
    "outputId": "4ebf6c3d-6e16-42ae-a235-5b8093bea2b3",
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ce94a1f212d94c8ab03b6244ae3072b1",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Button(description='Run the experiment!', style=ButtonStyle())"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "1844c274e44a423797ec5a828b051005",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# @hidden_cell\n",
    "# @title\n",
    "# this will be hidden\n",
    "\n",
    "from IPython.display import HTML, display\n",
    "from ipywidgets import widgets, Output\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import scipy.stats as st\n",
    "\n",
    "p=0.5\n",
    "\n",
    "button = widgets.Button(description = \"Run the experiment!\")\n",
    "display(button)\n",
    "out = Output()\n",
    "display(out)\n",
    "\n",
    "green_link = 'images/green.jpg'\n",
    "red_link = 'images/red.jpg'\n",
    "black_link = 'images/black.jpg'\n",
    "arrow_link = 'images/arrow.jpg'\n",
    "green_guy = \"<td><img src=\" + green_link + \"></td>\"\n",
    "red_guy = \"<td><img src=\" + red_link + \"></td>\"\n",
    "black_guy = \"<td><img src=\" + black_link + \"></td>\"\n",
    "arrow = \"<td><img src=\" + arrow_link + \"></td>\"\n",
    "\n",
    "\n",
    "def on_button_clicked(b):\n",
    "    number_guys = 0\n",
    "    test = st.bernoulli.rvs(p, size=1)\n",
    "    guys = \"\"\n",
    "    for item in test:\n",
    "      if item == 1:\n",
    "        guys = guys + green_guy\n",
    "      else:\n",
    "        guys = guys + red_guy\n",
    "      number_guys += item\n",
    "    \n",
    "    out.clear_output()\n",
    "    with out:\n",
    "        display(HTML(\"<table><tr><td>\" + black_guy + \"</td><td>\" + arrow \n",
    "                     + \"</td><td>\" + guys + \"</td></tr></table>\"))\n",
    "\n",
    "\n",
    "button.on_click(on_button_clicked)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "cellView": "form",
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 520
    },
    "colab_type": "code",
    "id": "ruuj6PmNTmvZ",
    "outputId": "3659593c-3f1a-45f8-dedf-62bf6f9a4bde",
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "1cae7e49ef034a3d9e844ccb55c5f610",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Button(description='Run the experiment!', style=ButtonStyle())"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "1a5bb02573c74093ab4085dc6f3d7b84",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# @hidden_cell\n",
    "# @title\n",
    "# this will be hidden\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import scipy.stats as st\n",
    "from ipywidgets import widgets, Output\n",
    "from IPython.display import HTML, display\n",
    "\n",
    "button = widgets.Button(description = \"Run the experiment!\")\n",
    "display(button)\n",
    "out = Output()\n",
    "display(out)\n",
    "\n",
    "dist_values=[0]*9\n",
    "\n",
    "green_link = 'images/green.jpg'\n",
    "red_link = 'images/red.jpg'\n",
    "green_guy = \"<td><img src=\" + green_link + \"></td>\"\n",
    "red_guy = \"<td><img src=\" + red_link + \"></td>\"\n",
    "\n",
    "def on_button_clicked(b):\n",
    "    p = 0.5\n",
    "    test = st.bernoulli.rvs(p, size=8)\n",
    "    guys = \"\"\n",
    "    number_guys = 0\n",
    "    for item in test:\n",
    "      if item == 1:\n",
    "        guys = guys + green_guy\n",
    "      else:\n",
    "        guys = guys + red_guy\n",
    "      number_guys += item\n",
    "    \n",
    "    out.clear_output()\n",
    "    dist_values[number_guys] += 1\n",
    "    fig = plt.figure(figsize=(14, 5))\n",
    "    plt.style.use('seaborn-v0_8-darkgrid')\n",
    "    \n",
    "    x = np.arange(0, 9)\n",
    "    ns = [8]\n",
    "    ps = [p]\n",
    "    for n, p in zip(ns, ps):\n",
    "        plt.bar(x, dist_values)\n",
    "    plt.bar(x[number_guys], dist_values[number_guys], color='green')\n",
    "    plt.xlabel('number of sign ups', fontsize=14)\n",
    "    plt.ylabel('counts', fontsize=14)\n",
    "    plt.xticks(range(0, 9))\n",
    "    with out:\n",
    "        display(HTML(\"<table><tr>\" + guys + \"</tr></table>\"))\n",
    "        plt.show()\n",
    "#plt.yticks([]);\n",
    "#plt.legend(loc=1)\n",
    "\n",
    "\n",
    "button.on_click(on_button_clicked)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### The Long Run Distribution\n",
    "\n",
    "* If one repeats the experiment many times, the graph will represent the binomial distribution\n",
    "\n",
    "  *  The distribution is parameterized by $n=8$ and $p=0.5$\n",
    "\n",
    "<img src=\"https://www.dropbox.com/scl/fi/cud08wt4l8j2cfy58vaq8/longrun.png?rlkey=a3xjjcb0a8ndvqtk1uvabrppz&dl=1\" width=\"500px\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "aqB7zpc358xw",
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "### Observations\n",
    "\n",
    "* We don't know the signup rates $p_A$ and $p_B$ for Version **A** and **B** a priori \n",
    "* Clearly, we can use the maximum likelihood (ML) to estimate the parameters\n",
    "* However: \n",
    "  * The sample is small and random events can greatly skew estimation\n",
    "  * Confidence interval tells us where the interval may be with 95% confidence\n",
    "    * What we are often interested in is the probability of individual values\n",
    "\n",
    "  * There is no way to encode our belief about the parameter\n",
    "    * Say we know a parameter should be ~ 0.9 because other research showed that\n",
    "    * How can we incorporate that in esimating the parameter? \n",
    "\n",
    "* Our approach needs to take that into consideration"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "aqB7zpc358xw",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Observations\n",
    "\n",
    "* We don't know the signup rates $p_A$ and $p_B$ for Version **A** and **B** a priori \n",
    "* Clearly, we can use the maximum likelihood (ML) to estimate the parameters\n",
    "* However: \n",
    "  * The sample is small and random events can greatly skew estimation\n",
    "  * Confidence interval tells us where the values may be with 95% confidence\n",
    "    * What we are often interested in is the probability of individual values\n",
    "\n",
    "  * There is no way to encode our belief about the parameter\n",
    "    * Say we know a parameter should be ~ 0.9 because other research showed that\n",
    "    * How can we incorporate that in esimating the parameter? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[True, True, True, True, True, False, False, False]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Suppose outcomes are \n",
    "outcomes = [True] * 5 + [False] * 3\n",
    "outcomes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bootstrap = np.random.choice(outcomes, size=8, replace=True)\n",
    "bootstrap_proportion = sum(bootstrap)/len(bootstrap)\n",
    "bootstrap_proportion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.25 , 0.875])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bootstrap_proportions = []\n",
    "for _ in range(10_000):\n",
    "    bootstrap = np.random.choice(outcomes, size=8, replace=True)\n",
    "    bootstrap_proportion = sum(bootstrap)/len(bootstrap)\n",
    "    bootstrap_proportions.append(bootstrap_proportion)\n",
    "np.percentile(bootstrap_proportions, (2.5, 97.5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ True False False  True  True  True False False]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.5"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bootstrap = np.random.choice([True, False], size=8, replace=True)\n",
    "bootstrap_proportion = sum(bootstrap)/len(bootstrap)\n",
    "print(bootstrap)\n",
    "bootstrap_proportion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.125, 0.875])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bootstrap_proportions = []\n",
    "for _ in range(10000):\n",
    "    bootstrap = np.random.choice([True, False], size=8, replace=True)\n",
    "    bootstrap_proportion = sum(bootstrap)/len(bootstrap)\n",
    "    bootstrap_proportions.append(bootstrap_proportion)\n",
    "np.percentile(bootstrap_proportions, (2.5, 97.5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Running the Simulation Backwards\n",
    "\n",
    "* Rather than generate random outcomes of the experiment, we record random parameters that could have yielded the observed results\n",
    "\n",
    "* Which parameters could have generated 5 signups in 8 trials?\n",
    "    * Recall that $p$ is continuous probability between 0 and 1\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "feFOS2XKOR3e",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Bayesian Inference Using Rejection Sampling \n",
    "\n",
    "\n",
    "* For simplicity, we will only consider Version A\n",
    "\n",
    "*  How can we determine the most likely value of parameter $p_A$ for Version A? \n",
    "\n",
    "* For that we will use a simple algorithm for Bayesian Inference called *rejection sampling*  \n",
    " * We simulate parameters and only retain those that agree with our data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Rejection Sampling \n",
    "\n",
    "1.  Sample a parameter value from the set of possible values of $p_A$\n",
    "  * This is called a prior and represents our prior belief on $p_A$\n",
    "  * In our example, we believe that $p_A$ is any possible value in $[0, 1]$ conitnuum\n",
    "   \n",
    "2.  Generate an outcome, given that parameter value (in our example, run the test that is described by Binomial distribution with parameter $p_A$ and number of people $8$)\n",
    "\n",
    "3.  * If the generated outcome is the observed data, record the value of the parameter $p_A$ as a possible value that can generate the observed results\n",
    "    * If the generated outcome is not the observed data, ignore (or reject) the value of the parameter $p_A$\n",
    "4.  Repeat the procedure many times"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Approximate Bayes Using Rejection Sampling -- Cont'd\n",
    "\n",
    "<img src=\"https://www.dropbox.com/scl/fi/3r76bpsb2t6x8ldnnmxe0/rejection.jpg?rlkey=k8wbmqo37cl7qqs0radt25ex6&dl=1\" width=\"1200\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Exploring the Distribution of the Parameter $p$\n",
    "\n",
    "* What does the distribution of $p_A$ look like?\n",
    "\n",
    "  * This ditribution represents the values that most likely generate the observed data\n",
    "  \n",
    "  * I.e., what  we believe, based on observing the data, the value of $p_A$ could have been\n",
    "  \n",
    "* Our prior belief was that  $p_A$ is any value between $0$ and $1$\n",
    "\n",
    "  * Results show that  some values of $p_A$ occur with more probability than other values\n",
    "  * We could have encoded our belief in a way that gives us some values more often than others\n",
    " \n",
    "* The resulting distribution is called the posterior distribution of the parameter $p_A$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 366
    },
    "colab_type": "code",
    "id": "7m4d4ALBl_Ti",
    "outputId": "12ead134-432c-49a5-d130-c23de14579d4",
    "scrolled": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# import packages\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Version A\n",
    "n_A = 8        # number of people Version A was tested on\n",
    "obs_A = 5      # observed number of signups for Version A\n",
    "p_A_recorded = []\n",
    "\n",
    "num_of_recorded_vals = 100_000\n",
    "\n",
    "for _ in range(num_of_recorded_vals):\n",
    "  # Sample a parameter value p_A\n",
    "  p_A = np.random.uniform(0, 1)\n",
    "\n",
    "  # For the p_A, generate an outcome from the Binomal distribution \n",
    "  v_A = np.random.binomial(n_A, p_A)\n",
    "    \n",
    "  # Compare generated outcomes to the observed data\n",
    "  if v_A == obs_A:\n",
    "    p_A_recorded.append(p_A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize=(10, 6)) \n",
    "\n",
    "plt.hist(p_A_recorded, bins=20, alpha=0.75, color=\"#A60628\", edgecolor='black', linewidth=1.2)\n",
    "\n",
    "plt.xlim(0, 1)\n",
    "plt.xlabel(\"Signup rate ($p_A$)\")\n",
    "plt.title(\"Number of Recorded Values for Version A\")\n",
    "plt.style.use([\"seaborn-v0_8-darkgrid\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "GGizV0W7l8oz",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Analyzing the Simulation Results\n",
    "\n",
    "* Histograms shows the probability of $p_A$ to be highest around 0.625\n",
    " * This agrees with the likelihood\n",
    " * This shows that the value could also be, with non-negligible probabilities, in other values\n",
    " \n",
    "* In this case, this does not add much to the likelihood\n",
    "\n",
    "* Imagine, however, that we have another dataset of signups for version A \n",
    "  * Out of 9 users tested, 6 signed up for version A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Updating Our Beliefs\n",
    "\n",
    "* We have already done some work with $p_A$ which led to generate a posterior of $p_A$\n",
    "* Rather than sample $p_A$ uniformly from $[0, 1]$, we can sample it from the posterior \n",
    "  * In this new round the posterior becomes a prior\n",
    "* We can sample from the histogram which represents the posterior"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7941569431184139"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.choice(p_A_recorded)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "# import packages\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Version A\n",
    "n_A = 9        # number of people Version A was tested on\n",
    "obs_A = 6      # observed number of signups for Version A\n",
    "p_A_recorded_experiment_2 = []\n",
    "\n",
    "num_of_recorded_vals = 100_000\n",
    "\n",
    "for _ in range(num_of_recorded_vals):\n",
    "  # Sample a parameter value p_A from the posterior \n",
    "  p_A = np.random.choice(p_A_recorded)\n",
    "\n",
    "  # For the p_A, generate an outcome from the Binomal distribution \n",
    "  v_A = np.random.binomial(n_A, p_A)\n",
    "    \n",
    "  # Compare generated outcomes to the observed data\n",
    "  if v_A == obs_A:\n",
    "    p_A_recorded_experiment_2.append(p_A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize=(10, 6)) \n",
    "\n",
    "plt.hist(p_A_recorded, bins=20, density=True, alpha=0.75, \n",
    "         label=\"Experiment 1\", color=\"#A60628\", edgecolor='black', linewidth=1.2,)\n",
    "plt.hist(p_A_recorded_experiment_2, bins=20, density=True, alpha=0.75, \n",
    "         label=\"Experiment 2\", color=\"#bcadd1\", edgecolor='black', linewidth=1.2)\n",
    "\n",
    "plt.xlim(0, 1)\n",
    "plt.xlabel(\"Signup rate ($p_A$)\")\n",
    "plt.title(\"Frequency of Recorded Values for Experiment 1 and 2\")\n",
    "plt.legend(loc='upper left', fontsize=14)\n",
    "plt.style.use([\"seaborn-v0_8-darkgrid\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# import packages\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Version A\n",
    "n_A = 8        # number of people Version A was tested on\n",
    "obs_A = 6      # observed number of signups for Version A\n",
    "p_A_recorded_experiment_3 = []\n",
    "\n",
    "num_of_recorded_vals = 100_000\n",
    "\n",
    "for _ in range(num_of_recorded_vals):\n",
    "  # Sample a parameter value p_A from the posterior \n",
    "  p_A = np.random.choice(p_A_recorded_experiment_2)\n",
    "\n",
    "  # For the p_A, generate an outcome from the Binomal distribution \n",
    "  v_A = np.random.binomial(n_A, p_A)\n",
    "    \n",
    "  # Compare generated outcomes to the observed data\n",
    "  if v_A == obs_A:\n",
    "    p_A_recorded_experiment_3.append(p_A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize=(10, 6)) \n",
    "\n",
    "plt.hist(p_A_recorded, bins=20, density=True, alpha=0.75, label=\"Experiment 1\", color=\"#a60628\", edgecolor='black', linewidth=1.2,)\n",
    "plt.hist(p_A_recorded_experiment_2, bins=20, density=True, alpha=0.75, \n",
    "         label=\"Experiment 2\", color=\"#bcadd1\", edgecolor='black', linewidth=1.2)\n",
    "plt.hist(p_A_recorded_experiment_3, bins=20, density=True, alpha=0.4, \n",
    "         label=\"Experiment 3\", color=\"#1f5ae6\", edgecolor='black', linewidth=1.2)\n",
    "\n",
    "plt.xlim(0, 1)\n",
    "plt.xlabel(\"Signup rate ($p_A$)\")\n",
    "plt.title(\"Frequency of Recorded Values for Three Experiments\")\n",
    "plt.legend(loc='upper left', fontsize=14);\n",
    "plt.style.use([\"seaborn-v0_8-darkgrid\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "kde1 = gaussian_kde(p_A_recorded, bw_method=0.8)\n",
    "kde2 = gaussian_kde(p_A_recorded_experiment_2, bw_method=0.8)\n",
    "kde3 = gaussian_kde(p_A_recorded_experiment_3, bw_method=0.8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = np.linspace(0, 1, 1000)\n",
    "\n",
    "# Plot KDE for each experiment\n",
    "fig = plt.figure(figsize=(10, 6))\n",
    "\n",
    "plt.plot(x, kde1(x), label=\"Experiment 1\", color=\"#a60628\", linewidth=2)\n",
    "plt.plot(x, kde2(x), label=\"Experiment 2\", color=\"#bcadd1\", linewidth=2)\n",
    "plt.plot(x, kde3(x), label=\"Experiment 3\", color=\"#1f5ae6\", linewidth=2, alpha=0.75)\n",
    "\n",
    "plt.xlim(0, 1)\n",
    "plt.xlabel(\"Signup rate ($p_A$)\")\n",
    "plt.title(\"Kernel Density Estimation for Three Experiments\")\n",
    "plt.legend(loc='upper left', fontsize=14)\n",
    "plt.style.use([\"seaborn-v0_8-darkgrid\"])\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "a4kyzxM1Uhud",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### **Bayesian Inference** for Parameter Estimation\n",
    "---\n",
    "\n",
    "* Bayesian inference allows us to use probability theory to assign probabilities to *parameters*\n",
    "\n",
    "  * Allows for encoding beliefs in a way that is probabilistic\n",
    "  \n",
    "  * Allows for incorporating new data in a way that leverages prior discoveries"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "colab": {
   "collapsed_sections": [],
   "name": "PP_1_Introduction.ipynb",
   "provenance": [],
   "version": "0.3.2"
  },
  "hide_input": false,
  "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.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}