{ "cells": [ { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Confidence Intervals\n", "====\n", "\n", "## Unit 8, Lecture 2\n", "\n", "*Numerical Methods and Statistics*\n", "\n", "----\n", "\n", "### Reading\n", "\n", "Bulmer: Pages 165-167\n", "\n", "----\n", "\n", "#### Prof. Andrew White, March 22 2020" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Computing Confidence Interval for error in population mean with $t$-Distribution \n", "====\n", "\n", "We know that the error in the population mean follows a $t$-distribution for small $N$. What if we want a confidence interval for where the true mean lies?" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "$$P(a < \\mu < b) = 0.95$$\n", "\n", "One simplification we can make right away is that we know $\\mu$ will be centered at $\\bar{x}$ and is symmetric:\n", "\n", "$$P( \\bar{x} - y < \\mu< \\bar{x} + y) = 0.95$$\n", "\n", "where $y$ is some number we need to find. We can further rewrite this as:\n", "\n", "$$P( - y < \\mu - \\bar{x}< + y) = 0.95$$\n", "\n", "which we know follows a $t-$distribution. Note that these are probailities, which are integrals of the probability distribution" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Here's a visual to understand what we're after. Note that I'm actually answering this problem to make the graph, so wait until later to try to understand the code!" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "slideshow": { "slide_type": "subslide" } }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "import scipy.stats as ss\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "%matplotlib inline\n", "\n", "#make some points for plot\n", "N = 5\n", "x = np.linspace(-5,5, 1000)\n", "T = ss.t.ppf(0.975, df=N-1)\n", "y = ss.t.pdf(x, df=N-1)\n", "plt.plot(x,y) \n", "plt.fill_between(x, y, where= np.abs(x) < T)\n", "plt.text(0,np.max(y) / 3, 'Area=0.95', fontdict={'size':14}, horizontalalignment='center')\n", "plt.axvline(T, linestyle='--', color='orange')\n", "plt.axvline(-T, linestyle='--', color='orange')\n", "plt.xticks([-T, T], ['-y', 'y'])\n", "plt.yticks([])\n", "plt.ylabel(r'$p(\\mu - \\bar{x})$')\n", "plt.xlabel(r'$\\mu - \\bar{x}$')\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "\n", "This is a very similar problem to the prediction intervals we had before. We know that $p(\\mu - \\bar{x})$ follows a $T(0, \\sigma_x /\\sqrt{N}, N - 1)$ distribution and we can use the same idea as $Z$-scores as we did for prediction intervals" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "fragment" } }, "source": [ "\n", "\n", "$$T(y) = \\frac{y - 0}{\\sigma_x / \\sqrt{N}}$$\n", "\n", "The 'mean' our error in the population mean distribution is 0, because our error in population mean is always centered around 0." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "fragment" } }, "source": [ "After taking 5 samples, we've found that the sample mean is 45 and the sample standard deviation, $\\sigma_x$ is 3. What is the 95% confidence interval for the true mean, $\\mu$?" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "fragment" } }, "source": [ "We can write this more like this:\n", "\n", "$$P(- y < \\mu - \\bar{x} < +y) = 0.95$$" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "Our interval will go from 2.5% to 97.5% (95% of probability), so let's find the $T$-value for $-\\infty$ to 2.5% and 97.5% to $\\infty$. Remember that the $T$-value depends on the degrees of freedom, N-1." ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "-2.7764451051977996\n", "2.7764451051977987\n" ] } ], "source": [ "import scipy.stats\n", "\n", "#The lower T Value. YOU MUST GIVE THE SAMPLE NUMBER\n", "print(scipy.stats.t.ppf(0.025, 4))\n", "print(scipy.stats.t.ppf(0.975, 4))" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "fragment" } }, "source": [ "$$T_{low} = \\frac{-y - 0}{\\sigma_x / \\sqrt{N}}$$\n", "$$T_{low} = -\\frac{y}{\\sigma_x / \\sqrt{N}}$$" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "$$y = -T_{low}\\frac{\\sigma_x}{\\sqrt{N}}$$" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "3.7249919946113006\n" ] } ], "source": [ "print(-scipy.stats.t.ppf(0.025, 4) * 3 / np.sqrt(5))" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "fragment" } }, "source": [ "The final answer is $P(45 - 3.72 < 45 < 45 + 3.72) = 0.95$ or $45\\pm 3.72$" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Computing Confidence Interval for Error in Population Mean Steps\n", "====\n", "\n", "1. Is the sample size greater than 25 OR do you know the true (population) standard deviation? If so, then use standard normal ($Z$) otherwise the $t$-distribution for your sample size ($T$).\n", "2. Build your interval in probability. For example, a 95% double-sided goes from 2.5% to 97.5%\n", "3. Find the $Z$ or $T$ values that match your interval. For example, $Z_{low} = -1.96$ to $Z_{high} = 1.96$ is for a double-sided 95% confidence inerval. Use the `scipy.stats.t.ppf` or `scipy.stats.norm.ppf` function to find them.\n", "4. Use the $y = Z \\sigma / \\sqrt{N}$ or $y = T \\sigma_x / \\sqrt{N}$ equation to find the interval values in your particular distribution, where $y$ is the interval width\n", "5. Report your answer either as an interval or the $\\bar{x} \\pm y$ notation." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "Shortcut Method For Normal\n", "====\n", "\n", "Here's how to quickly do these steps in Python for sample size greater than 25" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [], "source": [ "# DO NOT COPY, JUST GENERATING DATA FOR EXAMPLE\n", "data = scipy.stats.norm.rvs(size=100, scale=15, loc=50)" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "51.15171700183236 +/ 2.6078997696784336\n" ] } ], "source": [ "#Check if sample size is big enough.\n", "#This code will cause an error if it's not\n", "assert len(data) > 25 \n", "\n", "CI = 0.95\n", "sample_mean = np.mean(data)\n", "#The second argument specifies what the denominator should be (N - x),\n", "#where x is 1 in this case\n", "sample_var = np.var(data, ddof=1) \n", "Z = scipy.stats.norm.ppf((1 - CI) / 2)\n", "y = -Z * np.sqrt(sample_var / len(data))\n", "\n", "print('{} +/ {}'.format(sample_mean, y))\n", " " ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "Is that low? Well, remember that our error in the mean follows standard deviation divided by the root of number of samples." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "Shortcut Method For $t$-Distribution\n", "====\n", "\n", "Here's how to quickly do these steps in Python for sample size less than 25" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [], "source": [ "# DO NOT COPY, THIS JUST GENERATES DATA FOR EXAMPLE\n", "data = scipy.stats.norm.rvs(size=4, scale=15, loc=50)" ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "50.38338953766582 +/ 36.784888003627046\n" ] } ], "source": [ "CI = 0.95\n", "sample_mean = np.mean(data)\n", "sample_var = np.var(data, ddof=1) \n", "T = scipy.stats.t.ppf((1 - CI) / 2, df=len(data)-1)\n", "y = -T * np.sqrt(sample_var / len(data))\n", "\n", "print('{} +/ {}'.format(sample_mean, y))\n", " " ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Example of Prediction Intervals\n", "====\n", "\n", "I *know* that the thickness of a metal slab is distributed according to ${\\cal N}(3.4, 0.75)$. Construct a prediction interval so that a randomly chosen metal slab will lie within it 95% confidence." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "fragment" } }, "source": [ "$$P( \\mu - y < x < \\mu + y) = 0.95$$" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "fragment" } }, "source": [ "This is a prediction interval, so we're computing a interval on the distribution itself and we know everything about it." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "$$Z(\\mu + y) = \\frac{\\mu + y - \\mu}{\\sigma} \\Rightarrow y = \\sigma Z$$\n", "\n", "$$Z = 1.96$$\n", "\n", "$$x = \\mu \\pm 1.96 \\sigma = 3.4 \\pm 1.40$$" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "A randomly chosen slab will have a thickness of $3.4 \\pm 1.40$ 95% of the time. " ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Example 1 of error in population mean with known $\\sigma$\n", "====\n", "\n", "I measure the thickness of 35 metal slabs and find that $\\bar{x}$, the sample mean, is 3.38. If I know that $\\sigma = 0.75$, construct a confidence interval that will contain the true mean $\\mu$ with 95% confidence." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "We know that $p(\\bar{x} - \\mu)$ is normally distributed with ${\\cal N}(0, \\sigma / \\sqrt{N})$. We want to find\n", "\n", "$$ P(-y < \\bar{x} - \\mu < +y) = 0.95$$" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "$$ Z(+y) = \\frac{y - 0}{\\sigma_e} = \\frac{y}{\\sigma / \\sqrt{N}} \\Rightarrow y = \\frac{\\sigma}{\\sqrt{N}} Z$$\n", "\n", "$$y = \\frac{0.75}{\\sqrt{35}}1.96 = 0.248$$\n", "\n", "$$ \\mu - \\bar{x} = 0 \\pm 0.248$$\n", "\n", "$$ \\mu = 3.38 \\pm 0.248$$" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "fragment" } }, "source": [ "At a 95% confidence level, the true mean is $3.38 \\pm 0.248$. " ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Example 2 of error in population mean with known $\\sigma$\n", "====\n", "\n", "I measure the thickness of 11 metal slabs and find that $\\bar{x}$, the sample mean, is 5.64. If I know that $\\sigma = 1.2$, construct a confidence interval that will contain the true mean $\\mu$ with 99% confidence." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "fragment" } }, "source": [ "Again we know that $p(\\bar{x} - \\mu)$ is normally distributed with ${\\cal N}(0, \\sigma / \\sqrt{N})$. We want to find\n", "\n", "$$ P(-y < \\bar{x} - \\mu < +y) = 0.99$$" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "$$ Z(+y) = \\frac{y - 0}{\\sigma_e} = \\frac{y}{\\sigma / \\sqrt{N}} \\Rightarrow y = \\frac{\\sigma}{\\sqrt{N}} Z$$\n", "\n", "$$y = \\frac{1.2}{\\sqrt{11}}2.575 = 0.932$$\n", "\n", "$$ \\mu - \\bar{x} = 0 \\pm 0.932$$\n", "\n", "$$ \\mu = 5.64 \\pm 0.932$$" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Example 1 of error in population mean with unknown $\\sigma$\n", "====\n", "\n", "I measure the thickness of 6 metal slabs and find that $\\bar{x}$, the sample mean, is 3.65 and the sample standard deviation is $1.25$. Construct a confidence interval that will contain the true mean $\\mu$ with 90% confidence.\n" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "fragment" } }, "source": [ "$$T(+y) = \\frac{y - 0}{\\sigma_x / \\sqrt{N}} \\Rightarrow y = \\frac{\\sigma_x}{\\sqrt{N}} T$$" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "We know that $p(\\bar{x} - \\mu)$ is a $t$-distribution because $N$ is small. It is distributed as $T(0, \\sigma_x / \\sqrt{N})$. We want to find\n", "\n", "$$ P(-y < \\bar{x} - \\mu < +y) = 0.90$$" ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "2.015048372669157\n" ] } ], "source": [ "#Notice it is 95%, so the interval goes from\n", "#5% to 95% containing 90% of probability\n", "T = scipy.stats.t.ppf(0.95, df=6-1)\n", "print(T)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "$$ y = \\frac{1.25}{\\sqrt{6}} 2.015 = 1.028 $$\n", "$$\\mu = 3.65 \\pm 1.028$$" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "fragment" } }, "source": [ "The population mean of the slabs is $3.65 \\pm 1.028$ with 90% confidence." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Example 2 of error in population mean with unknown $\\sigma$\n", "====\n", "\n", "I measure the thickness of 25 metal slabs and find that $\\bar{x}$, the sample mean, is 3.42 and the sample standard deviation is 0.85. Construct a confidence interval that will contain the true mean $\\mu$ with 90% confidence." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "We know, just like last example, that $P(\\bar{x} - \\mu)$ is a normal distribution because $N$ is large enough for the central limit theorem to apply. It is distributed as ${\\cal N}(0, \\sigma_x / \\sqrt{N})$. We want to find\n", "\n", "$$ P(-y < \\bar{x} - \\mu < +y) = 0.90$$" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "$$Z(+y) = \\frac{y - 0}{\\sigma_x / \\sqrt{N}} \\Rightarrow y = \\frac{\\sigma_x}{\\sqrt{N}} Z$$\n", "\n", "$$ y = \\frac{0.85}{\\sqrt{25}} 1.645 = 0.28$$\n", "\n", "$$\\mu = 3.42 \\pm 0.28$$" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Single-Sided Confidence Intervals\n", "===\n", "\n", "Sometimes, you would desire only to bound the population mean to be on one side. " ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Upper Interval (Lower-Bound)\n", "--\n", "\n", "An upper-interval covers the upper x% of the probability mass and can be defined as an interval from $(y, \\infty)$, where $y$ acts as a lower-bound. A visual is shown below for an upper 90% confidence interval." ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "slideshow": { "slide_type": "subslide" } }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "#make some points for plot\n", "N = 5\n", "x = np.linspace(-5,5, 1000)\n", "T = ss.t.ppf(0.10, df=N-1)\n", "y = ss.t.pdf(x, df=N-1)\n", "plt.plot(x,y) \n", "plt.fill_between(x, y, where= x > T)\n", "plt.text(0,np.max(y) / 3, 'Area=0.90', fontdict={'size':14}, horizontalalignment='center')\n", "plt.axvline(T, linestyle='--', color='orange')\n", "plt.xticks([T], ['lower-bound'])\n", "plt.yticks([])\n", "plt.ylabel(r'$p(\\mu - \\bar{x})$')\n", "plt.xlabel(r'$\\mu - \\bar{x}$')\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Lower Interval (Upper-Bound)\n", "--\n", "\n", "A lower interval covers the lower x% of probability mass. It is defined with an upper bound like so: $(-\\infty, y)$. An example is below:" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "slideshow": { "slide_type": "subslide" } }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "#make some points for plot\n", "N = 5\n", "x = np.linspace(-5,5, 1000)\n", "T = ss.t.ppf(0.90, df=N-1)\n", "y = ss.t.pdf(x, df=N-1)\n", "plt.plot(x,y) \n", "plt.fill_between(x, y, where= x < T)\n", "plt.text(0,np.max(y) / 3, 'Area=0.90', fontdict={'size':14}, horizontalalignment='center')\n", "plt.axvline(T, linestyle='--', color='orange')\n", "plt.xticks([T], ['upper-bound'])\n", "plt.yticks([])\n", "plt.ylabel(r'$p(\\mu - \\bar{x})$')\n", "plt.xlabel(r'$\\mu - \\bar{x}$')\n", "plt.show()" ] } ], "metadata": { "celltoolbar": "Slideshow", "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": 2 }