From 683b751dab397db816325cb98db5f712a2147efe Mon Sep 17 00:00:00 2001
From: unknown <ethan.meyers@gmail.com>
Date: Tue, 29 Mar 2022 21:07:33 -0400
Subject: [PATCH] Added practice exercises 7

---
 practice_exercises/practice07.zip             | Bin 0 -> 5883 bytes
 .../practice07/practice07.ipynb               | 574 ++++++++++++++++++
 .../practice07/serial_numbers.csv             |  18 +
 3 files changed, 592 insertions(+)
 create mode 100644 practice_exercises/practice07.zip
 create mode 100644 practice_exercises/practice07/practice07.ipynb
 create mode 100644 practice_exercises/practice07/serial_numbers.csv

diff --git a/practice_exercises/practice07.zip b/practice_exercises/practice07.zip
new file mode 100644
index 0000000000000000000000000000000000000000..c0c8dbc9122142636e7cce09ba0704119d88816c
GIT binary patch
literal 5883
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

literal 0
HcmV?d00001

diff --git a/practice_exercises/practice07/practice07.ipynb b/practice_exercises/practice07/practice07.ipynb
new file mode 100644
index 0000000..84cb540
--- /dev/null
+++ b/practice_exercises/practice07/practice07.ipynb
@@ -0,0 +1,574 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Practice Exercises 7: Resampling and the Bootstrap"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The British Royal Air Force (RAF) wanted to know how many warplanes the Germans had (some number `N`, which is a *population parameter*), and they needed to estimate that quantity knowing only a random sample of the planes' serial numbers (from 1 to `N`). We know that the German's warplanes are labeled consecutively from 1 to `N`, so `N` would be the total number of warplanes they have. \n",
+    "\n",
+    "We normally investigate the random variation amongst our estimates by simulating a sampling procedure from the population many times and computing estimates from each sample that we generate.  In real life, if the RAF had known what the population looked like, they would have known `N` and would not have had any reason to think about random sampling. However, they didn't know what the population looked like, so they couldn't have run the simulations that we normally do.  \n",
+    "\n",
+    "Simulating a sampling procedure many times was a useful exercise in *understanding random variation* for an estimate, but it's not as useful as a tool for practical data analysis.\n",
+    "\n",
+    "Let's flip that sampling idea on its head to make it practical. Given *just* a random sample of serial numbers, we'll estimate `N`, and then we'll use simulation to find out how accurate our estimate probably is, without ever looking at the whole population.  This is an example of *statistical inference*.\n",
+    "\n",
+    "Remember, practice exercises are *not* required and will not be turned in for credit...but they are helpful for developing your YData skills!\n",
+    "\n",
+    "Credit:  These practice exercises have been adapted from Berkeley's Data8 course.\n",
+    "\n",
+    "Let's begin by running the cell below."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Run this cell to set up the notebook, but please don't change it.\n",
+    "\n",
+    "# These lines import the Numpy and Datascience modules.\n",
+    "import numpy as np\n",
+    "from datascience import *\n",
+    "\n",
+    "# These lines do some fancy plotting magic.\n",
+    "import matplotlib\n",
+    "%matplotlib inline\n",
+    "import matplotlib.pyplot as plt\n",
+    "plt.style.use('fivethirtyeight')\n",
+    "import warnings\n",
+    "warnings.simplefilter('ignore', FutureWarning)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 1. Preliminaries\n",
+    "We (the RAF in World War II) want to know the number of warplanes fielded by the Germans.  That number is `N`.  The warplanes have serial numbers from 1 to `N`, so `N` is also equal to the largest serial number on any of the warplanes.\n",
+    "\n",
+    "We only see a small number of serial numbers (assumed to be a random sample with replacement from among all the serial numbers), so we have to use estimation."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Question 1.1\n",
+    "Is `N` a population parameter or a statistic?  If we compute a number using our random sample that's an estimate of `N`, is that a population parameter or a statistic?"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "deletable": false,
+    "manual_problem_id": "population_parameter"
+   },
+   "source": [
+    "*Write your answer here, replacing this text.*"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "To make the situation realistic, we're going to hide the true number of warplanes from you.  You'll have access only to this random sample:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "observations = Table.read_table(\"serial_numbers.csv\")\n",
+    "num_observations = observations.num_rows\n",
+    "observations"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Question 1.2\n",
+    "Define a function named `plot_serial_numbers` to make a histogram of any table of serial numbers.  It should take one argument, a table like `observations` with one column called `\"serial number\"`.  It should plot a histogram of the values in the column **using bins of width 1** ranging from **1 to 200** but return nothing.  Then, call that function to make a histogram of `observations`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "deletable": false
+   },
+   "outputs": [],
+   "source": [
+    "def plot_serial_numbers(numbers):\n",
+    "    ...\n",
+    "    \n",
+    "    # Assuming the lines above produce a histogram, this next\n",
+    "    # line may make your histograms look nicer.  Feel free to\n",
+    "    # delete it if you want.\n",
+    "    plt.ylim(0, .25)\n",
+    "\n",
+    "plot_serial_numbers(observations)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Question 1.3\n",
+    "By looking at the histogram, what can we say about `N` immediately? (Hint: What is the relationship between `N` and the largest serial number in `observations`?) What does each little bar in the histogram represent and why are all the bars the same height?"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "deletable": false,
+    "manual_problem_id": "mean_based_sample"
+   },
+   "source": [
+    "*Write your answer here, replacing this text.*"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Question 1.4\n",
+    "One way to estimate `N` is to take twice the mean of the serial numbers we see. Write a function that computes that statistic.  It should take as its argument an array of serial numbers and return twice their mean.  Call it `mean_based_estimator`.  \n",
+    "\n",
+    "After that, use it to compute an estimate of `N` called `mean_based_estimate`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "deletable": false
+   },
+   "outputs": [],
+   "source": [
+    "def mean_based_estimator(nums):\n",
+    "    ...\n",
+    "\n",
+    "mean_based_estimate = ...\n",
+    "mean_based_estimate"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Question 1.5\n",
+    "We can also estimate `N` by using the biggest serial number in the sample.  Compute it, giving it the name `max_estimate`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "deletable": false
+   },
+   "outputs": [],
+   "source": [
+    "max_estimate = ...\n",
+    "max_estimate"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Question 1.6\n",
+    "Look at the values of `max_estimate` and `mean_based_estimate` that we happened to get for our dataset.  The value of `max_estimate` tells you something about `mean_based_estimate`.  For these specific values, is it possible for our value  of `mean_based_estimate` to be equal to `N` (at least, if we round it to the nearest integer)?  If not, is it definitely higher, definitely lower, or can we not tell?  Can you make a statement like the value of our \"`mean_based_estimate` is at least *[fill in a number]* away from `N`\"?"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "deletable": false,
+    "manual_problem_id": "max_estimate"
+   },
+   "source": [
+    "*Write your answer here, replacing this text.*"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can't just confidently proclaim that `max_estimate` or `mean_based_estimate` is equal to `N`.  What if we're really far off?  So we want to get a sense of the accuracy of our estimates."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 2. Resampling\n",
+    "To do this, we'll use resampling.  That is, we won't exactly simulate the observations the RAF would have really seen.  Rather we sample from our current sample, or \"resample.\"\n",
+    "\n",
+    "Why does that make any sense?\n",
+    "\n",
+    "When we tried to estimate `N`, we would have liked to use the whole population.  Since we had only a sample, we used that to estimate `N` instead.\n",
+    "\n",
+    "This time, we would like to use the population of serial numbers to *run a simulation* about estimates of `N`.  But we still only have our sample.  We use our sample in place of the population to run the simulation.\n",
+    "\n",
+    "So there is a simple analogy between estimating `N` and simulating the variability of estimates.\n",
+    "\n",
+    "$$\\text{computing }N\\text{ from the population}$$\n",
+    "$$:$$\n",
+    "$$\\text{computing an estimate of }N\\text{ from a sample}$$\n",
+    "\n",
+    "$$\\text{as}$$\n",
+    "\n",
+    "$$\\text{simulating the distribution of estimates of }N\\text{ using samples from the population}$$\n",
+    "$$:$$\n",
+    "$$\\text{simulating an (approximate) distribution of estimates of }N\\text{ using resamples from a sample}$$"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Question 2.1\n",
+    "Write a function called `simulate_resample`.  It should generate a resample from the observed serial numbers in `observations` and return that resample.  (The resample should be a table like `observations`.)  It should take no arguments."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "deletable": false
+   },
+   "outputs": [],
+   "source": [
+    "def simulate_resample():\n",
+    "    ..."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's make one resample."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# This is a little magic to make sure that you see the same results\n",
+    "# we did.\n",
+    "np.random.seed(123)\n",
+    "\n",
+    "one_resample = simulate_resample()\n",
+    "one_resample"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Later, we'll use many resamples at once to see what estimates typically look like.  We don't often pay attention to single resamples, so it's easy to misunderstand them.  Let's examine some individual resamples before we start using them."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Question 2.2\n",
+    "Make a histogram of your resample using the plotting function you defined earlier in this lab, **and** a separate histogram of the original observations."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "deletable": false
+   },
+   "outputs": [],
+   "source": [
+    "...\n",
+    "..."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Question 2.3\n",
+    "Which of the following are true:\n",
+    "1. In the plot of the resample, there are no bars at locations that weren't there in the plot of the original observations.\n",
+    "2. In the plot of the original observations, there are no bars at locations that weren't there in the plot of the resample.\n",
+    "3. The resample has exactly one copy of each serial number.\n",
+    "4. The sample has exactly one copy of each serial number.\n",
+    "\n",
+    "Assign true_statements to a list of the correct statements."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "deletable": false
+   },
+   "outputs": [],
+   "source": [
+    "true_statements = ..."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Question 2.4\n",
+    "Create two more resamples using the function `simulate_resample` from above. For each resampled data, plot it and compute its max- and mean-based estimates."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "deletable": false
+   },
+   "outputs": [],
+   "source": [
+    "resample_0 = ...\n",
+    "...\n",
+    "mean_based_estimate_0 = ...\n",
+    "max_based_estimate_0 = ...\n",
+    "print(\"Mean-based estimate for resample 0:\", mean_based_estimate_0)\n",
+    "print(\"Max-based estimate for resample 0:\", max_based_estimate_0)\n",
+    "\n",
+    "resample_1 = ...\n",
+    "...\n",
+    "mean_based_estimate_1 = ...\n",
+    "max_based_estimate_1 = ...\n",
+    "print(\"Mean-based estimate for resample 1:\", mean_based_estimate_1)\n",
+    "print(\"Max-based estimate for resample 1:\", max_based_estimate_1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "You may find that the max-based estimates from the resamples are both exactly 135.  You will probably find that the two mean-based estimates do differ from the sample mean-based estimate (and from each other).\n",
+    "\n",
+    "#### Question 2.5\n",
+    "Using probability that you've learned, compute the exact chance that a max-based estimate from *one* resample is 135.\n",
+    "\n",
+    "As a refresher, here are some rules of probability that may be helpful:\n",
+    "\n",
+    "- When all outcomes are equally likely: P(event happens) $=$ $\\frac{\\text{# outcomes that make event happen}}{\\text{# of all outcomes}}$\n",
+    "\n",
+    "- When an event can happen in 2 ways: P(event) $=$ P(event happening first way) $+$ P(event happening second way)\n",
+    "\n",
+    "- When 2 events must both happen: P(2 events both happen) $=$ P(one event happens) $*$ P(other event happens, given the first one happened)\n",
+    "\n",
+    "- When an event doesn't happen: P(event doesn't happen) $=$ 1 $-$ P(event does happen)\n",
+    "\n",
+    "- P(at least one success) $= 1 - $ P(no successes)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "deletable": false
+   },
+   "source": [
+    "*Write your answer here, replacing this text.*"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 3. Simulating with resampling\n",
+    "Since resampling from a sample looks just like sampling from a population, the code should look almost the same.  That means we can write a function that simulates the process of either sampling from a population or resampling from a sample.  If we pass in population as its argument, it will do the former; if we pass in a sample, it will do the latter.\n",
+    "\n",
+    "#### Question 3.1\n",
+    "Write a function called `simulate_estimates`.  It should take 4 arguments:\n",
+    "1. A table from which the data should be sampled.  The table will have 1 column named `\"serial number\"`.\n",
+    "2. The size of each sample from that table, an integer.  (For example, to do resampling, we would pass for this argument the number of rows in the table.)\n",
+    "3. A function that computes a statistic of a sample.  This argument is a *function* that takes an array of serial numbers as its argument and returns a number.\n",
+    "4. The number of replications to perform.\n",
+    "\n",
+    "It should simulate many samples with replacement from the given table.  (The number of samples is the 4th argument.)  For each of those samples, it should compute the statistic on that sample. Then it should return an array containing each of those statistics.  The code below provides an example use of your function and describes how you can verify that you've written it correctly."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "deletable": false,
+    "for_assignment_type": "student"
+   },
+   "outputs": [],
+   "source": [
+    "def simulate_estimates(original_table, sample_size, statistic, num_replications):\n",
+    "    # Our implementation of this function took 5 short lines of code.\n",
+    "    ...\n",
+    "\n",
+    "# This should generate an empirical histogram of twice-mean estimates\n",
+    "# of N from samples of size 50 if N is 1000.  This should be a bell-shaped\n",
+    "# curve centered at 1000 with most of its mass in [800, 1200].  To verify your\n",
+    "# answer, make sure that's what you see!\n",
+    "example_estimates = simulate_estimates(\n",
+    "    Table().with_column(\"serial number\", np.arange(1, 1000+1)),\n",
+    "    50,\n",
+    "    mean_based_estimator,\n",
+    "    10000)\n",
+    "Table().with_column(\"mean-based estimate\", example_estimates).hist(bins=np.arange(0, 1500, 25))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now we can go back to the sample we actually observed (the table `observations`) and estimate how much our mean-based estimate of `N` would have varied from sample to sample."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Question 3.2\n",
+    "Using the bootstrap and the sample `observations`, simulate the approximate distribution of *mean-based estimates* of `N`.  Use 5,000 replications.  \n",
+    "We have provided code that plots a histogram, allowing you to visualize the simulated estimates."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "deletable": false
+   },
+   "outputs": [],
+   "source": [
+    "bootstrap_estimates = ...\n",
+    "Table().with_column(\"mean-based estimate\", bootstrap_estimates).hist(bins=np.arange(0, 200, 4)) "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Question 3.3\n",
+    "Compute an interval that covers the middle 95% of the bootstrap estimates.  Verify that your interval looks like it covers 95% of the area in the histogram above."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "deletable": false
+   },
+   "outputs": [],
+   "source": [
+    "left_end = ...\n",
+    "right_end = ...\n",
+    "print(\"Middle 95% of bootstrap estimates: [{:f}, {:f}]\".format(left_end, right_end))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Question 3.4\n",
+    "Your mean-based estimate of `N` should have been around 122. Given the above calculations, is it likely that `N` is exactly 122? If not, what is the typical range of values of the mean-based estimates of `N` for samples of size 17?"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "deletable": false
+   },
+   "source": [
+    "*Write your answer here, replacing this text.*"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Question 3.5\n",
+    "`N` was actually 150!  Write code that simulates the sampling and bootstrapping process again, as follows:\n",
+    "\n",
+    "1. Generate a new set of random observations the RAF might have seen by sampling from the population table we have created for you below. \n",
+    "2. Compute an estimate of `N` from these new observations, using `mean_based_estimator`.\n",
+    "3. Using only the new observations, compute 5,000 bootstrap estimates of `N`.\n",
+    "4. Plot these bootstrap estimates and compute an interval covering the middle 95%."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "deletable": false
+   },
+   "outputs": [],
+   "source": [
+    "population = Table().with_column(\"serial number\", np.arange(1, 150+1))\n",
+    "\n",
+    "new_observations = ...\n",
+    "new_mean_based_estimate = ...\n",
+    "new_bootstrap_estimates = ...\n",
+    "...\n",
+    "new_left_end = ...\n",
+    "new_right_end = ...\n",
+    "\n",
+    "print(\"New mean-based estimate: {:f}\".format(new_mean_based_estimate))\n",
+    "print(\"Middle 95% of bootstrap estimates: [{:f}, {:f}]\".format(new_left_end, new_right_end))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Question 3.6\n",
+    "Does the interval covering the middle 95% of the new bootstrap estimates include `N`?  If you ran that cell many times, what is the probability that it will include `N`?"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "deletable": false
+   },
+   "source": [
+    "*Write your answer here, replacing this text.*"
+   ]
+  }
+ ],
+ "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.7.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}
diff --git a/practice_exercises/practice07/serial_numbers.csv b/practice_exercises/practice07/serial_numbers.csv
new file mode 100644
index 0000000..c6a9498
--- /dev/null
+++ b/practice_exercises/practice07/serial_numbers.csv
@@ -0,0 +1,18 @@
+serial number
+47
+42
+57
+79
+26
+23
+36
+64
+83
+135
+41
+21
+67
+108
+84
+50
+78