{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Bayesian Dice" ] }, { "cell_type": "markdown", "metadata": { "tags": [ "remove-cell" ] }, "source": [ "Think Bayes, Second Edition\n", "\n", "Copyright 2021 Allen B. Downey\n", "\n", "License: [Attribution-NonCommercial-ShareAlike 4.0 International (CC BY-NC-SA 4.0)](https://creativecommons.org/licenses/by-nc-sa/4.0/)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Click here to run this notebook on Colab](https://colab.research.google.com/github/AllenDowney/ThinkBayes2/blob/master/examples/bayes_dice.ipynb)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "I've been enjoying Aubrey Clayton's new book [*Bernoulli's Fallacy*](https://aubreyclayton.com/bernoulli). Chapter 1, which is about the historical development of competing definitions of probability, is worth the price of admission alone.\n", "\n", "One of the examples in the first chapter is a simplified version of a problem posed by Thomas Bayes. The original version, [which I wrote about here](https://allendowney.blogspot.com/2015/06/bayesian-billiards.html), involves a billiards (pool) table; Clayton's version uses dice:\n", "\n", "> Your friend rolls a six-sided die and secretly records the outcome; this number becomes the target *T*. You then put on a blindfold and roll the same six-sided die over and over. You're unable to see how it lands, so each time your friend [...] tells you *only* whether the number you just rolled was greater than, equal to, or less than *T*.\n", ">\n", "> Suppose in one round of the game we had this sequence of outcomes, with G representing a greater roll, L a lesser roll, and E an equal roll:\n", ">\n", "> G, G, L, E, L, L, L, E, G, L\n", "\n", "Based on this data, what is the posterior distribution of *T*?" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Computing likelihoods\n", "\n", "There are two parts of my solution; computing the likelihood of the data under each hypothesis and then using those likelihoods to compute the posterior distribution of *T*.\n", "\n", "To compute the likelihoods, I'll demonstrate one of my favorite idioms, using a meshgrid to apply an operation, like `>`, to all pairs of values from two sequences.\n", "\n", "In this case, the sequences are \n", "\n", "* `hypos`: The hypothetical values of *T*, and\n", "\n", "* `outcomes`: possible outcomes each time we roll the dice" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "hypos = [1,2,3,4,5,6]\n", "outcomes = [1,2,3,4,5,6]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "If we compute a meshgrid of `outcomes` and `hypos`, the result is two arrays." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "\n", "O, H = np.meshgrid(outcomes, hypos)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The first contains the possible outcomes repeated down the columns." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[1, 2, 3, 4, 5, 6],\n", " [1, 2, 3, 4, 5, 6],\n", " [1, 2, 3, 4, 5, 6],\n", " [1, 2, 3, 4, 5, 6],\n", " [1, 2, 3, 4, 5, 6],\n", " [1, 2, 3, 4, 5, 6]])" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "O" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The second contains the hypotheses repeated across the rows." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[1, 1, 1, 1, 1, 1],\n", " [2, 2, 2, 2, 2, 2],\n", " [3, 3, 3, 3, 3, 3],\n", " [4, 4, 4, 4, 4, 4],\n", " [5, 5, 5, 5, 5, 5],\n", " [6, 6, 6, 6, 6, 6]])" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "H" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "If we apply an operator like `>`, the result is a Boolean array." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[False, True, True, True, True, True],\n", " [False, False, True, True, True, True],\n", " [False, False, False, True, True, True],\n", " [False, False, False, False, True, True],\n", " [False, False, False, False, False, True],\n", " [False, False, False, False, False, False]])" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "O > H" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now we can use `mean` with `axis=1` to compute the fraction of `True` values in each row." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0.83333333, 0.66666667, 0.5 , 0.33333333, 0.16666667,\n", " 0. ])" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(O > H).mean(axis=1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The result is the probability that the outcome is greater than *T*, for each hypothetical value of *T*.\n", "I'll name this array `gt`:" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0.83333333, 0.66666667, 0.5 , 0.33333333, 0.16666667,\n", " 0. ])" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "gt = (O > H).mean(axis=1)\n", "gt" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The first element of the array is 5/6, which indicates that if *T* is 1, the probability of exceeding it is 5/6.\n", "The second element is 2/3, which indicates that if *T* is 2, the probability of exceeding it is 2/3.\n", "And do on.\n", "\n", "Now we can compute the corresponding arrays for less than and equal." ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0. , 0.16666667, 0.33333333, 0.5 , 0.66666667,\n", " 0.83333333])" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "lt = (O < H).mean(axis=1)\n", "lt" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0.16666667, 0.16666667, 0.16666667, 0.16666667, 0.16666667,\n", " 0.16666667])" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "eq = (O == H).mean(axis=1)\n", "eq" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In the next section, we'll use these arrays to do a Bayesian update." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## The Update\n", "\n", "In this example, computing the likelihoods was the hard part. The Bayesian update is easy.\n", "Since *T* was chosen by rolling a fair die, the prior distribution for *T* is uniform.\n", "I'll use a Pandas `Series` to represent it." ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1 0.166667\n", "2 0.166667\n", "3 0.166667\n", "4 0.166667\n", "5 0.166667\n", "6 0.166667\n", "dtype: float64" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import pandas as pd\n", "\n", "pmf = pd.Series(1/6, hypos)\n", "pmf" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now here's the sequence of data, encoded using the likelihoods we computed in the previous section." ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "data = [gt, gt, lt, eq, lt, lt, lt, eq, gt, lt]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The following loop updates the prior distribution by multiplying by each of the likelihoods." ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "for datum in data:\n", " pmf *= datum" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Finally, we normalize the posterior." ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1 0.000000\n", "2 0.016427\n", "3 0.221766\n", "4 0.498973\n", "5 0.262834\n", "6 0.000000\n", "dtype: float64" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "pmf /= pmf.sum()\n", "pmf" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Here's what it looks like." ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "pmf.plot.bar(xlabel='Target value', \n", " ylabel='PMF', \n", " title='Posterior distribution of $T$');" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "As an aside, you might have noticed that the values in `eq` are all the same.\n", "So when the value we roll is equal to $T$, we don't get any new information about *T*.\n", "We could leave the instances of `eq` out of the data, and we would get the same answer." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "celltoolbar": "Tags", "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.8.8" } }, "nbformat": 4, "nbformat_minor": 2 }