{ "cells": [ { "cell_type": "code", "execution_count": 1, "metadata": { "tags": [ "remove_input" ] }, "outputs": [], "source": [ "path_data = '../../../../data/'\n", "\n", "import numpy as np\n", "import pandas as pd\n", "\n", "%matplotlib inline\n", "import matplotlib.pyplot as plt\n", "plt.style.use('fivethirtyeight')\n", "\n", "import warnings\n", "warnings.filterwarnings('ignore')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Empirical Distribution of a Statistic ###\n", "The Law of Averages implies that with high probability, the empirical distribution of a large random sample will resemble the distribution of the population from which the sample was drawn.\n", "\n", "The resemblance is visible in two histograms: the empirical histogram of a large random sample is likely to resemble the histogram of the population.\n", "\n", "As a reminder, here is the histogram of the delays of all the flights in `united`, and an empirical histogram of the delays of a random sample of 1,000 of these flights." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "united = pd.read_csv(path_data + 'united_summer2015.csv')" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "delay_bins = np.arange(-20, 201, 10)\n", "\n", "unit = 'minute'\n", "\n", "fig, ax1 = plt.subplots()\n", "\n", "ax1.hist(united['Delay'], bins=delay_bins, density=True, alpha=0.8, ec='white')\n", "\n", "y_vals = ax1.get_yticks()\n", "\n", "y_label = 'Percent per ' + (unit if unit else 'unit')\n", "\n", "x_label = 'Delay' + (unit if unit else '(unit)')\n", "\n", "ax1.set_yticklabels(['{:g}'.format(x * 100) for x in y_vals])\n", "\n", "plt.ylabel(y_label)\n", "\n", "plt.xlabel(x_label)\n", "\n", "plt.title('Population');\n", "\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "sample_1000 = united.sample(1000)\n", "\n", "unit = 'minute'\n", "\n", "fig, ax1 = plt.subplots()\n", "\n", "ax1.hist(sample_1000['Delay'], bins=delay_bins, density=True, alpha=0.8, ec='white')\n", "\n", "y_vals = ax1.get_yticks()\n", "\n", "y_label = 'Percent per ' + (unit if unit else 'unit')\n", "\n", "x_label = 'Delay (' + (unit if unit else 'unit') + ')'\n", "\n", "ax1.set_yticklabels(['{:g}'.format(x * 100) for x in y_vals])\n", "\n", "plt.ylabel(y_label)\n", "\n", "plt.xlabel(x_label)\n", "\n", "plt.title('Population');\n", "\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The two histograms clearly resemble each other, though they are not identical. " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Parameter ###\n", "Frequently, we are interested in numerical quantities associated with a population.\n", "- In a population of voters, what percent will vote for Candidate A?\n", "- In a population of Facebook users, what is the largest number of Facebook friends that the users have?\n", "- In a population of United flights, what is the median departure delay?\n", "\n", "Numerical quantities associated with a population are called *parameters*. For the population of flights in `united`, we know the value of the parameter \"median delay\":" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "2.0" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.median(united['Delay'])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The `NumPy` function `median` returns the median (half-way point) of an array. Among all the flights in `united`, the median delay was 2 minutes. That is, about 50% of flights in the population had delays of 2 or fewer minutes:" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "0.5018444846292948" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "len(united[united['Delay'] <= 2])/len(united)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Half of all flights left no more than 2 minutes after their scheduled departure time. That's a very short delay! \n", "\n", "**Note.** The percent isn't exactly 50 because of \"ties,\" that is, flights that had delays of exactly 2 minutes. There were 480 such flights. Ties are quite common in data sets, and we will not worry about them in this course." ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "480" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "len(united[united['Delay'] == 2])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Statistic ###\n", "In many situations, we will be interested in figuring out the value of an unknown parameter. For this, we will rely on data from a large random sample drawn from the population.\n", "\n", "A *statistic* (note the singular!) is any number computed using the data in a sample. The sample median, therefore, is a statistic. \n", "\n", "Remember that `sample_1000` contains a random sample of 1000 flights from `united`. The observed value of the sample median is:" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "3.0" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.median(sample_1000['Delay'], overwrite_input=True)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Our sample – one set of 1,000 flights – gave us one observed value of the statistic. This raises an important problem of inference:\n", "\n", "**The statistic could have been different.**\n", "A fundamental consideration in using any statistic based on a random sample is that *the sample could have come out differently*, and therefore the statistic could have come out differently too. " ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "2.0" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.median(united['Delay'].sample(1000))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Run the cell above a few times to see how the answer varies. Often it is equal to 2, the same value as the population parameter. But sometimes it is different." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Just how different could the statistic have been?** One way to answer this is to simulate the statistic many times and note the values. A histogram of those values will tell us about the distribution of the statistic.\n", "\n", "Let's recall the main steps in a simulation." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Simulating a Statistic ###\n", "We will simulate the sample median using the steps we set up in an earlier chapter when we started studying simulation. You can replace the sample size of 1000 by any other sample size, and the sample median by any other statistic.\n", "\n", "**Step 1: Decide which statistic to simulate.** We have already decided that: we are going to simulate the median of a random sample of size 1000 drawn from the population of flight delays.\n", "\n", "**Step 2: Write the code to generate one value of the statistic.** Draw a random sample of size 1000 and compute the median of the sample. We did this in the code cell above. Here it is again, encapsulated in a function." ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "def random_sample_median():\n", " return np.median(united['Delay'].sample(1000))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Step 3: Decide how many simulated values to generate.** Let's do 5,000 repetitions.\n", "\n", "**Step 4: Write the code to generate an array of simulated values.** As in all simulations, we start by creating an empty array in which we will collect our results. We will then set up a `for` loop for generating all the simulated values. The body of the loop will consist of generating one simulated value of the sample median, and appending it to our collection array.\n", "\n", "The simulation takes a noticeable amount of time to run. That is because it is performing 5000 repetitions of the process of drawing a sample of size 1000 and computing its median. That's a lot of sampling and repeating!" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "medians = np.array([])\n", "\n", "for i in np.arange(5000):\n", " medians = np.append(medians, random_sample_median())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The simulation is done. All 5,000 simulated sample medians have been collected in the array `medians`. Now it's time to visualize the results. " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Visualization ###\n", "\n", "Here are the simulated random sample medians displayed in the table `simulated_medians`." ] }, { "cell_type": "code", "execution_count": 12, "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", " \n", " \n", " \n", " \n", " \n", " \n", "
Sample Median
03.0
12.0
22.0
32.0
43.0
......
49953.0
49962.0
49973.0
49982.0
49992.0
\n", "

5000 rows × 1 columns

\n", "
" ], "text/plain": [ " Sample Median\n", "0 3.0\n", "1 2.0\n", "2 2.0\n", "3 2.0\n", "4 3.0\n", "... ...\n", "4995 3.0\n", "4996 2.0\n", "4997 3.0\n", "4998 2.0\n", "4999 2.0\n", "\n", "[5000 rows x 1 columns]" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "simulated_medians = pd.DataFrame(({'Sample Median':medians}))\n", "simulated_medians" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can also visualize the simulated data using a histogram. The histogram is called an *empirical histogram of the statistic*. It displays the *empirical distribution* of the statistic. Remember that *empirical* means *observed*." ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "fig, ax1 = plt.subplots()\n", "\n", "ax1.hist(simulated_medians, bins=np.arange(0.5, 5, 1), density=True, alpha=0.8, ec='white')\n", "\n", "y_vals = ax1.get_yticks()\n", "\n", "y_label = 'Percent per ' + (unit if unit else 'unit')\n", "\n", "x_label = 'Sample Median'\n", "\n", "ax1.set_yticklabels(['{:g}'.format(x * 100) for x in y_vals])\n", "\n", "plt.ylabel(y_label)\n", "\n", "plt.xlabel(x_label)\n", "\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "You can see that the sample median is very likely to be about 2, which was the value of the population median. Since samples of 1000 flight delays are likely to resemble the population of delays, it is not surprising that the median delays of those samples should be close to the median delay in the population.\n", "\n", "This is an example of how a statistic can provide a good estimate of a parameter." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### The Power of Simulation ###\n", "\n", "If we could generate all possible random samples of size 1000, we would know all possible values of the statistic (the sample median), as well as the probabilities of all those values. We could visualize all the values and probabilities in the probability histogram of the statistic.\n", "\n", "But in many situations including this one, the number of all possible samples is large enough to exceed the capacity of the computer, and purely mathematical calculations of the probabilities can be intractably difficult.\n", "\n", "This is where empirical histograms come in.\n", "\n", "We know that by the Law of Averages, the empirical histogram of the statistic is likely to resemble the probability histogram of the statistic, if the sample size is large and if you repeat the random sampling process numerous times.\n", "\n", "This means that simulating random processes repeatedly is a way of approximating probability distributions *without figuring out the probabilities mathematically or generating all possible random samples*. Thus computer simulations become a powerful tool in data science. They can help data scientists understand the properties of random quantities that would be complicated to analyze in other ways." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "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.12" } }, "nbformat": 4, "nbformat_minor": 1 }