RollingDice.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "# Tables illustration of working with computational models of probability\n",
    "\n",
    "## David Culler\n",
    "\n",
    "This notebook seeks to illustrate simple datascience.Table operations as part of a basic lesson on probability.\n",
    "\n",
    "Documentation on the datascience module is at [http://data8.org/datascience/index.html](http://data8.org/datascience/index.html) and of Tables as [http://data8.org/datascience/tables.html](http://data8.org/datascience/tables.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# HIDDEN - generic nonsense for setting up environment\n",
    "from datascience import *\n",
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plots\n",
    "plots.style.use('fivethirtyeight')\n",
    "from ipywidgets import interact\n",
    "# datascience version number of last run of this notebook\n",
    "version.__version__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "## Create a table as a model of a stochastic phenomenom\n",
    "\n",
    "Here we create a single column table as a computational model of a die\n",
    "with each element of the table containing the number of dots on the side.\n",
    "This illustrates the simplest way of constructing a table, [`Table.with_column`](http://data8.org/datascience/_autosummary/datascience.tables.Table.with_column.html#datascience.tables.Table.with_column).\n",
    "\n",
    "Then we define a function that models rolling a die.  This illustrates the\n",
    "use of [`Table.sample`](http://data8.org/datascience/_autosummary/datascience.tables.Table.sample.html#datascience.tables.Table.sample)\n",
    "to take random sample of a table."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "die = Table().with_column('side', [1,2,3,4,5,6])\n",
    "die"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# Simulate the roll of a die by sampling from the die table\n",
    "def roll_die():\n",
    "    return die.sample(1)['side'][0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# roll it.  Try this over and over and see what you get\n",
    "roll_die()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "## Composition\n",
    "\n",
    "Build a computational model of rolling a die many times using our `roll_die` function as a building block.  It happens to utilize tables internally, but we have abstracted away from that.  Here it is a *black box* that yields a random roll of a die.  Again, we create a table to model the result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# Simulate rolling it many times, creating a table that records the rolls\n",
    "num_rolls = 600\n",
    "rolls = Table().with_column('roll', [roll_die() for i in range(num_rolls)])\n",
    "rolls"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "## Visualization\n",
    "\n",
    "Above we see just the tip of the table.  And, of course, it would be tedious to look at all those rolls.  Instead, we want to look at some *descriptive statistics* of the process.  We can do that with [`Table.hist`](http://data8.org/datascience/_autosummary/datascience.tables.Table.hist.html#datascience.tables.Table.hist), which\n",
    "can be used to produce a histogram or a discrete distribution (the default, i.e., `normed = True`).\n",
    "\n",
    "The histogram of the rolls shows what we mean by 'uniform at random'.  All sides are equally likely to come up on each roll.  Thus the number of times each comes up in a large number of rolls is nearly constant.  But not quite.\n",
    "The rolls table it self won't change on its own, but every time you run the cell above, you will get a slightly different picture."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "bins = np.arange(1,8)\n",
    "rolls.hist(bins=bins, normed=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# Normalize this gives a distribution.  The probability of each side appearing.  1/6.\n",
    "rolls.hist(normed=True,bins=bins)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "## Computing on distributions\n",
    "\n",
    "While visualization is useful for humans in the data exploration process, everything you see you should be able to compute upon.  The analog of `Table.hist` that yields a table, rather than a chart is [`table.bin`](http://data8.org/datascience/_autosummary/datascience.tables.Table.bin.html#datascience.tables.Table.bin).  It returns a new table with a row for each bin.\n",
    "\n",
    "Here we also illustrate doing some computing on the distribution table:\n",
    "* A column of a table is accessed using the standard python *get* syntax: `<object> [ <key> ]`. This actually yields an object that is a [numpy array](https://docs.scipy.org/doc/numpy-dev/user/quickstart.html), but part of the beauty of tables is you don't have to worry about what that is. The beauty of numpy arrays is that you can work with them pretty much like values, i.e., you can scale them by a constant, add them together and things like that.\n",
    "* A column is inserted in the table using the standard python set syntax for objects `<object> [ <key> ] = <value>`. Note that this modifies the table, adding a column if it does not exist ro updating it if it does.  The transformations on tables are *functional*, they produce new tables.  Set treats a table like an object and modifies it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "roll_dist = rolls.bin(normed=True,bins=bins).take(range(6))\n",
    "roll_dist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "roll_dist['roll density']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "roll_dist['Variation'] = (roll_dist['roll density'] - 1/6)/(1/6)\n",
    "roll_dist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# What is the average value of a roll?\n",
    "sum(roll_dist['bin']*roll_dist['roll density'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "np.mean(rolls['roll'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "## Statistical thinking\n",
    "\n",
    "They say \"life is about rolling dice\".  The statistical perspective on the `rolls` table above would be captured by sampling many times from the die table.  We can capture than naturally in a computational abstraction that rolls a die `n` times."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# Life is about rolling lots of dice.\n",
    "# Simulate rolling n dice.\n",
    "def roll(n):\n",
    "    \"\"\"Roll n die.  Return a table of the rolls\"\"\"\n",
    "    return die.sample(n, with_replacement=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# try it out.  many times\n",
    "roll(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "## Interactive visualization\n",
    "\n",
    "The central concept of computational thinking - *abstraction*. Here it is illustrated again by wrapping up the process of rolling many die and visualizing the resulting distribution into a function.\n",
    "\n",
    "Once we have it as a function, we can illustrate the central concept of inferential thinking - *the law of large numbers* - through interactive visualization.  When a dies is rolled only a few times, the resulting distribution may be very uneven.  But when it is rolled many many times, it is extremely rare for the result to be uneven."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "def show_die_dist(n):\n",
    "    \"\"\"Roll a die n times and show the distribution of sides that appear.\"\"\"\n",
    "    roll(n).hist(bins=np.arange(1,8))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# We can now use the ipywidget we had included at the beginning.\n",
    "interact(show_die_dist, n=(10, 1000, 10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "## Likelihood\n",
    "\n",
    "If we really roll the dice several times in life, what might we expect the overall outcome to be like?\n",
    "\n",
    "We can extend our computational approach further by simulating the rolling of several die many many times. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "num_die = 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "num_rolls = 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# Remember - referencing a column gives an array\n",
    "roll(num_die)['side']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# Simulate rolling num_die dice num_rolls times and build a table of the result\n",
    "rolls = Table([\"die_\"+str(i) for i in range(num_die)]).with_rows([roll(num_die)['side'] for i in range(num_rolls)])\n",
    "rolls"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# If we think of each row as a life experience, what is the life like?\n",
    "label = \"{}_dice\".format(num_die)\n",
    "sum_rolls = Table().with_column(label, [np.sum(roll(num_die)['side']) for i in range(num_rolls)])\n",
    "sum_rolls.hist(range=[10,6*num_die], normed=False)\n",
    "sum_rolls.stats()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# Or as a distribution\n",
    "sum_rolls.hist(range=[10,6*num_die],normed=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# Or normalize by the number of die ...\n",
    "#\n",
    "Table().with_column(label, [np.sum(roll(num_die)['side'])/num_die for i in range(num_rolls)]).hist(normed=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "In probability theory, the central limit theorem (CLT) states that, given certain conditions, the arithmetic mean of a sufficiently large number of iterates of independent random variables, each with a well-defined expected value and well-defined variance, will be approximately normally distributed, regardless of the underlying distribution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [default]",
   "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.5.3"
  },
  "widgets": {
   "state": {
    "35e80ef2b36d43de82beb22a6ed0092b": {
     "views": [
      {
       "cell_index": 22
      }
     ]
    }
   },
   "version": "1.2.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}