diff --git a/docs/hacker-stats-intro/01-Instructor-Probability_a_simulated_introduction.ipynb b/docs/hacker-stats-intro/01-Instructor-Probability_a_simulated_introduction.ipynb new file mode 100644 index 0000000..774fc83 --- /dev/null +++ b/docs/hacker-stats-intro/01-Instructor-Probability_a_simulated_introduction.ipynb @@ -0,0 +1,1726 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# What is probability? A simulated introduction" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "#Import packages\n", + "import numpy as np\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "sns.set()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Learning Objectives of Part 1" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- To have an understanding of what \"probability\" means, in both Bayesian and Frequentist terms;\n", + "- To be able to simulate probability distributions that model real-world phenomena;\n", + "- To understand how probability distributions relate to data-generating **stories**;\n", + "- To understand and be able to simulate joint probabilities and conditional probabilities;\n", + "- To understand Bayes' Theorem and its utility." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. Probability" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "> To the pioneers such as Bernoulli, Bayes and Laplace, a probability represented a _degree-of-belief_ or plausibility; how much they thought that something was true, based on the evidence at hand. To the 19th century scholars, however, this seemed too vague and subjective an idea to be the basis of a rigorous mathematical theory. So they redefined probability as the _long-run relative frequency_ with which an event occurred, given (infinitely) many repeated (experimental) trials. Since frequencies can be measured, probability was now seen as an objective tool for dealing with _random_ phenomena.\n", + "\n", + "-- _Data Analysis, A Bayesian Tutorial_, Sivia & Skilling (p. 9)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "What type of random phenomena are we talking about here? One example is:\n", + "\n", + "- Knowing that a website has a click-through rate (CTR) of 10%, we can calculate the probability of having 10 people, 9 people, 8 people ... and so on click through, upon drawing 10 people randomly from the population;\n", + "- But given the data of how many people click through, how can we calculate the CTR? And how certain can we be of this CTR? Or how likely is a particular CTR?\n", + "\n", + "Science mostly asks questions of the second form above & Bayesian thinking provides a wonderful framework for answering such questions. Essentially Bayes' Theorem gives us a way of moving from the probability of the data given the model (written as $P(data|model)$) to the probability of the model given the data ($P(model|data)$).\n", + "\n", + "We'll first explore questions of the 1st type using simulation: knowing the model, what is the probability of seeing certain data?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. Simulating probabilities" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "* Let's say that a website has a CTR of 50%, i.e. that 50% of people click through. If we picked 1000 people at random from the population, how likely would it be to find that a certain number of people click?\n", + "\n", + "We can simulate this using `numpy`'s random number generator.\n", + "\n", + "To do so, first note we can use `np.random.rand()` to randomly select floats between 0 and 1 (known as the _uniform distribution_). Below, we do so and plot a histogram:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXkAAAD7CAYAAACPDORaAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAARzUlEQVR4nO3de2yTdd/H8U93YMADRhwtGFyWeGsgEh0mGJ2YTYyOwSjEjUTAqIkSwMMweHvAsbgQJM7D7fzDLEpiNBL9AxXcXGZBnSySkhCIuIxDIIFNJLAVUGCwVdb+nr/s83CLdL16raU/3q+EhK6H6/trx3vlanvNY4wxAgBYKSvdAwAAhg+RBwCLEXkAsBiRBwCLEXkAsBiRBwCLEXkAsFhOugf4b7//fl7RaOJv3c/PH6NTp/qGYaKrF2u+NrDma4PTNWdleTRu3P/84/lXXeSjUeMo8n9d91rDmq8NrPnaMBxrZncNAFiMyAOAxYg8AFiMyAOAxYg8AFiMyAOAxYg8AFjsqnuffCYae90ojcxL/V3558VIyrcJILMQeReMzMuR/99NKd/uN/+Zn/JtAsgs7K4BAIsReQCwGJEHAIsReQCwGJEHAIsReQCwmDVvofzzYkRe79h0jwG4Ll3f2wPhQZ0725/y7cJd1kR+RG52Wt6rLvF+dQyvdH1vf/Of+TqX8q3CbeyuAQCLEXkAsBiRBwCLWbNPHtcGXoQEEkPkkVF4ERJIDLtrAMBiRB4ALEbkAcBiRB4ALMYLrwAuK52HCuFXW7pnSJHv6+vTwoUL9cEHH+imm25SMBjUG2+8oXA4rNmzZ2vlypWSpP3792v16tU6f/68pk+frjVr1ignh58jQCbiUCF2iLu75pdfftGiRYvU1dUlSRoYGFBNTY0aGxvV2tqqzs5Otbe3S5Jeeuklvfbaa9qyZYuMMdq4ceOwDg8AuLK4kd+4caPq6urk8/kkSR0dHSosLFRBQYFycnLk9/sVCAR07NgxDQwMaNq0aZKkyspKBQKB4Z0eAHBFcfelrFu37pLTvb298nq9sdM+n089PT1/+7rX61VPT4+LowIAEpXwDvNoNCqPxxM7bYyRx+P5x68nKj9/TMLXuZZxDP3U4b5OrXTc339ejGhEbnbKt/vXtodjzQlHfuLEiQqFQrHToVBIPp/vb18/efJkbBdPIk6d6lM0ahK+3rX6DzAUurY+bJ/Oxzld9zXf26nj9Y5N64vNTtacleW54pPjhN8nX1RUpCNHjqi7u1uRSEQtLS0qKSnRpEmTlJeXp927d0uSmpqaVFJSkvDAAAD3JPxMPi8vT/X19aqurlY4HFZpaanKy8slSe+8845qa2vV19enqVOn6vHHH3d9YADA0A058m1tbbG/FxcXq7m5+W+XmTJlir788kt3JgMAJI3DGgCAxYg8AFiMYw4AQ5DO47gAySDywBBwHBdkKiIP4KrD/5zcQ+QBXHXS+bt8bcMLrwBgMSIPABYj8gBgMSIPABYj8gBgMSIPABYj8gBgMSIPABYj8gBgMSIPABYj8gBgMSIPABYj8gBgMSIPABYj8gBgMY4nD0fGXjdKI/P49gGudvwrhSMj83L4pQ5ABmB3DQBYjMgDgMWIPABYjH3yGYzfaA8gHiKfwdL1G+0lXgAFMkVSu2uamppUUVGhiooKvfnmm5KkYDAov9+vsrIyNTQ0uDIkAMAZx5Hv7+/XunXrtGHDBjU1NWnXrl1qa2tTTU2NGhsb1draqs7OTrW3t7s5LwAgAY4jH4lEFI1G1d/fr8HBQQ0ODmrMmDEqLCxUQUGBcnJy5Pf7FQgE3JwXAJAAx/vkx4wZo+eff16zZ8/WqFGjdNddd6m3t1derzd2GZ/Pp56eHlcGBQAkznHkDxw4oK+++ko//vijxo4dqxdffFFdXV3yeDyxyxhjLjk9FPn5Y5yOBAAZbTjeLec48tu3b1dxcbHy8/MlSZWVlfroo4+UnZ0du0woFJLP50vodk+d6lM0ahKeh7cSAsh0odC5hK+TleW54pNjx/vkp0yZomAwqAsXLsgYo7a2NhUVFenIkSPq7u5WJBJRS0uLSkpKnG4CAJAkx8/k77vvPu3bt0+VlZXKzc3V7bffrurqas2YMUPV1dUKh8MqLS1VeXm5m/MCABKQ1Iehli5dqqVLl17yteLiYjU3Nyc1FADAHRy7BgAsRuQBwGJEHgAsRuQBwGJEHgAsRuQBwGJEHgAsRuQBwGJEHgAsRuQBwGJEHgAsRuQBwGJEHgAsRuQBwGJEHgAsRuQBwGJEHgAsRuQBwGJEHgAsRuQBwGJEHgAsRuQBwGJEHgAsRuQBwGJEHgAsRuQBwGJEHgAsRuQBwGJJRb6trU2VlZWaPXu2Xn/9dUlSMBiU3+9XWVmZGhoaXBkSAOCM48gfPXpUdXV1amxsVHNzs/bt26f29nbV1NSosbFRra2t6uzsVHt7u5vzAgAS4Djy3333nebMmaOJEycqNzdXDQ0NGjVqlAoLC1VQUKCcnBz5/X4FAgE35wUAJCDH6RW7u7uVm5ur5cuX6/jx47r//vt16623yuv1xi7j8/nU09OT0O3m549xOhIAZDSvd6zrt+k48pFIRLt27dKGDRs0evRoPf300xo5cqQ8Hk/sMsaYS04PxalTfYpGTcLzDMedAwCpFAqdS/g6WVmeKz45dhz58ePHq7i4WDfccIMk6cEHH1QgEFB2dnbsMqFQSD6fz+kmAABJcrxPfubMmdq+fbvOnj2rSCSin376SeXl5Tpy5Ii6u7sViUTU0tKikpISN+cFACTA8TP5oqIiLVmyRIsXL9bFixc1Y8YMLVq0SDfffLOqq6sVDodVWlqq8vJyN+cFACTAceQlacGCBVqwYMElXysuLlZzc3NSQwEA3MEnXgHAYkQeACxG5AHAYkQeACxG5AHAYkQeACxG5AHAYkQeACxG5AHAYkQeACxG5AHAYkQeACxG5AHAYkQeACxG5AHAYkQeACxG5AHAYkQeACxG5AHAYkQeACxG5AHAYkQeACxG5AHAYkQeACxG5AHAYkQeACxG5AHAYq5E/s0339SqVaskScFgUH6/X2VlZWpoaHDj5gEADiUd+R07dmjz5s2SpIGBAdXU1KixsVGtra3q7OxUe3t70kMCAJxJKvJ//PGHGhoatHz5cklSR0eHCgsLVVBQoJycHPn9fgUCAVcGBQAkLqnIv/baa1q5cqWuu+46SVJvb6+8Xm/sfJ/Pp56enuQmBAA4luP0il988YVuvPFGFRcXa9OmTZKkaDQqj8cTu4wx5pLTQ5GfP8bpSACQ0bzesa7fpuPIt7a2KhQKaf78+Tpz5owuXLigY8eOKTs7O3aZUCgkn8+X0O2eOtWnaNQkPM9w3DkAkEqh0LmEr5OV5bnik2PHkf/4449jf9+0aZN27typNWvWqKysTN3d3brpppvU0tKiqqoqp5sAACTJceQvJy8vT/X19aqurlY4HFZpaanKy8vd3AQAIAGuRL6yslKVlZWSpOLiYjU3N7txswCAJPGJVwCwGJEHAIsReQCwGJEHAIsReQCwGJEHAIsReQCwGJEHAIsReQCwGJEHAIsReQCwGJEHAIsReQCwGJEHAIsReQCwGJEHAIsReQCwGJEHAIsReQCwGJEHAIsReQCwGJEHAIsReQCwGJEHAIsReQCwGJEHAIsReQCwGJEHAIslFfn3339fFRUVqqio0FtvvSVJCgaD8vv9KisrU0NDgytDAgCccRz5YDCo7du3a/Pmzfr666+1d+9etbS0qKamRo2NjWptbVVnZ6fa29vdnBcAkADHkfd6vVq1apVGjBih3Nxc/etf/1JXV5cKCwtVUFCgnJwc+f1+BQIBN+cFACTAceRvvfVWTZs2TZLU1dWlb7/9Vh6PR16vN3YZn8+nnp6e5KcEADiSk+wNHDp0SMuWLdPLL7+s7OxsdXV1xc4zxsjj8SR0e/n5Y5IdCQAyktc71vXbTCryu3fv1ooVK1RTU6OKigrt3LlToVAodn4oFJLP50voNk+d6lM0ahKeZTjuHABIpVDoXMLXycryXPHJsePdNcePH9ezzz6rd955RxUVFZKkoqIiHTlyRN3d3YpEImppaVFJSYnTTQAAkuT4mfxHH32kcDis+vr62NcWLlyo+vp6VVdXKxwOq7S0VOXl5a4MCgBInOPI19bWqra29rLnNTc3Ox4IAOAePvEKABYj8gBgMSIPABYj8gBgMSIPABYj8gBgMSIPABYj8gBgMSIPABYj8gBgMSIPABYj8gBgMSIPABYj8gBgMSIPABYj8gBgMSIPABYj8gBgMSIPABYj8gBgMSIPABYj8gBgMSIPABYj8gBgMSIPABYj8gBgMSIPABYj8gBgsWGJ/DfffKM5c+aorKxMn3322XBsAgAwBDlu32BPT48aGhq0adMmjRgxQgsXLtTdd9+tW265xe1NAQDicD3ywWBQ99xzj66//npJ0qxZsxQIBPTcc88N6fpZWR7H2/aNG+X4uslK17ZZs/3bTee2WXNqOelfvOt4jDHG6UCX8+GHH+rChQtauXKlJOmLL75QR0eH1q5d6+ZmAABD4Po++Wg0Ko/n/36yGGMuOQ0ASB3XIz9x4kSFQqHY6VAoJJ/P5/ZmAABD4Hrk7733Xu3YsUOnT59Wf3+/tm7dqpKSErc3AwAYAtdfeJ0wYYJWrlypxx9/XBcvXtSCBQt0xx13uL0ZAMAQuP7CKwDg6sEnXgHAYkQeACxG5AHAYkQeACyWcZGPd/Cz/fv3q7KyUrNmzdLq1as1ODiYhindFW/N33//vebPn6958+bpmWee0ZkzZ9IwpbuGepC7bdu26YEHHkjhZMMn3poPHz6sxx57TPPmzdNTTz11TTzOe/fuVVVVlebNm6dly5bp7NmzaZjSXX19fZo7d65+++23v503LP0yGeTEiRNm5syZ5vfffzfnz583fr/fHDp06JLLVFRUmJ9//tkYY8yrr75qPvvss3SM6pp4az537pyZMWOGOXHihDHGmPfee8+sXbs2XeO6YiiPszHGhEIhU15ebmbOnJmGKd0Vb83RaNSUlZWZ9vZ2Y4wxb7/9tnnrrbfSNa4rhvI4L1q0yGzbts0YY8wbb7xh3n333XSM6po9e/aYuXPnmqlTp5qjR4/+7fzh6FdGPZP//wc/Gz16dOzgZ385duyYBgYGNG3aNElSZWXlJednonhrvnjxourq6jRhwgRJ0uTJk3X8+PF0jeuKeGv+S21t7ZAPfHe1i7fmvXv3avTo0bEPFi5fvlyPPvpousZ1xVAe52g0qvPnz0uS+vv7NXLkyHSM6pqNGzeqrq7uskcBGK5+ZVTke3t75fV6Y6d9Pp96enr+8Xyv13vJ+Zko3prHjRunhx56SJI0MDCg9evX68EHH0z5nG6Kt2ZJ+vTTT3XbbbepqKgo1eMNi3hr/vXXXzV+/HjV1NTo4YcfVl1dnUaPHp2OUV0zlMd51apVqq2t1X333adgMKiFCxemekxXrVu3TtOnT7/secPVr4yKfLyDn9l4cLShruncuXNaunSppkyZoocffjiVI7ou3poPHjyorVu36plnnknHeMMi3poHBwe1c+dOLVq0SJs3b1ZBQYHq6+vTMapr4q15YGBAq1ev1ieffKLt27dr8eLFeuWVV9IxakoMV78yKvLxDn723+efPHky4w+ONpQDvvX29mrx4sWaPHmy1q1bl+oRXRdvzYFAQKFQSFVVVVq6dGls/Zks3pq9Xq8KCwt1++23S5Lmzp2rjo6OlM/ppnhrPnjwoPLy8mKHRXnkkUe0c+fOlM+ZKsPVr4yKfLyDn02aNEl5eXnavXu3JKmpqSnjD44Wb82RSETLly/X7NmztXr16oz/n4sUf80rVqzQli1b1NTUpPXr18vn8+nzzz9P48TJi7fmO++8U6dPn9aBAwckSW1tbZo6dWq6xnVFvDUXFhbqxIkTOnz4sCTphx9+iP2Qs9Gw9Svpl25TrLm52VRUVJiysjKzfv16Y4wxS5YsMR0dHcYYY/bv32+qqqrMrFmzzAsvvGDC4XA6x3XFlda8detWM3nyZDNv3rzYn5qamjRPnLx4j/Nfjh49asW7a4yJv+Y9e/aYqqoqM2fOHPPkk0+akydPpnNcV8Rb87Zt24zf7zdz5841TzzxhPn111/TOa5rZs6cGXt3zXD3iwOUAYDFMmp3DQAgMUQeACxG5AHAYkQeACxG5AHAYkQeACxG5AHAYkQeACz2v8CgZ6KASVelAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Draw 1,000 samples from uniform & plot results\n", + "x = np.random.rand(1000)\n", + "plt.hist(x);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To then simulate the sampling from the population, we check whether each float was greater or less than 0.5. If less than or equal to 0.5, we say the person clicked." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'Number of clicks = 498'" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Computed how many people click\n", + "clicks = x <= 0.5\n", + "n_clicks = sum(clicks)\n", + "f\"Number of clicks = {n_clicks}\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The proportion of people who clicked can be calculated as the total number of clicks over the number of people:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'Proportion who clicked = 0.498'" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Computed proportion of people who clicked\n", + "f\"Proportion who clicked = {n_clicks/len(clicks)}\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Discussion**: Did you get the same answer as your neighbour? If you did, why? If not, why not?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Up for discussion:** Let's say that all you had was this data and you wanted to figure out the CTR (probability of clicking). \n", + "\n", + "* What would your estimate be?\n", + "* Bonus points: how confident would you be of your estimate?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Note:** Although, in the above, we have described _probability_ in two ways, we have not described it mathematically. We're not going to do so rigorously here, but we will say that _probability_ defines a function from the space of possibilities (in the above, the interval $[0,1]$) that describes how likely it is to get a particular point or region in that space. Mike Betancourt has an elegant [Introduction to Probability Theory (For Scientists and Engineers)](https://betanalpha.github.io/assets/case_studies/probability_theory.html) that I can recommend." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Hands-on: more clicking" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Use random sampling to simulate how many people click when the CTR is 0.7. How many click? What proportion?" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of clicks = 702\n", + "Proportion who clicked = 0.702\n" + ] + } + ], + "source": [ + "# Solution\n", + "clicks = x <= 0.7\n", + "n_clicks = sum(clicks)\n", + "print(f\"Number of clicks = {n_clicks}\")\n", + "print(f\"Proportion who clicked = {n_clicks/len(clicks)}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "_Discussion point_: This model is known as the bias coin flip. \n", + "- Can you see why?\n", + "- Can it be used to model other phenomena?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Galapagos finch beaks" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can also calculate such proportions with real-world data. Here we import a dataset of Finch beak measurements from the Galápagos islands. You can find the data [here](https://datadryad.org/resource/doi:10.5061/dryad.9gh90)." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
bandspeciesblengthbdepth
019022fortis10.08.5
119028fortis12.58.9
219032fortis9.37.5
319041fortis10.39.6
419044fortis11.09.2
\n", + "
" + ], + "text/plain": [ + " band species blength bdepth\n", + "0 19022 fortis 10.0 8.5\n", + "1 19028 fortis 12.5 8.9\n", + "2 19032 fortis 9.3 7.5\n", + "3 19041 fortis 10.3 9.6\n", + "4 19044 fortis 11.0 9.2" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Import and view head of data\n", + "df_12 = pd.read_csv('../../data/finch_beaks_2012.csv')\n", + "df_12.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# Store lengths in a pandas series\n", + "lengths = df_12['blength']" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "* What proportion of birds have a beak length > 10 ?" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.8514056224899599" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "p = (sum(lengths > 10))/len(lengths)\n", + "p" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Note:** This is the proportion of birds that have beak length $>10$ in your empirical data, not the probability that any bird drawn from the population will have beak length $>10$." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### A proxy for probability\n", + "\n", + "As stated above, we have calculated a proportion, not a probability. As a proxy for the probability, we can simulate drawing random samples (with replacement) from the data seeing how many lengths are > 10 and calculating the proportion (commonly referred to as [hacker statistics](https://speakerdeck.com/jakevdp/statistics-for-hackers)):" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.8505" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "n_samples = 10000\n", + "sum(np.random.choice(lengths, n_samples, replace=True) > 10)/n_samples" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Another way to simulate coin-flips" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In the above, you have used the uniform distribution to sample from a series of biased coin flips. I want to introduce you to another distribution that you can also use to do so: the **binomial distribution**.\n", + "\n", + "The **binomial distribution** with parameters $n$ and $p$ is defined as the probability distribution of\n", + "\n", + "> the number of heads seen when flipping a coin $n$ times when with $p(heads)=p$." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Note** that this distribution essentially tells the **story** of a general model in the following sense: if we believe that they underlying process generating the observed data has a binary outcome (affected by disease or not, head or not, 0 or 1, clicked through or not), and that one the of the two outcomes occurs with probability $p$, then the probability of seeing a particular outcome is given by the **binomial distribution** with parameters $n$ and $p$." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Any process that matches the coin flip story is a Binomial process (note that you'll see such coin flips also referred to as Bernoulli trials in the literature). So we can also formulate the story of the Binomial distribution as\n", + "\n", + "> the number $r$ of successes in $n$ Bernoulli trials with probability $p$ of success, is Binomially distributed. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We'll now use the binomial distribution to answer the same question as above:\n", + "* If P(heads) = 0.7 and you flip the coin ten times, how many heads will come up?\n", + "\n", + "We'll also set the seed to ensure reproducible results." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "7" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Set seed\n", + "np.random.seed(seed=16071982)\n", + "\n", + "# Simulate one run of flipping the biased coin 10 times\n", + "np.random.binomial(10, 0.7)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Simulating many times to get the distribution\n", + "\n", + "In the above, we have simulated the scenario once. But this only tells us one potential outcome. To see how likely it is to get $n$ heads, for example, we need to simulate it a lot of times and check what proportion ended up with $n$ heads." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Simulate 1,000 run of flipping the biased coin 10 times\n", + "x = np.random.binomial(10, 0.3, 10000)\n", + "\n", + "# Plot normalized histogram of results\n", + "plt.hist(x, density=True, bins=10);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "* Group chat: what do you see in the above?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Hands-on" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- If I flip a biased coin ($P(H)=0.3$) 20 times, what is the probability of 5 or more heads?" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.7613" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Solution\n", + "sum(np.random.binomial(20, 0.3, 10000) >= 5)/10000" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- If I flip a fair coin 20 times, what is the probability of 5 or more heads?" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.994" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sum(np.random.binomial(20,0.5,10000) >= 5)/10000" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- Plot the normalized histogram of number of heads of the following experiment: flipping a fair coin 10 times." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot histogram \n", + "x = np.random.binomial(10, 0.5, 10000)\n", + "plt.hist(x, density=True, bins=10);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Note:** you may have noticed that the _binomial distribution_ can take on only a finite number of values, whereas the _uniform distribution_ above can take on any number between $0$ and $1$. These are different enough cases to warrant special mention of this & two different names: the former is called a _probability mass function_ (PMF) and the latter a _probability distribution function_ (PDF). Time permitting, we may discuss some of the subtleties here. If not, all good texts will cover this. I like (Sivia & Skilling, 2006), among many others.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Question:** \n", + "* Looking at the histogram, can you tell me the probability of seeing 4 or more heads?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Enter the ECDF." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Empirical cumulative distribution functions (ECDFs)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "An ECDF is, as an alternative to a histogram, a way to visualize univariate data that is rich in information. It allows you to visualize all of your data and, by doing so, avoids the very real problem of binning.\n", + "- can plot control plus experiment\n", + "- data plus model!\n", + "- many populations\n", + "- can see multimodality (though less pronounced) -- a mode becomes a point of inflexion!\n", + "- can read off so much: e.g. percentiles.\n", + "\n", + "See Eric Ma's great post on ECDFS [here](https://ericmjl.github.io/blog/2018/7/14/ecdfs/) AND [this twitter thread](https://twitter.com/allendowney/status/1019171696572583936) (thanks, Allen Downey!).\n", + "\n", + "So what is this ECDF? \n", + "\n", + "**Definition:** In an ECDF, the x-axis is the range of possible values for the data & for any given x-value, the corresponding y-value is the proportion of data points less than or equal to that x-value." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's define a handy ECDF function that takes in data and outputs $x$ and $y$ data for the ECDF." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "def ecdf(data):\n", + " \"\"\"Compute ECDF for a one-dimensional array of measurements.\"\"\"\n", + " # Number of data points\n", + " n = len(data)\n", + "\n", + " # x-data for the ECDF\n", + " x = np.sort(data)\n", + "\n", + " # y-data for the ECDF\n", + " y = np.arange(1, n+1) / n\n", + "\n", + " return x, y" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Hands-on" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Plot the ECDF for the previous hands-on exercise. Read the answer to the following question off the ECDF: the probability of seeing 4 or more heads?" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Generate x- and y-data for the ECDF\n", + "x_flips, y_flips = ecdf(x)\n", + "\n", + "# Plot the ECDF\n", + "plt.plot(x_flips, y_flips, marker='.', linestyle='none');" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3. PROBABILITY DISTRIBUTIONS AND THEIR STORIES" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Credit:** Thank you to [Justin Bois](http://bois.caltech.edu/) for countless hours of discussion, work and collaboration on thinking about probability distributions and their stories. All of the following is inspired by Justin & his work, if not explicitly drawn from." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "___\n", + "\n", + "In the above, we saw that we could match data-generating processes with binary outcomes to the story of the binomial distribution.\n", + "\n", + "> The Binomial distribution's story is as follows: the number $r$ of successes in $n$ Bernoulli trials with probability $p$ of success, is Binomially distributed. \n", + "\n", + "There are many other distributions with stories also!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Poisson processes and the Poisson distribution" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In the book [Information Theory, Inference and Learning Algorithms](https://www.amazon.com/Information-Theory-Inference-Learning-Algorithms/dp/0521642981) David MacKay tells the tale of a town called Poissonville, in which the buses have an odd schedule. Standing at a bus stop in Poissonville, the amount of time you have to wait for a bus is totally independent of when the previous bus arrived. This means you could watch a bus drive off and another arrive almost instantaneously, or you could be waiting for hours.\n", + "\n", + "Arrival of buses in Poissonville is what we call a Poisson process. The timing of the next event is completely independent of when the previous event happened. Many real-life processes behave in this way. \n", + "\n", + "* natural births in a given hospital (there is a well-defined average number of natural births per year, and the timing of one birth is independent of the timing of the previous one);\n", + "* Landings on a website;\n", + "* Meteor strikes;\n", + "* Molecular collisions in a gas;\n", + "* Aviation incidents.\n", + "\n", + "Any process that matches the buses in Poissonville **story** is a Poisson process.\n", + "\n", + " " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The number of arrivals of a Poisson process in a given amount of time is Poisson distributed. The Poisson distribution has one parameter, the average number of arrivals in a given length of time. So, to match the story, we could consider the number of hits on a website in an hour with an average of six hits per hour. This is Poisson distributed." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYsAAAD7CAYAAACbtbj+AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nO3df1CUd2LH8ffCLivJkqF4u4Kc56RpOna0leusc+cls9t0egJZVhsuXiNUmkkzJs7VcDYhRaAwXEM1zka5zh3aTDP3B3c3DWcvoHZZezMe2sTMVZmejo3tpDmxiSjsCj1+KLC7PP3DcyuS84EFZY2f14yDz5fnu3y/3/3CZ5/vs8+zFsMwDERERG4jbaEbICIiqU9hISIiphQWIiJiSmEhIiKmFBYiImJKYSEiIqYUFiIiYsq60A24UwYHR5mcTO4SksWLHVy5MjLPLfrs0PiY0xjdnsbH3N0eo7Q0C7/xGw/+2u9/ZsNictJIOixu1JdfT+NjTmN0exofc6k0RlqGEhERUwoLERExpbAQERFTCgsRETGlsBAREVMzCouRkRFKSkr45JNPAPj3f/93vv71r+Pz+fjLv/xLJiYmADh37hylpaUUFhZSW1tLLBYDoLe3l/LycoqKiti6dSujo6MADA0NsWXLFoqLiykvLyccDgMwMTFBVVUVxcXFPPXUU3z00Ufz3nEREZk507A4ffo0mzZtoqenB7geHNu2beNb3/oW//zP/wzAgQMHAKiqqqK+vp4jR45gGAZtbW0ANDY2UlZWRigUYtWqVbS0tADQ3NyM2+2ms7OTjRs30tTUBEBrayuZmZl0dnZSU1PDjh075r3jIiIyc6Zh0dbWRkNDAy6XC4D33nuPgoICVqxYAUBdXR1f/epXuXjxImNjYxQUFABQWlpKKBQiGo1y8uRJCgsLp5QDdHV14ff7ASgpKeH48eNEo1G6urpYv349AGvWrGFgYIDe3t557roshKyHMnE6s2b9L+uhzIVuush9zfSivBuv9m+4cOECDzzwANu3b+cXv/gFv//7v091dTUffPABTqczsZ/T6aSvr4/BwUEcDgdWq3VKOUB/f3+ijtVqxeFwMDAwMKX8Rp3Lly+zdOnSGXds8WLHjPf9NE5n1pzqf5ZNRONzGh//yx2zrnPojQ0suseeE82h29P4mEulMZr1FdzxeJx3332Xt99+m6VLl1JbW8ubb77JV77yFSwWS2I/wzCwWCyJrze7dfvmOmlpadPq3CifjStXRpK++tHpzCIcHk6q7v3A6cxK6g8+XP+jn6x76TnRHLo9jY+5uz1GaWmW277InvW7oT73uc+xevVqli1bRnp6OsXFxZw5c4bc3NzECWqASCSCy+UiJyeH4eFh4vE4AOFwOLGk5XK5iEQiAMRiMUZHR8nOzmbJkiX09/dPeywREVkYsw6Lxx9/nP/4j//g0qVLAPz0pz9l5cqV5OfnY7fb6e7uBqCjowOPx4PNZsPtdhMMBgFob2/H4/EA4PV6aW9vByAYDOJ2u7HZbHi9Xjo6rr9yPXXqFHa7fVZLUCIiMr9mvQyVl5fHt771LV588UXGx8f5nd/5Hf7qr/4KgEAgQF1dHSMjI6xcuZKKigoAGhoaqK6uZt++feTl5bFnzx4AKisrqa6uxufzkZWVRSAQAGDz5s3U19fj8/nIyMhg9+7d89VfERFJgsUwjNS5reE80jmLO2eu5yySPcF9Lz0nmkO3p/Exd8+fsxARkfuPwkJEREwpLERExJTCQkRETCksRETElMJCRERMKSxERMSUwkJEREwpLERExJTCQkRETCksRETElMJCRERMKSxERMSUwkJEREwpLERExJTCQkRETM0oLEZGRigpKeGTTz6ZUv7973+fzZs3J7bPnTtHaWkphYWF1NbWEovFAOjt7aW8vJyioiK2bt3K6OgoAENDQ2zZsoXi4mLKy8sTn+E9MTFBVVUVxcXFPPXUU3z00Ufz0lkREUmOaVicPn2aTZs20dPTM6X8v//7v3nzzTenlFVVVVFfX8+RI0cwDIO2tjYAGhsbKSsrIxQKsWrVKlpaWgBobm7G7XbT2dnJxo0baWpqAqC1tZXMzEw6Ozupqalhx44d89FXERFJkmlYtLW10dDQgMvlSpRNTExQX1/PSy+9lCi7ePEiY2NjFBQUAFBaWkooFCIajXLy5EkKCwunlAN0dXXh9/sBKCkp4fjx40SjUbq6uli/fj0Aa9asYWBggN7e3nnqsoiIzJbVbIcbr/Zv9sYbb/C1r32Nz3/+84my/v5+nE5nYtvpdNLX18fg4CAOhwOr1Tql/NY6VqsVh8PBwMDApz7W5cuXWbp0aZLdFBGRuTANi1u99957XLp0iR07dvCzn/0sUT45OYnFYklsG4aBxWJJfL3Zrds310lLS5tW50b5bNzug8dnwunMmlN9mX/32nNyr7X3btP4mEulMZp1WBw+fJgPP/yQDRs2cPXqVSKRCN/85jepqqpKnKAGiEQiuFwucnJyGB4eJh6Pk56eTjgcTixpuVwuIpEIubm5xGIxRkdHyc7OZsmSJfT39/OFL3xhymPNxpUrI0xOGrPtHnD9CQqHh5Oqez9YqAl8Lz0nmkO3p/Exd7fHKC3NctsX2bN+6+zOnTvp7Oyko6OD1157jVWrVtHc3Ex+fj52u53u7m4AOjo68Hg82Gw23G43wWAQgPb2djweDwBer5f29nYAgsEgbrcbm82G1+ulo6MDgFOnTmG327UEJSKygGZ9ZHE7gUCAuro6RkZGWLlyJRUVFQA0NDRQXV3Nvn37yMvLY8+ePQBUVlZSXV2Nz+cjKyuLQCAAwObNm6mvr8fn85GRkcHu3bvns5lyD5qIxpM+ohkbjzE8dG2eWyRyf7EYhpHcWk2K0zLUneN0ZuF/uSOpuofe2JBU3WTr3ah7t59PzaHb0/iYu+eXoURE5P6jsBAREVMKCxERMTWvJ7jl3pL1UCaL7JoCImJOfynuY4vs1qRPNovI/UXLUCIiYkphISIiphQWIiJiSmEhIiKmFBYiImJKYSEiIqYUFiIiYkphISIiphQWIiJiSmEhIiKmFBYiImJKYSEiIqZmFBYjIyOUlJTwySefAPD2229TUlKC3+9nx44dTExMAHDu3DlKS0spLCyktraWWCwGQG9vL+Xl5RQVFbF161ZGR0cBGBoaYsuWLRQXF1NeXk44HAZgYmKCqqoqiouLeeqpp/joo4/mveMiIjJzpmFx+vRpNm3aRE9PDwDnz5/nrbfe4h//8R85ePAgk5OT/PCHPwSgqqqK+vp6jhw5gmEYtLW1AdDY2EhZWRmhUIhVq1bR0tICQHNzM263m87OTjZu3EhTUxMAra2tZGZm0tnZSU1NDTt27LgTfRcRkRkyDYu2tjYaGhpwuVwAZGRk0NDQgMPhwGKx8Nu//dv09vZy8eJFxsbGKCgoAKC0tJRQKEQ0GuXkyZMUFhZOKQfo6urC7/cDUFJSwvHjx4lGo3R1dbF+/XoA1qxZw8DAAL29vfPfexERmRHTz7O48Wr/hvz8fPLz8wEYGBjgBz/4ATt37qS/vx+n05nYz+l00tfXx+DgIA6HA6vVOqUcmFLHarXicDgYGBj41Me6fPkyS5cunWN3RUQkGUl/+FFfXx/PP/88X/va1/jSl75Ed3c3Fosl8X3DMLBYLImvN7t1++Y6aWlp0+rcKJ+NxYsds9r/Vk5n1pzqS2pZiOdTc+j2ND7mUmmMkgqLjz76iOeff57Nmzfz3HPPAZCbm5s4QQ0QiURwuVzk5OQwPDxMPB4nPT2dcDicWNJyuVxEIhFyc3OJxWKMjo6SnZ3NkiVL6O/v5wtf+MKUx5qNK1dGmJw0kukeTmcW4fBwUnXvJak0Ee+0u/183i9zKFkaH3N3e4zS0iy3fZE967fOjoyM8Od//udUVlYmggKuL0/Z7Xa6u7sB6OjowOPxYLPZcLvdBINBANrb2/F4PAB4vV7a29sBCAaDuN1ubDYbXq+Xjo7rH/d56tQp7Ha7lqBERBbQrMPiwIEDRCIRvve977FhwwY2bNjAt7/9bQACgQA7d+6kqKiIq1evUlFRAUBDQwNtbW08+eSTnDp1im9+85sAVFZW8vOf/xyfz8cPf/hD6uvrAdi8eTMTExP4fD6amprYvXv3fPVXRESSMONlqKNHjwLw7LPP8uyzz37qPitWrODAgQPTyvPz82ltbZ1Wnp2dzf79+6eV2+12Xn/99Zk2TURE7jBdwS0iIqYUFiIiYkphISIiphQWIiJiSmEhIiKmFBYiImJKYSEiIqYUFiIiYkphISIiphQWIiJiSmEhIiKmFBYiImJKYSEiIqYUFiIiYkphISIiphQWIiJiKqnP4Ba5l0xE40l93vjYeIzhoWt3oEUi954ZhcXIyAjPPPMM+/fv5/Of/zwnTpxg586djI+PU1xczPbt2wE4d+4ctbW1jI6O4na7aWxsxGq10tvbS1VVFVeuXOHhhx8mEAjw4IMPMjQ0xCuvvMLHH39MTk4Ozc3NOJ1OJiYmqK2t5ezZsyxatIhAIMAjjzxyRwdCPrsybOn4X+6Ydb1Db2xg+A60R+ReZLoMdfr0aTZt2kRPTw8AY2Nj1NTU0NLSQjAY5OzZsxw7dgyAqqoq6uvrOXLkCIZh0NbWBkBjYyNlZWWEQiFWrVpFS0sLAM3Nzbjdbjo7O9m4cSNNTU0AtLa2kpmZSWdnJzU1NezYseNO9F1ERGbINCza2tpoaGjA5XIBcObMGZYvX86yZcuwWq34/X5CoRAXL15kbGyMgoICAEpLSwmFQkSjUU6ePElhYeGUcoCuri78fj8AJSUlHD9+nGg0SldXF+vXrwdgzZo1DAwM0NvbO/+9FxGRGTFdhrrxav+G/v5+nE5nYtvlctHX1zet3Ol00tfXx+DgIA6HA6vVOqX81seyWq04HA4GBgY+9bEuX77M0qVLZ9yxxYsdM9730ySzxi2fPXOZB5pDt6fxMZdKYzTrE9yTk5NYLJbEtmEYWCyWX1t+4+vNbt2+uU5aWtq0OjfKZ+PKlREmJ41Z1bnB6cwiHP7sr1an0kRMVcnOg/tlDiVL42Pubo9RWprlti+yZ/3W2dzcXMLhcGI7HA7jcrmmlUciEVwuFzk5OQwPDxOPx6fsD9ePSiKRCACxWIzR0VGys7NZsmQJ/f390x5LREQWxqzDYvXq1Zw/f54LFy4Qj8c5fPgwHo+H/Px87HY73d3dAHR0dODxeLDZbLjdboLBIADt7e14PB4AvF4v7e3tAASDQdxuNzabDa/XS0fH9XevnDp1CrvdPqslKBERmV+zXoay2+3s2rWLbdu2MT4+jtfrpaioCIBAIEBdXR0jIyOsXLmSiooKABoaGqiurmbfvn3k5eWxZ88eACorK6mursbn85GVlUUgEABg8+bN1NfX4/P5yMjIYPfu3fPVXxERScKMw+Lo0aOJ/69du5aDBw9O22fFihUcOHBgWnl+fj6tra3TyrOzs9m/f/+0crvdzuuvvz7TpomIyB2m232IiIgphYWIiJhSWIiIiCmFhYiImFJYiIiIKYWFiIiYUliIiIgphYWIiJjSJ+Xd47IeymSRXU+jiNxZ+itzj1tktyb1KXBw/ZPgRERmQstQIiJiSmEhIiKmFBYiImJKYSEiIqYUFiIiYkphISIiphQWIiJiak5h0dHRgc/nw+fzJT7Z7sSJE/j9ftatW8fevXsT+547d47S0lIKCwupra0lFosB0NvbS3l5OUVFRWzdupXR0VEAhoaG2LJlC8XFxZSXlxMOh+fSVBERmYOkw+LatWs0NTXR2tpKR0cHp06d4ujRo9TU1NDS0kIwGOTs2bMcO3YMgKqqKurr6zly5AiGYdDW1gZAY2MjZWVlhEIhVq1aRUtLCwDNzc243W46OzvZuHEjTU1N89BdERFJRtJhEY/HmZyc5Nq1a8RiMWKxGA6Hg+XLl7Ns2TKsVit+v59QKMTFixcZGxujoKAAgNLSUkKhENFolJMnT1JYWDilHKCrqwu/3w9ASUkJx48fJxqNzrW/IiKShKRv9+FwOKisrKS4uJjMzEzWrFlDf38/TqczsY/L5aKvr29audPppK+vj8HBQRwOB1ardUo5MKWO1WrF4XAwMDDAkiVLZtS+xYsdyXbtV23JmlN9+WyYyzzQHLo9jY+5VBqjpMPiP//zP/mnf/onfvrTn5KVlcUrr7xCT08PFoslsY9hGFgsFiYnJz+1/MbXm926fXOdtLSZHwhduTLC5KQxy15d53RmEQ4PJ1X3bkulyfRZlOw8uJfm0ELQ+Ji722OUlma57YvspJeh3n33XdauXcvixYvJyMigtLSUn/3sZ1NORIfDYVwuF7m5uVPKI5EILpeLnJwchoeHicfjU/aH60clkUgEgFgsxujoKNnZ2ck2V0RE5iDpsFixYgUnTpzg6tWrGIbB0aNHWb16NefPn+fChQvE43EOHz6Mx+MhPz8fu91Od3c3cP1dVB6PB5vNhtvtJhgMAtDe3o7H4wHA6/XS3t4OQDAYxO12Y7PZ5tpfERFJQtLLUI8//jgffPABpaWl2Gw2fvd3f5dt27bx2GOPsW3bNsbHx/F6vRQVFQEQCASoq6tjZGSElStXUlFRAUBDQwPV1dXs27ePvLw89uzZA0BlZSXV1dX4fD6ysrIIBALz0F0REUnGnD7PYsuWLWzZsmVK2dq1azl48OC0fVesWMGBAwemlefn59Pa2jqtPDs7m/3798+leSIiMk90BbeIiJhSWIiIiCmFhYiImFJYiIiIKYWFiIiYUliIiIgphYWIiJhSWIiIiCmFhYiImJrTFdwin2UT0XjSd/WdiMbnuTUiC0thIfJrZNjS8b/ckVTdQ29smOfWiCwsLUOJiIgphYWIiJhSWIiIiCmFhYiImFJYiIiIqTmFxdGjRyktLaW4uJjXXnsNgBMnTuD3+1m3bh179+5N7Hvu3DlKS0spLCyktraWWCwGQG9vL+Xl5RQVFbF161ZGR0cBGBoaYsuWLRQXF1NeXj7lM7xFROTuSjosPv74YxoaGmhpaeHgwYN88MEHHDt2jJqaGlpaWggGg5w9e5Zjx44BUFVVRX19PUeOHMEwDNra2gBobGykrKyMUCjEqlWraGlpAaC5uRm3201nZycbN26kqalpHrorIiLJSDosfvKTn/Dkk0+Sm5uLzWZj7969ZGZmsnz5cpYtW4bVasXv9xMKhbh48SJjY2MUFBQAUFpaSigUIhqNcvLkSQoLC6eUA3R1deH3+wEoKSnh+PHjRKPRufZXRESSkPRFeRcuXMBms/Hiiy9y6dIl/uAP/oBHH30Up9OZ2MflctHX10d/f/+UcqfTSV9fH4ODgzgcDqxW65RyYEodq9WKw+FgYGCAJUuWJNtkERFJUtJhEY/HOXXqFK2trTzwwANs3bqVRYsWYbFYEvsYhoHFYmFycvJTy298vdmt2zfXSUub+YHQ4sWOWfZoqmRv8yByg+bQ7Wl8zKXSGCUdFp/73OdYu3YtOTk5APzRH/0RoVCI9PT0xD7hcBiXy0Vubu6UE9SRSASXy0VOTg7Dw8PE43HS09MT+8P1o5JIJEJubi6xWIzR0VGys7Nn3L4rV0aYnDSS6pvTmUU4PJxU3bstlSaTTHWvzKGFcC/9ji2Uuz1GaWmW277ITvqcxRNPPMG7777L0NAQ8Xicf/3Xf6WoqIjz589z4cIF4vE4hw8fxuPxkJ+fj91up7u7G4COjg48Hg82mw23200wGASgvb0dj8cDgNfrpb29HYBgMIjb7cZmsyXbXBERmYOkjyxWr17N888/T1lZGdFolMcee4xNmzbxm7/5m2zbto3x8XG8Xi9FRUUABAIB6urqGBkZYeXKlVRUVADQ0NBAdXU1+/btIy8vjz179gBQWVlJdXU1Pp+PrKwsAoHAPHRXRESSMae7zj799NM8/fTTU8rWrl3LwYMHp+27YsUKDhw4MK08Pz+f1tbWaeXZ2dns379/Ls0TEZF5oiu4RUTElMJCRERMKSxERMSUwkJEREwpLERExJTCQkRETCksRETElMJCRERMKSxERMSUwkJEREwpLERExJTCQkRETCksRETElMJCRERMKSxERMTUnD7PQuZP1kOZLLLr6RCR1KS/Tilikd2K/+WOWdc79MaGO9AaEZGp5mUZ6vXXX6e6uhqAEydO4Pf7WbduHXv37k3sc+7cOUpLSyksLKS2tpZYLAZAb28v5eXlFBUVsXXrVkZHRwEYGhpiy5YtFBcXU15eTjgcno+miohIEuYcFu+//z7vvPMOAGNjY9TU1NDS0kIwGOTs2bMcO3YMgKqqKurr6zly5AiGYdDW1gZAY2MjZWVlhEIhVq1aRUtLCwDNzc243W46OzvZuHEjTU1Nc22qiIgkaU5h8b//+7/s3buXF198EYAzZ86wfPlyli1bhtVqxe/3EwqFuHjxImNjYxQUFABQWlpKKBQiGo1y8uRJCgsLp5QDdHV14ff7ASgpKeH48eNEo9G5NFfkrpmIxnE6s2b9L+uhzIVuusinmtM5i/r6erZv386lS5cA6O/vx+l0Jr7vcrno6+ubVu50Ounr62NwcBCHw4HVap1SfutjWa1WHA4HAwMDLFmyZC5NFrkrMmzpSZ+DGr4D7RGZq6TD4kc/+hF5eXmsXbuWH//4xwBMTk5isVgS+xiGgcVi+bXlN77e7Nbtm+ukpc38QGjxYsdsujON05k1p/oiybpf5t790s+5SKUxSjosgsEg4XCYDRs28Mtf/pKrV69y8eJF0tPTE/uEw2FcLhe5ublTTlBHIhFcLhc5OTkMDw8Tj8dJT09P7A/Xj0oikQi5ubnEYjFGR0fJzs6ecfuuXBlhctJIqm9OZxbh8N19fZdKk0IW1t2eewthIX7H7jV3e4zS0iy3fZGd9DmL733vexw+fJiOjg5eeukl/vAP/5B/+Id/4Pz581y4cIF4PM7hw4fxeDzk5+djt9vp7u4GoKOjA4/Hg81mw+12EwwGAWhvb8fj8QDg9Xppb28HrgeT2+3GZrMl21wREZmDeb3Owm63s2vXLrZt28b4+Dher5eioiIAAoEAdXV1jIyMsHLlSioqKgBoaGigurqaffv2kZeXx549ewCorKykuroan89HVlYWgUBgPpsqIiKzMC9hUVpaSmlpKQBr167l4MGD0/ZZsWIFBw4cmFaen59Pa2vrtPLs7Gz2798/H80TEZE50r2hRETElMJCRERMKSxERMSUwkJEREwpLERExJTCQkRETCksRETElMJCRERMKSxERMSUwkJEREwpLERExJTCQkRETCksRETElMJCRERMKSxERMSUwkJEREwpLERExNScPinvO9/5Dp2dncD1z8x+9dVXOXHiBDt37mR8fJzi4mK2b98OwLlz56itrWV0dBS3201jYyNWq5Xe3l6qqqq4cuUKDz/8MIFAgAcffJChoSFeeeUVPv74Y3JycmhubsbpdM69xyIpbCIax+nMSqru2HiM4aFr89wikeuSDosTJ07w7rvv8s4772CxWHj++ec5fPgwgUCA1tZW8vLyeOGFFzh27Bher5eqqipee+01CgoKqKmpoa2tjbKyMhobGykrK8Pn8/Hd736XlpYWqqqqaG5uxu128+abb9Le3k5TUxPNzc3z2XeRlJNhS8f/ckdSdQ+9sYHheW6PyA1JL0M5nU6qq6vJyMjAZrPxyCOP0NPTw/Lly1m2bBlWqxW/308oFOLixYuMjY1RUFAAXP/M7lAoRDQa5eTJkxQWFk4pB+jq6sLv9wNQUlLC8ePHiUajc+2viIgkIemwePTRRxN//Ht6eujs7MRisUxZKnK5XPT19dHf3z+l3Ol00tfXx+DgIA6HA6vVOqUcmFLHarXicDgYGBhItrkiIjIHczpnAfDhhx/ywgsv8Oqrr5Kenk5PT0/ie4ZhYLFYmJycxGKxTCu/8fVmt27fXCctbebZtnixY3YduUWy68YiC+lemrf3UlsXSiqN0ZzCoru7m5deeomamhp8Ph//9m//RjgcTnw/HA7jcrnIzc2dUh6JRHC5XOTk5DA8PEw8Hic9PT2xP1w/KolEIuTm5hKLxRgdHSU7O3vGbbtyZYTJSSOpfjmdWYTDd3f1N5Umhdy77va8TdZC/I7da+72GKWlWW77IjvpZahLly7xjW98g0AggM/nA2D16tWcP3+eCxcuEI/HOXz4MB6Ph/z8fOx2O93d3QB0dHTg8Xiw2Wy43W6CwSAA7e3teDwe4Pq7q9rb2wEIBoO43W5sNluyzRURkTlI+sjirbfeYnx8nF27diXKnnnmGXbt2sW2bdsYHx/H6/VSVFQEQCAQoK6ujpGREVauXElFRQUADQ0NVFdXs2/fPvLy8tizZw8AlZWVVFdX4/P5yMrKIhAIzKWfIiIyB0mHRV1dHXV1dZ/6vYMHD04rW7FiBQcOHJhWnp+fT2tr67Ty7Oxs9u/fn2zzRERkHukKbhERMTXnd0PJ/8t6KJNFdg2piHz26C/bPFpkt87p6lsRkVSlZSgRETGlsBAREVMKCxERMaVzFiKfEcne3ly3NpeZUFiIfEYke3tz3dpcZkLLUCIiYkphISIiphQWIiJiSmEhIiKmFBYiImJKYSEiIqb01lmR+1yy12eArtG4nygsRO5zyV6fAbpG436iZSgRETGV0kcWhw4dYt++fcRiMf7sz/6M8vLyu/Jz53JYLnI/SfZ3ZSIavwOtkTspZcOir6+PvXv38uMf/5iMjAyeeeYZvvSlL/Fbv/Vbd/xnz+W2CSL3E/2u3D9SNixOnDjBl7/8ZbKzswEoLCwkFArxF3/xFzOqn5ZmmdPPd/1G5l2tp5+pn3k//cy5HL2Pj8cYGRlLqu69Zq5/x+bzZ1kMwzDuUltm5e///u+5evUq27dvB+BHP/oRZ86c4W/+5m8WuGUiIveflD3BPTk5icXy/0lnGMaUbRERuXtSNixyc3MJh8OJ7XA4jMvlWsAWiYjcv1I2LL7yla/w/vvvMzAwwLVr1/iXf/kXPB7PQjdLROS+lLInuJcsWcL27dupqKggGo3y9NNP83u/93sL3SwRkftSyp7gFhGR1JGyy1AiImQe0kcAAAOCSURBVJI6FBYiImJKYSEiIqYUFiIiYkphcZNDhw7x5JNPsm7dOn7wgx8sdHNS0ubNm/H5fGzYsIENGzZw+vTphW5SShgZGaGkpIRPPvkEuH67Gr/fz7p169i7d+8Ct27h3To+O3bsYN26dYl59JOf/GSBW7iwvvOd7+Dz+fD5fOzevRtIwTlkiGEYhnH58mXjiSeeMAYHB43R0VHD7/cbH3744UI3K6VMTk4ajz/+uBGNRhe6KSnl5z//uVFSUmKsXLnS+Pjjj41r164ZXq/X+J//+R8jGo0azz33nNHV1bXQzVwwt46PYRhGSUmJ0dfXt8AtSw3vvfee8Sd/8ifG+Pi4MTExYVRUVBiHDh1KuTmkI4tfufnGhQ888EDixoXy/37xi18A8Nxzz7F+/Xq+//3vL3CLUkNbWxsNDQ2JOwycOXOG5cuXs2zZMqxWK36//76eS7eOz7Vr1+jt7aWmpga/38/f/d3fMTk5ucCtXDhOp5Pq6moyMjKw2Ww88sgj9PT0pNwcStmL8u62/v5+nE5nYtvlcnHmzJkFbFHqGRoaYu3atfz1X/810WiUiooKHn74YR577LGFbtqCampqmrL9aXOpr6/vbjcrZdw6PpFIhC9/+cs0NDSQlZXFCy+8wIEDB/j617++QC1cWI8++mji/z09PXR2dvKnf/qnKTeHdGTxK7pxobkvfvGL7N69m6ysLHJycnj66ac5duzYQjcr5Wgu3d6yZcv47ne/i8vlIjMzk82bN2seAR9++CHPPfccr776KsuWLUu5OaSw+BXduNDcqVOneP/99xPbhmFgterg9FaaS7f3X//1Xxw5ciSxrXkE3d3dPPvss7z88ss89dRTKTmHFBa/ohsXmhseHmb37t2Mj48zMjLCO++8w1e/+tWFblbKWb16NefPn+fChQvE43EOHz6suXQTwzD427/9W375y18SjUZ5++237+t5dOnSJb7xjW8QCATw+XxAas6h+zvOb6IbF5p74oknOH36NH/8x3/M5OQkZWVlfPGLX1zoZqUcu93Orl272LZtG+Pj43i9XoqKiha6WSljxYoVbNmyhU2bNhGLxVi3bh0lJSUL3awF89ZbbzE+Ps6uXbsSZc8880zKzSHdSFBERExpGUpEREwpLERExJTCQkRETCksRETElMJCRERMKSxERMSUwkJEREwpLERExNT/AZgclzjJqjTEAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Generate Poisson-distributed data\n", + "samples = np.random.poisson(6, size=10**6)\n", + "\n", + "# Plot histogram\n", + "plt.hist(samples, bins=21);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Question:** Does this look like anything to you?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In fact, the Poisson distribution is the limit of the Binomial distribution for low probability of success and large number of trials, that is, for rare events. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To see this, think about the stories. Picture this: you're doing a Bernoulli trial once a minute for an hour, each with a success probability of 0.05. We would do 60 trials, and the number of successes is Binomially distributed, and we would expect to get about 3 successes. This is just like the Poisson story of seeing 3 buses on average arrive in a given interval of time. Thus the Poisson distribution with arrival rate equal to np approximates a Binomial distribution for n Bernoulli trials with probability p of success (with n large and p small). This is useful because the Poisson distribution can be simpler to work with as it has only one parameter instead of two for the Binomial distribution." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Hands-on" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Plot the ECDF of the Poisson-distributed data that you generated above." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Generate x- and y-data for the ECDF\n", + "x_p, y_p = ecdf(samples)\n", + "\n", + "# Plot the ECDF\n", + "plt.plot(x_p, y_p, marker='.', linestyle='none');" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example Poisson distribution: field goals attempted per game" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This section is explicitly taken from the great work of Justin Bois. You can find more [here](https://github.com/justinbois/dataframed-plot-examples/blob/master/lebron_field_goals.ipynb)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's first remind ourselves of the story behind the Poisson distribution.\n", + "> The number of arrivals of a Poisson processes in a given set time interval is Poisson distributed.\n", + "\n", + "To quote Justin Bois:\n", + "\n", + "> We could model field goal attempts in a basketball game using a Poisson distribution. When a player takes a shot is a largely stochastic process, being influenced by the myriad ebbs and flows of a basketball game. Some players shoot more than others, though, so there is a well-defined rate of shooting. Let's consider LeBron James's field goal attempts for the 2017-2018 NBA season." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First thing's first, the data ([from here](https://www.basketball-reference.com/players/j/jamesle01/gamelog/2018)):" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "fga = [19, 16, 15, 20, 20, 11, 15, 22, 34, 17, 20, 24, 14, 14, \n", + " 24, 26, 14, 17, 20, 23, 16, 11, 22, 15, 18, 22, 23, 13, \n", + " 18, 15, 23, 22, 23, 18, 17, 22, 17, 15, 23, 8, 16, 25, \n", + " 18, 16, 17, 23, 17, 15, 20, 21, 10, 17, 22, 20, 20, 23, \n", + " 17, 18, 16, 25, 25, 24, 19, 17, 25, 20, 20, 14, 25, 26, \n", + " 29, 19, 16, 19, 18, 26, 24, 21, 14, 20, 29, 16, 9]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To show that this LeBron's attempts are ~ Poisson distributed, you're now going to plot the ECDF and compare it with the the ECDF of the Poisson distribution that has the mean of the data (technically, this is the maximum likelihood estimate)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## HANDS ON" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Generate the x and y values for the ECDF of LeBron's field attempt goals." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "# Generate x & y data for ECDF\n", + "x_ecdf, y_ecdf = ecdf(fga)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we'll draw samples out of a Poisson distribution to get the theoretical ECDF (that is, simulating the model), plot it with the ECDF of the data and see how they look." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'ECDF')" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Number of times we simulate the model\n", + "n_reps = 1000\n", + "\n", + "# Plot ECDF of data\n", + "plt.plot(x_ecdf, y_ecdf, '.', color='black');\n", + "\n", + "# Plot ECDF of model\n", + "for _ in range(n_reps):\n", + " samples = np.random.poisson(np.mean(fga), size=len(fga))\n", + " x_theor, y_theor = ecdf(samples)\n", + " plt.plot(x_theor, y_theor, '.', alpha=0.01, color='lightgray');\n", + "\n", + "\n", + "# Label your axes\n", + "plt.xlabel('field goal attempts')\n", + "plt.ylabel('ECDF')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can see from the ECDF that LeBron's field goal attempts per game are ~ Poisson distributed." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Exponential distribution" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We've encountered a variety of named _discrete distributions_. There are also named _continuous distributions_, such as the exponential distribution and the normal (or Gaussian) distribution. To see what the story of the exponential distribution is, let's return to Poissonville, in which the number of buses that will arrive per hour are Poisson distributed.\n", + "However, the waiting time between arrivals of a Poisson process are exponentially distributed.\n", + "\n", + "So: the exponential distribution has the following story: the waiting time between arrivals of a Poisson process are exponentially distributed. It has a single parameter, the mean waiting time. This distribution is not peaked, as we can see from its PDF.\n", + "\n", + "For an illustrative example, lets check out the time between all incidents involving nuclear power since 1974. It's a reasonable first approximation to expect incidents to be well-modeled by a Poisson process, which means the timing of one incident is independent of all others. If this is the case, the time between incidents should be exponentially distributed.\n", + "\n", + "\n", + "To see if this story is credible, we can plot the ECDF of the data with the CDF that we'd get from an exponential distribution with the sole parameter, the mean, given by the mean inter-incident time of the data.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "# Load nuclear power accidents data & create array of inter-incident times\n", + "df = pd.read_csv('../../data/nuclear_power_accidents.csv')\n", + "df.Date = pd.to_datetime(df.Date)\n", + "df = df[df.Date >= pd.to_datetime('1974-01-01')]\n", + "inter_times = np.diff(np.sort(df.Date)).astype(float) / 1e9 / 3600 / 24" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "# Compute mean and sample from exponential\n", + "mean = np.mean(inter_times)\n", + "samples = np.random.exponential(mean, size=10**6)\n", + "\n", + "# Compute ECDFs for sample & model\n", + "x, y = ecdf(inter_times)\n", + "x_theor, y_theor = ecdf(samples)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot sample & model ECDFs\n", + "plt.plot(x_theor, y_theor);\n", + "plt.plot(x, y, marker='.', linestyle='none');" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We see that the data is close to being Exponentially distributed, which means that we can model the nuclear incidents as a Poisson process." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Normal distribution" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The normal distribution, also known as the Gaussian or Bell Curve, appears everywhere. There are many reasons for this. One is the following:\n", + "\n", + "> When doing repeated measurements, we expect them to be normally distributed, owing to the many subprocesses that contribute to a measurement. This is because (a formulation of the Central Limit Theorem) **any quantity that emerges as the sum of a large number of subprocesses tends to be Normally distributed** provided none of the subprocesses is very broadly distributed.\n", + "\n", + "Now it's time to see if this holds for the measurements of the speed of light in the famous Michelson–Morley experiment:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Below, I'll plot the histogram with a Gaussian curve fitted to it. Even if that looks good, though, that could be due to binning bias. SO then you'll plot the ECDF of the data and the CDF of the model!" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'PDF')" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Load data, plot histogram \n", + "import scipy.stats as st\n", + "df = pd.read_csv('../../data/michelson_speed_of_light.csv')\n", + "df = df.rename(columns={'velocity of light in air (km/s)': 'c'})\n", + "c = df.c.values\n", + "x_s = np.linspace(299.6, 300.1, 400) * 1000\n", + "plt.plot(x_s, st.norm.pdf(x_s, c.mean(), c.std(ddof=1)))\n", + "plt.hist(c, bins=9, density=True)\n", + "plt.xlabel('speed of light (km/s)')\n", + "plt.ylabel('PDF')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## HANDS ON" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Get speed of light measurement + mean & standard deviation\n", + "michelson_speed_of_light = df.c.values\n", + "mean = np.mean(michelson_speed_of_light)\n", + "std = np.std(michelson_speed_of_light, ddof=1)\n", + "\n", + "# Generate normal samples w/ mean, std of data\n", + "samples = np.random.normal(mean, std, size=10000)\n", + "\n", + "# Generate data ECDF & model CDF\n", + "x, y = ecdf(michelson_speed_of_light)\n", + "x_theor, y_theor = ecdf(samples)\n", + "\n", + "# Plot data & model (E)CDFs\n", + "_ = plt.plot(x_theor, y_theor)\n", + "_ = plt.plot(x, y, marker='.', linestyle='none')\n", + "_ = plt.xlabel('speed of light (km/s)')\n", + "_ = plt.ylabel('CDF')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Some of you may ask but is the data really normal? I urge you to check out Allen Downey's post [_Are your data normal? Hint: no._ ](http://allendowney.blogspot.com/2013/08/are-my-data-normal.html)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4. Joint Probability & Conditional Probability" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Joint Probability" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We have already encountered joint probabilities above, perhaps without knowing it: $P(A,B)$ is the probability two events $A$ and $B$ _both_ occurring.\n", + "* For example, getting two heads in a row.\n", + "\n", + "If $A$ and $B$ are independent, then $P(A,B)=P(A)P(B)$ but be warned: this is not always (or often) the case.\n", + "\n", + "One way to think of this is considering \"AND\" as multiplication: the probability of A **and** B is the probability of A **multiplied** by the probability of B." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### HANDS-ON: JOINT PROBABILITY COIN FLIPPING" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Verify that $P(A,B)=P(A)P(B)$ in the two fair coin-flip case (A=heads, B=heads) by \n", + "- first simulating two coins being flipped together and calculating the proportion of occurences with two heads;\n", + "- then simulating one coin flip and calculating the proportion of heads and then doing that again and multiplying the two proportions.\n", + "\n", + "Your two calculations should give \"pretty close\" results and not the same results due to the (in)accuracy of simulation. " + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.2506\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Solution: Calculate P(A,B)\n", + "x_0 = np.random.binomial(2, 0.5, 10000)\n", + "p_ab = sum(x_0==2)/len(x_0)\n", + "plt.hist(x_0);\n", + "print(p_ab)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.25254837999999996" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Solution: Calculate P(A)P(B)\n", + "x_1 = np.random.binomial(1, 0.5, 10000)\n", + "x_2 = np.random.binomial(1, 0.5, 10000)\n", + "p_a = sum(x_1 == 1)/len(x_1)\n", + "p_b = sum(x_2 == 1)/len(x_2)\n", + "p_a*p_b" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Note:** In order to use such simulation and _hacker statistics_ approaches to \"prove\" results such as the above, we're gliding over several coupled and deep technicalities. This is in the interests of the pedagogical nature of this introduction. For the sake of completeness, we'll mention that we're essentially\n", + "- Using the proportion in our simulations as a proxy for the probability (which, although Frequentist, is useful to allow you to start getting your hands dirty with probability via simluation).\n", + "\n", + "Having stated this, for ease of instruction, we'll continue to do so when thinking about joint & conditional probabilities of both simulated and real data. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### HANDS-ON: joint probability for birds" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "What is the probability that two randomly selected birds have beak depths over 10 ?" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.724891534007516" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Calculate P(A)P(B) of two birds having beak lengths > 10\n", + "p_a = (sum(lengths > 10))/len(lengths)\n", + "p_b = (sum(lengths > 10))/len(lengths)\n", + "p_a*p_b" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "* Calculate the joint probability using the resampling method, that is, by drawing random samples (with replacement) from the data. First calculate $P(A)P(B)$:" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.7246427954999999" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Calculate P(A)P(B) using resampling methods\n", + "n_samples = 100000\n", + "p_a = sum(np.random.choice(lengths, n_samples, replace=True) > 10)/n_samples\n", + "p_b = sum(np.random.choice(lengths, n_samples, replace=True) > 10)/n_samples\n", + "p_a*p_b" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now calculate $P(A,B)$:" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.72671" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Calculate P(A,B) using resampling methods\n", + "n_samples = 100000\n", + "samples = np.random.choice(lengths, (n_samples,2), replace=True)\n", + "_ = samples > (10, 10)\n", + "p_ab = sum(np.prod(_, axis=1))/n_samples\n", + "p_ab" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Task:** Interpret the results of your simulations." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Conditional Probability" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now that we have a grasp on joint probabilities, lets consider conditional probabilities, that is, the probability of some $A$, knowing that some other $B$ is true. We use the notation $P(A|B)$ to denote this. For example, you can ask the question \"What is the probability of a finch beak having depth $<10$, knowing that the finch is of species 'fortis'?\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Example: conditional probability for birds" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "1. What is the probability of a finch beak having depth > 10 ?\n", + "2. What if we know the finch is of species 'fortis'?\n", + "3. What if we know the finch is of species 'scandens'?" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.8514056224899599" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sum(df_12.blength > 10)/len(df_12)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.6942148760330579" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df_fortis = df_12.loc[df_12['species'] == 'fortis']\n", + "sum(df_fortis.blength > 10)/len(df_fortis)" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1.0" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df_scandens = df_12.loc[df_12['species'] == 'scandens']\n", + "sum(df_scandens.blength > 10)/len(df_scandens)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Note:** These proportions are definitely different. We can't say much more currently but we'll soon see how to use hypothesis testing to see what else we can say about the differences between the species of finches." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Joint and conditional probabilities\n", + "\n", + "Conditional and joint probabilites are related by the following:\n", + "$$ P(A,B) = P(A|B)P(B)$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Homework exercise for the avid learner:** verify the above relationship using simulation/resampling techniques in one of the cases above." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Hands on example: drug testing" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Question:** Suppose that a test for using a particular drug has 99% sensitivity (true positive rate) and 99% specificity (true negative rate), that is, a 1% false positive rate and 1% false negative rate. Suppose that 0.5% (5 in 1,000) of people are users of the drug. What is the probability that a randomly selected individual with a positive test is a drug user?\n", + "\n", + "**If we can answer this, it will be really cool as it shows how we can move from knowing $P(+|user)$ to $P(user|+)$, a MVP for being able to move from $P(data|model)$ to $P(model|data)$.**" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In the spirit of this workshop, it's now time to harness your computational power and the intuition of simulation to solve this drug testing example. \n", + "\n", + "* Before doing so, what do you think the answer to the question _\"What is the probability that a randomly selected individual with a positive test is a drug user?\"_ is? Write down your guess." + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [], + "source": [ + "# Take 10,000 subjects\n", + "n = 100000\n", + "# Sample for number of users, non-users\n", + "users = np.random.binomial(n, 0.005, 1) \n", + "non_users = n - users" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [], + "source": [ + "# How many of these users tested +ve ?\n", + "u_pos = np.random.binomial(users, 0.99)\n", + "# How many of these non-users tested +ve ?\n", + "non_pos = np.random.binomial(non_users, 0.01)" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0.3442953])" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# how many of those +ve tests were for users?\n", + "u_pos/(u_pos+non_pos)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Discussion**: What you have been able to do here is to solve the following problem: you knew $P(+|user)=0.99$, but you were trying to figure out $P(user|+)$. Is the answer what you expected? If not, why not? \n", + "\n", + "If you were surprised at the answer, that's not too surprising: you've experienced the [base rate fallacy](https://en.wikipedia.org/wiki/Base_rate_fallacy). The base rate of 99% true positive may lead one to think that most positive tests will be of users, however the vast majority of the overall population are non-users, which means that there will be more that test positive incorrectly than one would otherwise expect.\n", + "\n", + "**Key note:** This is related to the serious scientific challenge posed at the beginning here: if you know the underlying parameters/model, you can figure out the distribution and the result, but often we have only the experimental result and we're trying to figure out the most appropriate model and parameters.\n", + "\n", + "It is Bayes' Theorem that lets us move between these." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5. Bayes' Theorem\n", + "\n", + "$$P(B|A) = \\frac{P(A|B)P(B)}{P(A)}$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As you may have guessed, it is Bayes' Theorem that will allow us to move back and forth between $P(data|model)$ and $P(model|data)$. As we have seen, $P(model|data)$ is usually what we're interested in as data scientists yet $P(data|model)$ is what we can easily compute, either by simulating our model or using analytic equations." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**One of the coolest things:** Bayes Theorem can be proved with a few lines of mathematics. Your instructor will do this on the chalk/white-board now." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Bayes Theorem solves the above drug testing problem\n", + "\n", + "Bayes Theorem can be used to analytically derive the solution to the 'drug testing' example above as follows." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "From Bayes Theorem, \n", + "\n", + "$$P(user|+) = \\frac{P(+|user)P(user)}{P(+)}$$\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can expand the denominator here into \n", + "\n", + "$$P(+) = P(+,user) + P(+,non-user) $$\n", + "\n", + "so that\n", + "\n", + "$$ P(+)=P(+|user)P(user) + P(+|non-user)P(non-user)$$\n", + "\n", + "and \n", + "\n", + "$$P(user|+) = \\frac{P(+|user)P(user)}{P(+|user)P(user) + P(+|non-user)P(non-user)}$$." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Calculating this explicitly yields\n", + "\n", + "$$P(user|+) = \\frac{0.99\\times 0.005}{0.99\\times 0.005 + 0.01\\times 0.995} = 0.332 $$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This means that if an individual tests positive, there is still only a 33.2% chance that they are a user! This is because the number of non-users is so high compared to the number of users." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Coming up: from Bayes Theorem to Bayesian Inference!" + ] + } + ], + "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.6" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docs/hacker-stats-intro/02-Instructor-Parameter_estimation_hypothesis_testing.ipynb b/docs/hacker-stats-intro/02-Instructor-Parameter_estimation_hypothesis_testing.ipynb new file mode 100644 index 0000000..a0a4dda --- /dev/null +++ b/docs/hacker-stats-intro/02-Instructor-Parameter_estimation_hypothesis_testing.ipynb @@ -0,0 +1,785 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Parameter estimation and hypothesis testing" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "#Import packages\n", + "import numpy as np\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "import pymc3 as pm\n", + "from ipywidgets import interact\n", + "import arviz as az\n", + "%matplotlib inline\n", + "sns.set()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Learning Objectives of Part 2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "1. Understand what priors, likelihoods and posteriors are;\n", + "2. Use random sampling for parameter estimation to appreciate the relationship between sample size & the posterior distribution, along with the effect of the prior;\n", + "3. Use probabilistic programming for parameter estimation;\n", + "4. Use probabilistic programming for hypothesis testing." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. From Bayes Theorem to Bayesian Inference" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's say that we flip a biased coin several times and we want to estimate the probability of heads from the number of heads we saw. Statistical intuition tells us that our best estimate of $p(heads)=$ number of heads divided by total number of flips.\n", + "\n", + "However, \n", + "\n", + "1. It doesn't tell us how certain we can be of that estimate and\n", + "2. This type of intuition doesn't extend to even slightly more complex examples.\n", + "\n", + "Bayesian inference helps us here. We can calculate the probability of a particular $p=p(H)$ given data $D$ by setting $A$ in Bayes Theorem equal to $p$ and $B$ equal to $D$." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "$$P(p|D) = \\frac{P(D|p)P(p)}{P(D)} $$\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this equation, we call $P(p)$ the prior (distribution), $P(D|p)$ the likelihood and $P(p|D)$ the posterior (distribution). The intuition behind the nomenclature is as follows: the prior is the distribution containing our knowledge about $p$ prior to the introduction of the data $D$ & the posterior is the distribution containing our knowledge about $p$ after considering the data $D$." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Note** that we're _overloading_ the term _probability_ here. In fact, we have 3 distinct usages of the word:\n", + "- The probability $p$ of seeing a head when flipping a coin;\n", + "- The resulting binomial probability distribution $P(D|p)$ of seeing the data $D$, given $p$;\n", + "- The prior & posterior probability distributions of $p$, encoding our _uncertainty_ about the value of $p$." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Key concept:** We only need to know the posterior distribution $P(p|D)$ up to multiplication by a constant at the moment: this is because we really only care about the values of $P(p|D)$ relative to each other – for example, what is the most likely value of $p$? To answer such questions, we only need to know what $P(p|D)$ is proportional to, as a function of $p$. Thus we don’t currently need to worry about the term $P(D)$. In fact,\n", + "\n", + "$$P(p|D) \\propto P(D|p)P(p) $$\n", + "\n", + "**Note:** What is the prior? Really, what do we know about $p$ before we see any data? Well, as it is a probability, we know that $0\\leq p \\leq1$. If we haven’t flipped any coins yet, we don’t know much else: so it seems logical that all values of $p$ within this interval are equally likely, i.e., $P(p)=1$, for $0\\leq p \\leq1$. This is known as an uninformative prior because it contains little information (there are other uninformative priors we may use in this situation, such as the Jeffreys prior, to be discussed later). People who like to hate on Bayesian inference tend to claim that the need to choose a prior makes Bayesian methods somewhat arbitrary, but as we’ll now see, if you have enough data, the likelihood dominates over the prior and the latter doesn’t matter so much." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "**Essential remark:** we get the whole distribution of $P(p|D)$, not merely a point estimate plus errors bars, such as [95% confidence intervals](http://andrewgelman.com/2018/07/04/4th-july-lets-declare-independence-95/).\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. Bayesian parameter estimation I: flip those coins" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's generate some coin flips and try to estimate $p(H)$. Two notes:\n", + "- given data $D$ consisting of $n$ coin tosses & $k$ heads, the likelihood function is given by $L:=P(D|p) \\propto p^k(1-p)^{n-k}$;\n", + "- given a uniform prior, the posterior is proportional to the likelihood." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def plot_posterior(p=0.6, N=0):\n", + " \"\"\"Plot the posterior given a uniform prior; Bernoulli trials\n", + " with probability p; sample size N\"\"\"\n", + " np.random.seed(42)\n", + " # Flip coins \n", + " n_successes = np.random.binomial(N, p)\n", + " # X-axis for PDF\n", + " x = np.linspace(0, 1, 100)\n", + " # Prior\n", + " prior = 1\n", + " # Compute posterior, given the likelihood (analytic form)\n", + " posterior = x**n_successes*(1-x)**(N-n_successes)*prior\n", + " posterior /= np.max(posterior) # so that peak always at 1\n", + " plt.plot(x, posterior)\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_posterior(N=10)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "* Now use the great ipywidget interact to check out the posterior as you generate more and more data (you can also vary $p$):" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a2b8fe422627493b8e50a595a5a0c825", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "interactive(children=(FloatSlider(value=0.6, description='p', max=1.0, step=0.01), IntSlider(value=0, descript…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "interact(plot_posterior, p=(0, 1, 0.01), N=(0, 1500));" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Notes for discussion:**\n", + "\n", + "* as you generate more and more data, your posterior gets narrower, i.e. you get more and more certain of your estimate.\n", + "* you need more data to be certain of your estimate when $p=0.5$, as opposed to when $p=0$ or $p=1$. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### The choice of the prior" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You may have noticed that we needed to choose a prior and that, in the small to medium data limit, this choice can affect the posterior. We'll briefly introduce several types of priors and then you'll use one of them for the example above to see the effect of the prior:\n", + "\n", + "- **Informative priors** express specific, definite information about a variable, for example, if we got a coin from the mint, we may use an informative prior with a peak at $p=0.5$ and small variance. \n", + "- **Weakly informative priors** express partial information about a variable, such as a peak at $p=0.5$ (if we have no reason to believe the coin is biased), with a larger variance.\n", + "- **Uninformative priors** express no information about a variable, except what we know for sure, such as knowing that $0\\leq p \\leq1$.\n", + "\n", + "Now you may think that the _uniform distribution_ is uninformative, however, what if I am thinking about this question in terms of the probability $p$ and Eric Ma is thinking about it in terms of the _odds ratio_ $r=\\frac{p}{1-p}$? Eric rightly feels that he has no prior knowledge as to what this $r$ is and thus chooses the uniform prior on $r$.\n", + "\n", + "With a bit of algebra (transformation of variables), we can show that choosing the uniform prior on $p$ amounts to choosing a decidedly non-uniform prior on $r$ and vice versa. So Eric and I have actually chosen different priors, using the same philosophy. How do we avoid this happening? Enter the **Jeffreys prior**, which is an uninformative prior that solves this problem. You can read more about the Jeffreys prior [here](https://en.wikipedia.org/wiki/Jeffreys_prior) & in your favourite Bayesian text book (Sivia gives a nice treatment). \n", + "\n", + "In the binomial (coin flip) case, the Jeffreys prior is given by $P(p) = \\frac{1}{\\sqrt{p(1-p)}}$.\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Hands-on" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "* Create an interactive plot like the one above, except that it has two posteriors on it: one for the uniform prior, another for the Jeffries prior." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# Solution\n", + "def plot_posteriors(p=0.6, N=0):\n", + " np.random.seed(42)\n", + " n_successes = np.random.binomial(N, p)\n", + " x = np.linspace(0.01, 0.99, 100)\n", + " posterior1 = x**n_successes*(1-x)**(N-n_successes) # w/ uniform prior\n", + " posterior1 /= np.max(posterior1) # so that peak always at 1\n", + " plt.plot(x, posterior1, label='Uniform prior')\n", + " jp = np.sqrt(x*(1-x))**(-1) # Jeffreys prior\n", + " posterior2 = posterior1*jp # w/ Jeffreys prior\n", + " posterior2 /= np.max(posterior2) # so that peak always at 1 (not quite correct to do; see below)\n", + " plt.plot(x, posterior2, label='Jeffreys prior')\n", + " plt.legend()\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ad9040b7630c4b36ab6392914eddf494", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "interactive(children=(FloatSlider(value=0.6, description='p', max=1.0, step=0.01), IntSlider(value=0, descript…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "interact(plot_posteriors, p=(0, 1, 0.01), N=(0, 100));" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Question:** What happens to the posteriors as you generate more and more data?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3. Bayesian parameter estimation using PyMC3" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Well done! You've learnt the basics of Bayesian model building. The steps are\n", + "1. To completely specify the model in terms of _probability distributions_. This includes specifying \n", + " - what the form of the sampling distribution of the data is _and_ \n", + " - what form describes our _uncertainty_ in the unknown parameters (This formulation is adapted from [Fonnesbeck's workshop](https://github.com/fonnesbeck/intro_stat_modeling_2017/blob/master/notebooks/2.%20Basic%20Bayesian%20Inference.ipynb) as Chris said it so well there).\n", + "2. Calculate the _posterior distribution_.\n", + "\n", + "In the above, the form of the sampling distribution of the data was Binomial (described by the likelihood) and the uncertainty around the unknown parameter $p$ captured by the prior." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now it is time to do the same using the **probabilistic programming language** PyMC3. There's _loads of cool stuff_ about PyMC3 and this paradigm, two of which are\n", + "- _probabililty distributions_ are first class citizens, in that we can assign them to variables and use them intuitively to mirror how we think about priors, likelihoods & posteriors.\n", + "- PyMC3 calculates the posterior for us!\n", + "\n", + "Under the hood, PyMC3 will compute the posterior using a sampling based approach called Markov Chain Monte Carlo (MCMC) or Variational Inference. Check the [PyMC3 docs](https://docs.pymc.io/) for more on these. \n", + "\n", + "But now, it's time to bust out some MCMC and get sampling!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Parameter estimation I: click-through rate" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A common experiment in tech data science is to test a product change and see how it affects a metric that you're interested in. Say that I don't think enough people are clicking a button on my website & I hypothesize that it's because the button is a similar color to the background of the page. Then I can set up two pages and send some people to each: the first the original page, the second a page that is identical, except that it has a button that is of higher contrast and see if more people click through. This is commonly referred to as an A/B test and the metric of interest is click-through rate (CTR), what proportion of people click through. Before even looking at two rates, let's use PyMC3 to estimate one.\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First generate click-through data, given a CTR $p_a=0.15$." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# click-through rates\n", + "p_a = 0.15\n", + "N = 150\n", + "n_successes_a = np.sum(np.random.binomial(N, p_a))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now it's time to build your probability model. Noticing that our model of having a constant CTR resulting in click or not is a biased coin flip,\n", + "- the sampling distribution is binomial and we need to encode this in the likelihood;\n", + "- there is a single parameter $p$ that we need to describe the uncertainty around, using a prior and we'll use a uniform prior for this.\n", + "\n", + "These are the ingredients for the model so let's now build it:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# Build model of p_a\n", + "with pm.Model() as Model:\n", + " # Prior on p\n", + " prob = pm.Uniform('p')\n", + " # Binomial Likelihood\n", + " y = pm.Binomial('y', n=N, p=prob, observed=n_successes_a)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Discussion:** \n", + "- What do you think of the API for PyMC3. Does it reflect how we think about model building?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It's now time to sample from the posterior using PyMC3. You'll also plot the posterior:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Auto-assigning NUTS sampler...\n", + "Initializing NUTS using jitter+adapt_diag...\n", + "Multiprocess sampling (4 chains in 4 jobs)\n", + "NUTS: [p]\n", + "Sampling 4 chains: 100%|██████████| 10000/10000 [00:01<00:00, 5931.68draws/s]\n", + "The acceptance probability does not match the target. It is 0.8922666867337682, but should be close to 0.8. Try to increase the number of tuning steps.\n", + "The acceptance probability does not match the target. It is 0.8878163923648399, but should be close to 0.8. Try to increase the number of tuning steps.\n" + ] + } + ], + "source": [ + "with Model:\n", + " samples = pm.sample(2000)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "az.plot_posterior(samples, kind='hist');" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**For discussion:** Interpret the posterior ditribution. What would your tell the non-technical manager of your growth team about the CTR?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Hands-on: Parameter estimation II -- the mean of a population" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this exercise, you'll calculate the posterior mean beak depth of Galapagos finches in a given species. First you'll load the data and subset wrt species:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "# Import and view head of data\n", + "df_12 = pd.read_csv('../../data/finch_beaks_2012.csv')\n", + "df_fortis = df_12.loc[df_12['species'] == 'fortis']\n", + "df_scandens = df_12.loc[df_12['species'] == 'scandens']" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To specify the full probability model, you need\n", + "- a likelihood function for the data &\n", + "- priors for all unknowns.\n", + "\n", + "What is the likelihood here? Let's plot the measurements below and see that they look approximately Gaussian/normal so you'll use a normal likelihood $y_i\\sim \\mathcal{N}(\\mu, \\sigma^2)$. The unknowns here are the mean $\\mu$ and standard deviation $\\sigma$ and we'll use weakly informative priors on both\n", + "- a normal prior for $\\mu$ with mean $10$ and standard deviation $5$;\n", + "- a uniform prior for $\\sigma$ bounded between $0$ and $10$.\n", + "\n", + "We can discuss biological reasons for these priors also but you can also test that the posteriors are relatively robust to the choice of prior here due to the amount of data." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.distplot(df_fortis['blength']);" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "with pm.Model() as model:\n", + " # Prior for mean & standard deviation\n", + " μ_1 = pm.Normal('μ_1', mu=10, sd=5)\n", + " σ_1 = pm.Lognormal('σ_1', 0, 10)\n", + " # Gaussian Likelihood\n", + " y_1 = pm.Normal('y_1', mu=μ_1, sd=σ_1, observed=df_fortis['blength'])" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Auto-assigning NUTS sampler...\n", + "Initializing NUTS using jitter+adapt_diag...\n", + "Multiprocess sampling (4 chains in 4 jobs)\n", + "NUTS: [σ_1, μ_1]\n", + "Sampling 4 chains: 100%|██████████| 10000/10000 [00:01<00:00, 5037.14draws/s]\n" + ] + } + ], + "source": [ + "# bust it out & sample\n", + "with model:\n", + " samples = pm.sample(2000)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + " az.plot_posterior(samples);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4. Bayesian Hypothesis testing" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Bayesian Hypothesis testing I: A/B tests on click through rates" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Assume we have a website and want to redesign the layout (*A*) and test whether the new layout (*B*) results in a higher click through rate. When people come to our website we randomly show them layout *A* or *B* and see how many people click through for each. First let's generate the data we need:" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "# click-through rates\n", + "p_a = 0.15\n", + "p_b = 0.20\n", + "N = 1000\n", + "n_successes_a = np.sum(np.random.uniform(size=N) <= p_a)\n", + "n_successes_b = np.sum(np.random.uniform(size=N) <= p_b)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Once again, we need to specify our models for $p_a$ and $p_b$. Each will be the same as the CTR example above\n", + "- Binomial likelihoods\n", + "- uniform priors on $p_a$ and $_p$.\n", + "\n", + "We also want to calculate the posterior of the difference $p_a-p_b$ and we do so using `pm.Deterministic()`, which specifies a deterministic random variable, i.e., one that is completely determined by the values it references, in the case $p_a$ & $p_b$.\n", + "\n", + "We'll now build the model:" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "with pm.Model() as Model:\n", + " # Prior on p\n", + " prob_a = pm.Uniform('p_a')\n", + " prob_b = pm.Uniform('p_b')\n", + " # Binomial Likelihood\n", + " y_a = pm.Binomial('y_a', n=N, p=prob_a, observed=n_successes_a)\n", + " y_b = pm.Binomial('y_b', n=N, p=prob_b, observed=n_successes_b)\n", + " diff_clicks = pm.Deterministic('diff_clicks', prob_a-prob_b)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Sample from the posterior and plot them:" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Auto-assigning NUTS sampler...\n", + "Initializing NUTS using jitter+adapt_diag...\n", + "Multiprocess sampling (4 chains in 4 jobs)\n", + "NUTS: [p_b, p_a]\n", + "Sampling 4 chains: 100%|██████████| 10000/10000 [00:01<00:00, 5136.65draws/s]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "with Model:\n", + " samples = pm.sample(2000)\n", + "az.plot_posterior(samples, kind='hist');" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Hands-on: Bayesian Hypothesis testing II -- beak lengths difference between species" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Task**: Determine whether the mean beak length of the Galapogas finches differs between species. For the mean of each species, use the same model as in previous hand-on section:\n", + "\n", + "- Gaussian likelihood;\n", + "- Normal prior for the means;\n", + "- Uniform prior for the variances.\n", + "\n", + "Also calculate the difference between the means and, for bonus points, the _effect size_, which is the difference between the means divided by the pooled standard deviations = $\\sqrt{(\\sigma_1^2+\\sigma_2^2)/2}$. Hugo will talk through the importance of the _effect size_.\n", + "\n", + "Don't forget to sample from the posteriors and plot them!" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "with pm.Model() as model:\n", + " # Priors for means and variances\n", + " μ_1 = pm.Normal('μ_1', mu=10, sd=5)\n", + " σ_1 = pm.Uniform('σ_1', 0, 10)\n", + " μ_2 = pm.Normal('μ_2', mu=10, sd=5)\n", + " σ_2 = pm.Uniform('σ_2', 0, 10)\n", + " # Gaussian Likelihoods\n", + " y_1 = pm.Normal('y_1', mu=μ_1, sd=σ_1, observed=df_fortis['blength'])\n", + " y_2 = pm.Normal('y_2', mu=μ_2, sd=σ_2, observed=df_scandens['blength'])\n", + " # Calculate the effect size and its uncertainty.\n", + " diff_means = pm.Deterministic('diff_means', μ_1 - μ_2)\n", + " pooled_sd = pm.Deterministic('pooled_sd', \n", + " np.sqrt(np.power(σ_1, 2) + \n", + " np.power(σ_2, 2)) / 2)\n", + " effect_size = pm.Deterministic('effect_size', \n", + " diff_means / pooled_sd)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Auto-assigning NUTS sampler...\n", + "Initializing NUTS using jitter+adapt_diag...\n", + "Multiprocess sampling (4 chains in 4 jobs)\n", + "NUTS: [σ_2, μ_2, σ_1, μ_1]\n", + "Sampling 4 chains: 100%|██████████| 10000/10000 [00:02<00:00, 3451.84draws/s]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# bust it out & sample\n", + "with model:\n", + " samples = pm.sample(2000)\n", + "az.plot_posterior(samples, var_names=['μ_1', 'μ_2', 'diff_means', 'effect_size'], kind='hist');" + ] + } + ], + "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.6" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docs/hacker-stats-intro/data.py b/docs/hacker-stats-intro/data.py new file mode 100644 index 0000000..e19c03c --- /dev/null +++ b/docs/hacker-stats-intro/data.py @@ -0,0 +1,74 @@ +import pandas as pd +from sklearn.preprocessing import LabelEncoder +import janitor as jn +import numpy as np + + +def load_finches_2012(): + path = '../data/finch_beaks_2012.csv' + return load_finches(path) + + +def load_finches_1975(): + path = '../data/finch_beaks_1975.csv' + df = load_finches(path) + df = df.rename_column('beak_length_mm', 'beak_length').rename_column('beak_depth_mm', 'beak_depth') + return df + + +def load_finches(path): + # Load the data + df = ( + pd.read_csv(path) + .clean_names() # clean column names + .rename_column('blength', 'beak_length') # rename blength to beak_length (readability fix) + .rename_column('bdepth', 'beak_depth') # rename bdepth to beak_depth (readability fix) + .label_encode('species') # create a `species_enc` column that has the species encoded numerically + ) + return df + + +def load_baseball(): + df = pd.read_csv('../data/baseballdb/core/Batting.csv') + df['AB'] = df['AB'].replace(0, np.nan) + df = df.dropna() + df['batting_avg'] = df['H'] / df['AB'] + df = df[df['yearID'] >= 2016] + df = df.iloc[0:15] + df.head(5) + return df + + +def load_sterilization(): + df = ( + pd.read_csv('../data/sterilization.csv', na_filter=True, na_values=['#DIV/0!']) + .clean_names() + .label_encode('treatment') + ) + mapping = dict(zip(df['treatment'], df['treatment_enc'])) + return df, mapping + + +def load_kruschke(): + df = ( + pd.read_csv('../data/iq.csv', index_col=0) # comment out the path to the file for students. + .label_encode('treatment') + ) + return df + + +# Constants for load_decay +tau = 71.9 # indium decay half life +A = 42 # starting magnitude +C = 21 # measurement error +noise_scale = 1 + + +def load_decay(): + t = np.arange(0, 1000) + def decay_func(ts, noise): + return A * np.exp(-t/tau) + C + np.random.normal(0, noise, size=(len(t))) + + data = {'t': t, 'activity': decay_func(t, noise_scale)} + df = pd.DataFrame(data) + return df \ No newline at end of file diff --git a/docs/hacker-stats-intro/matplotlibrc b/docs/hacker-stats-intro/matplotlibrc new file mode 100644 index 0000000..7ea7e7e --- /dev/null +++ b/docs/hacker-stats-intro/matplotlibrc @@ -0,0 +1,5 @@ +axes.spines.left : True # display axis spines +axes.spines.bottom : True +axes.spines.top : False +axes.spines.right : False + diff --git a/docs/hacker-stats-intro/utils.py b/docs/hacker-stats-intro/utils.py new file mode 100644 index 0000000..10072c6 --- /dev/null +++ b/docs/hacker-stats-intro/utils.py @@ -0,0 +1,19 @@ +import numpy as np + + +def ECDF(data): + x = np.sort(data) + y = np.cumsum(x) / np.sum(x) + + return x, y + + +def despine(ax): + ax.spines['right'].set_visible(False) + ax.spines['top'].set_visible(False) + + +def despine_traceplot(traceplot): + for row in traceplot: + for ax in row: + despine(ax) \ No newline at end of file