cs109a_hw0.ipynb

{
  "metadata": {
    "anaconda-cloud": {},
    "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.6.1"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 1,
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### CS 109A/STAT 121A/AC 209A/CSCI E-109A\n",
        "\n",
        "# Homework 0\n",
        "\n",
        "**Harvard University**<br/>\n",
        "**Fall 2017**<br/>\n",
        "**Instructors**: Pavlos Protopapas, Kevin Rader, Rahul Dave, Margo Levine\n",
        "\n",
        "---\n",
        "\n",
        "This is a homework which you must  turn in.\n",
        "\n",
        "This homework has the following intentions:\n",
        "\n",
        "1. To get you familiar with the jupyter/python environment (whether you are using your own install or jupyterhub)\n",
        "2. You should easily understand these questions and what is being asked. If you struggle, this may not be the right class for you.\n",
        "3. You should be able to understand the intent (if not the exact syntax) of the code and be able to look up google and provide code that is asked of you. If you cannot, this may not be the right class for you."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "collapsed": true
      },
      "outputs": [],
      "source": [
        "# The line %... is a jupyter \"magic\" command, and is not part of the Python language.\n",
        "# In this case we're just telling the plotting library to draw things on\n",
        "# the notebook, instead of on a separate window.\n",
        "%matplotlib inline\n",
        "# See the \"import ... as ...\" contructs below? They're just aliasing the package names.\n",
        "# That way we can call methods like plt.plot() instead of matplotlib.pyplot.plot().\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Simulation of a coin throw\n",
        "\n",
        "We dont have a coin right now. So let us **simulate** the process of throwing one on a computer. To do this we will use a form of the **random number generator** built into `numpy`. In particular, we will use the function `np.random.choice`, which will pick items with uniform probability from a list (thus if the list is of size 6, it will pick one of the six list items each time, with a probability 1/6). "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {},
      "outputs": [],
      "source": [
        "def throw_a_coin(N):\n",
        "    return np.random.choice(['H','T'], size=N)\n",
        "\n",
        "throws = throw_a_coin(40)\n",
        "print(\"Throws\",throws)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "This next line gives you a `True` when the array element is a 'H' and `False` otherwise."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {},
      "outputs": [],
      "source": [
        "throws == 'H'"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "If you do a `np.sum` on the array of `True`s and `False`s, python will coerce the `True` to 1 and `False` to 0. Thus a sum will give you the number of heads"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {},
      "outputs": [],
      "source": [
        "np.sum(throws == 'H')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {},
      "outputs": [],
      "source": [
        "print(\"Number of Heads:\", np.sum(throws == 'H'))\n",
        "print(\"p1 = Number of Heads/Total Throws:\", np.sum(throws == 'H')/40.) # you can also do np.mean(throws=='H')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Notice that you do not necessarily get 20 heads.\n",
        "\n",
        "Now say that we run the entire process again, a second **replication** to obtain a second sample. Then we ask the same question: what is the fraction of heads we get this time? Lets call the odds of heads in sample 2, then, $p_2$:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {},
      "outputs": [],
      "source": [
        "throws = throw_a_coin(40)\n",
        "print(\"Throws:\", throws)\n",
        "print(\"Number of Heads:\", np.sum(throws == 'H'))\n",
        "print(\"p2 = Number of Heads/Total Throws:\", np.sum(throws ==  'H')/40.)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Q1. Show what happens as we choose a larger and larger set of trials\n",
        "\n",
        "Do one replication for each size in the trials array below. Store the resultant probabilities in an array `probabilities`. Write a few lines on what you observe."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "collapsed": true
      },
      "outputs": [],
      "source": [
        "trials = [10, 30, 50, 70, 100, 130, 170, 200, 500, 1000, 2000, 5000, 10000]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "collapsed": true
      },
      "outputs": [],
      "source": [
        "# your code here\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {},
      "outputs": [],
      "source": [
        "plt.plot(trials, probabilities, 'o-', alpha=0.6);\n",
        "plt.axhline(0.5, 0, 1, color='r');\n",
        "plt.xlabel('number of trials');\n",
        "plt.ylabel('probability of heads from simulation');\n",
        "plt.title('Probability of heads, one replication per trial size');"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "What did you observe?\n",
        "\n",
        "*your answer here*\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Multiple replications of the coin flips\n",
        "\n",
        "Lets redo the experiment with coin flips that we started above. We'll establish some terminology at first. As notation we shall call the size of the trial of coin flips $n$. We'll call the result of each coin flip an observation, and a single replication (which is what we did above) a sample of observations. We will do $M$ replications (or $M$ \"samples\"), for which the variable in the function below is `number_of_samples` now, for each sample size $n$ (`sample_size`)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Q2. Write a function to make M replications of N throws\n",
        "\n",
        "Your job is to write a function `make_throws` which takes as arguments the `number_of_samples` (M) and the `sample_size` (n), and returns a list of probablities of size M, with each probability coming from a different replication of size n. In each replication we do n coin tosses. We have provided a \"spec\" of the function below. "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "collapsed": true
      },
      "outputs": [],
      "source": [
        "\"\"\"\n",
        "Function\n",
        "--------\n",
        "make_throws\n",
        "\n",
        "Generate a array of probabilities, each representing\n",
        "the probability of finding heads in a sample of fair coins\n",
        "\n",
        "Parameters\n",
        "----------\n",
        "number_of_samples : int\n",
        "    The number of samples or replications\n",
        "sample_size: int\n",
        "    The size of each sample (we assume each sample has the same size)\n",
        "\n",
        "Returns\n",
        "-------\n",
        "sample_probs : array\n",
        "    Array of probabilities of H, one from each sample or replication\n",
        "\n",
        "Example\n",
        "-------\n",
        ">>> make_throws(number_of_samples = 3, sample_size = 20)\n",
        "[0.40000000000000002, 0.5, 0.59999999999999998]\n",
        "\"\"\"\n",
        "# your code here\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "We show the mean over the observations, or sample mean, for a sample size of 10, with 20 replications. There are thus 20 means."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {},
      "outputs": [],
      "source": [
        "make_throws(number_of_samples=20, sample_size=10)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Q3. What happens to the mean and standard deviation of the sample means as you increase the sample size\n",
        "\n",
        "Using the sample sizes from the `sample_sizes` array below, compute a set of sample_means for each sample size, and for 200 replications. Calculate the mean and standard deviation for each sample size. Store this in arrays `mean_of_sample_means` and `std_dev_of_sample_means`. The standard deviation of the sampling means is called the \"standard error\". Explain what you see about this \"mean of sampling means\"."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "collapsed": true
      },
      "outputs": [],
      "source": [
        "sample_sizes = np.arange(1,1001,1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "collapsed": true
      },
      "outputs": [],
      "source": [
        "# your code here\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {},
      "outputs": [],
      "source": [
        "# mean and std of 200 means from 200 replications, each of size 10\n",
        "trials[0], mean_of_sample_means[0], std_dev_of_sample_means[0] "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {},
      "outputs": [],
      "source": [
        "plt.plot(sample_sizes, mean_of_sample_means);\n",
        "plt.ylim([0.480,0.520]);\n",
        "plt.xlabel(\"sample sizes\")\n",
        "plt.ylabel(\"mean probability of heads\")\n",
        "plt.title(\"Mean of sample means over 200 replications\");"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Explain what you see about this \"mean of sampling means\".\n",
        "\n",
        "*your answer here*\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Q4. What distribution do the sampling means follow?\n",
        "\n",
        "Store in variables `sampling_means_at_size_100` and `sampling_means_at_size_1000` the set of sampling means at sample sizes of 100 and 1000 respectively, still with 200 replications. We will plot in a histogram below these distributions. What type of distributions are these, roughly? How do these distributions vary with sample size?"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {
        "collapsed": true
      },
      "outputs": [],
      "source": [
        "# your code here\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {},
      "outputs": [],
      "source": [
        "plt.hist(sampling_means_at_size_100, alpha=0.3, label=\"100\", bins=10)\n",
        "plt.hist(sampling_means_at_size_1000, alpha=0.3, label=\"1000\", bins=10)\n",
        "plt.legend();\n",
        "plt.title(\"Sampling distributions at different sample sizes and for 200 replications\");"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "What type of distributions are these, roughly? How do these distributions vary with sample size?\n",
        "\n",
        "*your answer here*\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Q5. How does the standard error of the sample mean vary with sample size? Create a plot to illustrate how it varies over various sample sizes.\n",
        "\n",
        "Hint: you might want to take logarithms for one of your axes"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {},
      "outputs": [],
      "source": [
        "# your code here\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "How does the standard error of the sample mean vary with sample size?\n",
        "\n",
        "*your answer here*\n"
      ]
    }
  ]
}