P9 - Confidence Interval.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "d11a0353",
   "metadata": {},
   "source": [
    "## Confidence Interval"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "39cbe004",
   "metadata": {},
   "source": [
    "Data cleaning and exploratory analysis are often preliminary steps toward the end goal of extracting insight from data through statistical inference or predictive modeling. The remainder of this guide will focus on methods for analyzing data and tools for carrying out analyses in Python.\n",
    "\n",
    "Statistical inference is the process of analyzing sample data to gain insight into the population from which the data was collected and to investigate differences between data samples. In data analysis, we are often interested in the characteristics of some large population, but collecting data on the entire population may be infeasible. For example, leading up to U.S. presidential elections it could be very useful to know the political leanings of every single eligible voter, but surveying every voter is not feasible. Instead, we could poll some subset of the population, such as a thousand registered voters, and use that data to make inferences about the population as a whole."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "76696a48",
   "metadata": {},
   "source": [
    "**Point Estimates**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0395f753",
   "metadata": {},
   "source": [
    "Point estimates are estimates of population parameters based on sample data. For instance, if we wanted to know the average age of registered voters in the U.S., we could take a survey of registered voters and then use the average age of the respondents as a point estimate of the average age of the population as a whole. The average of a sample is known as the sample mean.\n",
    "\n",
    "The sample mean is usually not exactly the same as the population mean. This difference can be caused by many factors including poor survey design, biased sampling methods and the randomness inherent to drawing a sample from a population. Let's investigate point estimates by generating a population of random age data and then drawing a sample from it to estimate the mean:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "4a61d01d",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt \n",
    "import scipy.stats as stats\n",
    "import random\n",
    "import math\n",
    "%matplotlib inline "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "aca7b692",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([58, 55, 53, ..., 27, 28, 28])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Genrating random age data \n",
    "np.random.seed(10)\n",
    "\n",
    "population_age_1 = stats.poisson.rvs(loc = 18,\n",
    "                                    mu = 35,\n",
    "                                    size = 150000)\n",
    "population_age_2 = stats.poisson.rvs(loc = 18,\n",
    "                                    mu = 10,\n",
    "                                    size = 100000)\n",
    "\n",
    "population_age = np.concatenate((population_age_1,\n",
    "                               population_age_2))\n",
    "population_age"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "827fb254",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "43.002372"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Calculating the mean of the data obtained \n",
    "population_age.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "09472f59",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([23, 53, 52, 24, 52, 29, 47, 25, 35, 32, 48, 21, 54, 50, 25, 55, 51,\n",
       "       28, 58, 56, 46, 49, 27, 63, 54, 45, 49, 27, 50, 58, 30, 51, 50, 44,\n",
       "       28, 30, 28, 46, 49, 28, 51, 61, 55, 49, 26, 27, 52, 53, 45, 47, 26,\n",
       "       58, 50, 62, 60, 49, 29, 26, 60, 53, 25, 29, 54, 30, 56, 28, 34, 60,\n",
       "       46, 24, 31, 53, 60, 59, 64, 57, 52, 49, 29, 27, 44, 68, 27, 55, 66,\n",
       "       58, 51, 39, 57, 48, 47, 30, 26, 51, 53, 55, 31, 25, 25, 41, 52, 27,\n",
       "       57, 59, 31, 29, 47, 51, 53, 28, 62, 28, 29, 52, 58, 54, 50, 31, 46,\n",
       "       31, 54, 28, 52, 41, 46, 47, 30, 29, 49, 45, 23, 50, 26, 50, 48, 26,\n",
       "       34, 49, 26, 31, 27, 31, 26, 61, 26, 29, 28, 25, 46, 33, 48, 56, 51,\n",
       "       42, 30, 30, 30, 31, 39, 66, 56, 42, 24, 47, 33, 30, 58, 63, 29, 60,\n",
       "       25, 46, 41, 52, 47, 49, 23, 27, 53, 48, 27, 50, 58, 27, 30, 51, 56,\n",
       "       54, 43, 28, 60, 44, 25, 27, 21, 53, 32, 63, 50, 52, 53, 29, 55, 49,\n",
       "       29, 56, 47, 28, 59, 33, 31, 61, 32, 65, 27, 27, 26, 26, 39, 60, 26,\n",
       "       51, 25, 51, 28, 58, 46, 28, 28, 56, 28, 60, 53, 56, 44, 63, 25, 51,\n",
       "       44, 47, 56, 43, 57, 23, 29, 53, 28, 54, 28, 26, 57, 54, 46, 54, 26,\n",
       "       53, 28, 58, 31, 50, 54, 25, 49, 29, 27, 60, 28, 50, 30, 52, 26, 62,\n",
       "       33, 28, 57, 52, 27, 57, 46, 46, 31, 56, 27, 51, 24, 51, 46, 23, 24,\n",
       "       30, 26, 54, 27, 27, 25, 55, 34, 30, 50, 55, 59, 58, 34, 34, 29, 26,\n",
       "       45, 50, 49, 56, 29, 54, 52, 52, 23, 36, 45, 29, 59, 47, 27, 47, 48,\n",
       "       46, 65, 55, 31, 30, 53, 29, 24, 27, 30, 47, 58, 26, 30, 45, 46, 57,\n",
       "       57, 28, 47, 57, 60, 35, 32, 26, 25, 54, 22, 47, 62, 25, 43, 59, 24,\n",
       "       42, 52, 47, 57, 46, 51, 51, 62, 45, 28, 54, 61, 49, 31, 57, 27, 30,\n",
       "       50, 50, 52, 28, 49, 50, 49, 24, 45, 31, 53, 52, 26, 26, 58, 32, 33,\n",
       "       55, 61, 54, 28, 31, 51, 28, 52, 37, 49, 57, 49, 50, 32, 50, 58, 51,\n",
       "       57, 45, 52, 57, 31, 29, 60, 54, 56, 63, 30, 48, 63, 56, 49, 45, 47,\n",
       "       53, 30, 27, 24, 23, 25, 55, 49, 62, 54, 28, 25, 28, 32, 58, 27, 55,\n",
       "       43, 47, 64, 27, 25, 59, 50, 27, 29, 51, 54, 54, 23, 26, 37, 22, 26,\n",
       "       34, 41, 29, 33, 60, 29, 30, 28, 57, 59, 61, 27, 47, 60, 47, 62, 45,\n",
       "       42, 47, 28, 24, 48, 61, 41, 27, 31, 48, 63, 37, 31, 60, 27, 60, 28,\n",
       "       23, 64, 26, 48, 54, 26, 30])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.seed(6)\n",
    "\n",
    "sample_age = np.random.choice(a = population_age,\n",
    "                             size = 500)\n",
    "sample_age"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "2598401f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "42.388"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Calculating the mean of sample_data \n",
    "sample_age.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "fbf3785c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.614372000000003"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Calulate the difference between population_age mean and sample_age mean\n",
    "\n",
    "population_age.mean() - sample_age.mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a983ca06",
   "metadata": {},
   "source": [
    "* Our point estimate based on a sample of 500 individuals underestimates the true population mean by 0.6 years, but it is close. \n",
    "* This illustrates an important point: we can get a fairly accurate estimate of a large population by sampling a relatively small subset of individuals."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd50d3c4",
   "metadata": {},
   "source": [
    "Another point estimate that may be of interest is the proportion of the population that belongs to some category or subgroup. For example, we might like to know the race of each voter we poll, to get a sense of the overall demographics of the voter base. we can make a point estimate of this sort of proportion by taking a sample and then checking the ratio in the sample:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "bdffe551",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "other proportion estimate : \n",
      "0.099\n",
      "hispanic proportion estimate : \n",
      "0.192\n",
      "white proportion estimate : \n",
      "0.379\n",
      "black proportion estimate : \n",
      "0.231\n",
      "asian proportion estimate : \n",
      "0.099\n"
     ]
    }
   ],
   "source": [
    "random.seed(10)\n",
    "\n",
    "population_races = ([\"white\"]*100000) + ([\"black\"]*50000) +\\\n",
    "                   ([\"hispanic\"]*50000) + ([\"asian\"]*25000) +\\\n",
    "                   ([\"other\"]*25000)\n",
    "\n",
    "demo_sample = random.sample(population_races,1000)\n",
    "\n",
    "for race in set(demo_sample):\n",
    "    print(race + \" proportion estimate : \")\n",
    "    print(demo_sample.count(race)/1000)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f26eefd3",
   "metadata": {},
   "source": [
    "* Notice that the proportion estimates are close to the true underlying population proportions."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "45c1da6c",
   "metadata": {},
   "source": [
    "**Sampling Distributions and The Central Limit Theorem**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cd0e86d0",
   "metadata": {},
   "source": [
    "Many statistical procedures assume that data follows a normal distribution, because the normal distribution has nice properties like symmetricity and having the majority of the data clustered within a few standard deviations of the mean. Unfortunately, real world data is often not normally distributed and the distribution of a sample tends to mirror the distribution of the population. This means a sample taken from a population with a skewed distribution will also tend to be skewed. Let's investigate by plotting the data and sample we created earlier and by checking the skew:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "7d3b9372",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-0.12008483603917186\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x648 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plotting the population_age data uisng the histogram\n",
    "pd.DataFrame(population_age).hist(bins = 58,\n",
    "                                 range = (20.5,68.5),\n",
    "                                 figsize = (9,9))\n",
    "\n",
    "print(stats.skew(population_age))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "699feb17",
   "metadata": {},
   "source": [
    "* The distribution has low skewness, but the plot reveals the data is clearly not normal: instead of one symmetric bell curve, it has as bimodal distribution with two high density peaks. The sample we drew from this population should have roughly the same shape and skew:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "fd0b9514",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-0.056225282585406065\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x648 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plotting sample_data using the histogram\n",
    "\n",
    "pd.DataFrame(sample_age).hist(bins = 58,\n",
    "                             range = (20.5,68.5),\n",
    "                             figsize = (9,9))\n",
    "\n",
    "print(stats.skew(sample_age))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "69337ff1",
   "metadata": {},
   "source": [
    "* The sample has roughly the same shape as the underlying population. This suggests that we can't apply techniques that assume a normal distribution to this data set, since it is not normal. In reality, we can, thanks the central limit theorem.\n",
    "\n",
    "The central limit theorem is one of the most important results of probability theory and serves as the foundation of many methods of statistical analysis. At a high level, the theorem states the distribution of many sample means, known as a sampling distribution, will be normally distributed. This rule holds even if the underlying distribution itself is not normally distributed. As a result we can treat the sample mean as if it were drawn normal distribution.\n",
    "\n",
    "To illustrate, let's create a sampling distribution by taking 200 samples from our population and then making 200 point estimates of the mean:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "ec8d12b4",
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(12)\n",
    "\n",
    "point_estimates = [] # creating a list to hold the value of the point eastimate of the 200 samples\n",
    "\n",
    "for i in range(200):\n",
    "    sample = np.random.choice(a = population_age,  # generating random sample from the population_age\n",
    "                         size = 500)\n",
    "    point_estimates.append(sample.mean())  # putting the sample mean into the point_estimates list "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "d41ef0c1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[43.416,\n",
       " 43.1,\n",
       " 43.156,\n",
       " 43.194,\n",
       " 44.164,\n",
       " 42.856,\n",
       " 42.832,\n",
       " 43.05,\n",
       " 42.59,\n",
       " 42.732,\n",
       " 43.362,\n",
       " 43.756,\n",
       " 42.826,\n",
       " 43.09,\n",
       " 42.362,\n",
       " 42.79,\n",
       " 42.666,\n",
       " 42.026,\n",
       " 43.456,\n",
       " 43.264,\n",
       " 43.578,\n",
       " 43.212,\n",
       " 43.484,\n",
       " 43.142,\n",
       " 43.084,\n",
       " 42.018,\n",
       " 43.12,\n",
       " 43.192,\n",
       " 43.244,\n",
       " 43.682,\n",
       " 42.118,\n",
       " 43.792,\n",
       " 42.564,\n",
       " 42.674,\n",
       " 42.522,\n",
       " 43.578,\n",
       " 43.58,\n",
       " 42.56,\n",
       " 42.774,\n",
       " 43.048,\n",
       " 42.408,\n",
       " 42.62,\n",
       " 43.14,\n",
       " 42.68,\n",
       " 43.918,\n",
       " 44.524,\n",
       " 42.636,\n",
       " 42.926,\n",
       " 43.332,\n",
       " 43.168,\n",
       " 42.49,\n",
       " 43.486,\n",
       " 42.77,\n",
       " 43.41,\n",
       " 42.704,\n",
       " 43.928,\n",
       " 43.282,\n",
       " 42.532,\n",
       " 42.586,\n",
       " 42.374,\n",
       " 42.878,\n",
       " 43.362,\n",
       " 42.78,\n",
       " 42.282,\n",
       " 42.972,\n",
       " 43.918,\n",
       " 43.56,\n",
       " 43.88,\n",
       " 43.226,\n",
       " 42.972,\n",
       " 42.484,\n",
       " 43.242,\n",
       " 43.246,\n",
       " 43.102,\n",
       " 42.5,\n",
       " 43.954,\n",
       " 42.296,\n",
       " 43.278,\n",
       " 43.182,\n",
       " 43.28,\n",
       " 42.57,\n",
       " 43.094,\n",
       " 42.52,\n",
       " 42.2,\n",
       " 44.246,\n",
       " 42.566,\n",
       " 42.376,\n",
       " 43.47,\n",
       " 43.126,\n",
       " 43.328,\n",
       " 42.868,\n",
       " 41.69,\n",
       " 42.81,\n",
       " 42.992,\n",
       " 43.564,\n",
       " 43.314,\n",
       " 43.332,\n",
       " 42.872,\n",
       " 41.466,\n",
       " 43.488,\n",
       " 42.732,\n",
       " 42.246,\n",
       " 42.96,\n",
       " 41.448,\n",
       " 43.188,\n",
       " 43.344,\n",
       " 42.582,\n",
       " 42.992,\n",
       " 42.914,\n",
       " 42.624,\n",
       " 43.752,\n",
       " 43.224,\n",
       " 43.086,\n",
       " 43.438,\n",
       " 42.652,\n",
       " 43.78,\n",
       " 43.018,\n",
       " 43.64,\n",
       " 44.5,\n",
       " 43.792,\n",
       " 43.15,\n",
       " 43.154,\n",
       " 43.72,\n",
       " 43.466,\n",
       " 42.658,\n",
       " 42.808,\n",
       " 42.94,\n",
       " 43.064,\n",
       " 42.874,\n",
       " 42.748,\n",
       " 42.052,\n",
       " 42.432,\n",
       " 42.422,\n",
       " 43.182,\n",
       " 42.786,\n",
       " 41.968,\n",
       " 42.108,\n",
       " 43.23,\n",
       " 42.706,\n",
       " 44.354,\n",
       " 43.768,\n",
       " 43.702,\n",
       " 43.93,\n",
       " 42.53,\n",
       " 43.004,\n",
       " 42.176,\n",
       " 42.894,\n",
       " 43.492,\n",
       " 42.276,\n",
       " 42.622,\n",
       " 42.782,\n",
       " 43.958,\n",
       " 43.536,\n",
       " 42.786,\n",
       " 43.468,\n",
       " 43.86,\n",
       " 42.652,\n",
       " 43.472,\n",
       " 43.218,\n",
       " 43.038,\n",
       " 42.924,\n",
       " 42.274,\n",
       " 42.23,\n",
       " 42.498,\n",
       " 43.238,\n",
       " 42.92,\n",
       " 43.922,\n",
       " 43.494,\n",
       " 42.278,\n",
       " 44.74,\n",
       " 43.164,\n",
       " 42.78,\n",
       " 42.952,\n",
       " 42.408,\n",
       " 42.626,\n",
       " 43.268,\n",
       " 43.4,\n",
       " 43.416,\n",
       " 44.13,\n",
       " 43.06,\n",
       " 43.09,\n",
       " 43.508,\n",
       " 43.548,\n",
       " 43.222,\n",
       " 41.854,\n",
       " 42.918,\n",
       " 42.64,\n",
       " 42.922,\n",
       " 43.46,\n",
       " 43.506,\n",
       " 42.944,\n",
       " 43.044,\n",
       " 43.596,\n",
       " 42.346,\n",
       " 43.39,\n",
       " 43.358,\n",
       " 41.508,\n",
       " 42.438,\n",
       " 43.09,\n",
       " 42.446]"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Looking at the values of the list point_estimates \n",
    "point_estimates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "06f7ad57",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>43.416</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>43.100</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>43.156</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>43.194</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>44.164</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>195</th>\n",
       "      <td>43.358</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>196</th>\n",
       "      <td>41.508</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>197</th>\n",
       "      <td>42.438</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>198</th>\n",
       "      <td>43.090</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>199</th>\n",
       "      <td>42.446</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>200 rows × 1 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "          0\n",
       "0    43.416\n",
       "1    43.100\n",
       "2    43.156\n",
       "3    43.194\n",
       "4    44.164\n",
       "..      ...\n",
       "195  43.358\n",
       "196  41.508\n",
       "197  42.438\n",
       "198  43.090\n",
       "199  42.446\n",
       "\n",
       "[200 rows x 1 columns]"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Convert the above result into the dataframe \n",
    "\n",
    "point_estimates = pd.DataFrame(point_estimates)\n",
    "point_estimates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "07bb2353",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:ylabel='Density'>"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x648 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot the above result \n",
    "\n",
    "point_estimates.plot(kind = 'density',\n",
    "                    figsize = (9,9))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d45bec2c",
   "metadata": {},
   "source": [
    "* The sampling distribution appears to be roughly normal, despite the bimodal population distribution that the samples were drawn from. \n",
    "* In addition, the mean of the sampling distribution approaches the true population mean:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "6815e00f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0   -0.029138\n",
       "dtype: float64"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Calculate the difference between population_age mean and point_estimates age mean\n",
    "\n",
    "population_age.mean() - point_estimates.mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f58aab21",
   "metadata": {},
   "source": [
    "* The more samples we take, the better our estimate of the population parameter is likely to be."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "72660699",
   "metadata": {},
   "source": [
    "**Confidence Intervals**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "05cc650a",
   "metadata": {},
   "source": [
    "A point estimate can give you a rough idea of a population parameter like the mean, but estimates are prone to error and taking multiple samples to get improved estimates may not be feasible. A confidence interval is a range of values above and below a point estimate that captures the true population parameter at some predetermined confidence level. For example, if you want to have a 95% chance of capturing the true population parameter with a point estimate and a corresponding confidence interval, you'd set your confidence level to 95%. Higher confidence levels result in a wider confidence intervals.\n",
    "\n",
    "\n",
    "Calculate a confidence interval by taking a point estimate and then adding and subtracting a margin of error to create a range. Margin of error is based on your desired confidence level, the spread of the data and the size of your sample. The way you calculate the margin of error depends on whether you know the standard deviation of the population or not.\n",
    "\n",
    "\n",
    "If you know the standard deviation of the population, the margin of error is equal to:\n",
    "\n",
    "z * (sigma/sqrt(n))\n",
    "\n",
    "\n",
    "Where σ (sigma) is the population standard deviation, n is sample size, and z is a number known as the z-critical value. The z-critical value is the number of standard deviations you'd have to go from the mean of the normal distribution to capture the proportion of the data associated with the desired confidence level. For instance, we know that roughly 95% of the data in a normal distribution lies within 2 standard deviations of the mean, so we could use 2 as the z-critical value for a 95% confidence interval (although it is more exact to get z-critical values with stats.norm.ppf().).\n",
    "\n",
    "\n",
    "Let's calculate a 95% confidence for our mean point estimate:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "28c59fdc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "z critical value: \n",
      "1.959963984540054\n",
      "cofidence interval : \n",
      "(41.70306406882683, 43.34293593117317)\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(10)\n",
    "\n",
    "sample_size = 1000\n",
    "sample = np.random.choice(a = population_age,\n",
    "                         size = sample_size)\n",
    "sample_mean = sample.mean()\n",
    "\n",
    "# get the z-critical value \n",
    "\n",
    "z_critical = stats.norm.ppf(q = 0.975)\n",
    "\n",
    "print('z critical value: ')\n",
    "print(z_critical)\n",
    "\n",
    "\n",
    "#  calculate the populationn standard deviation\n",
    "\n",
    "pop_std = population_age.std()\n",
    "\n",
    "margin_of_error = z_critical * (pop_std/math.sqrt(sample_size))\n",
    "\n",
    "#  calculate the confidence interval\n",
    "\n",
    "confidence_interval = (sample_mean - margin_of_error,\n",
    "                      sample_mean + margin_of_error)\n",
    "\n",
    "print('cofidence interval : ')\n",
    "print(confidence_interval)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1cb4a611",
   "metadata": {},
   "source": [
    "* Note: We use stats.norm.ppf(q = 0.975) to get the desired z-critical value instead of q = 0.95 because the distribution has two tails.\n",
    "\n",
    "* Notice that the confidence interval we calculated captures the true population mean of 43.0023."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5719a3bd",
   "metadata": {},
   "source": [
    "Let's create several confidence intervals and plot them to get a better sense of what it means to \"capture\" the true mean:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "6742c913",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "z_critical : \n",
      "1.959963984540054\n",
      "confidence interval : \n",
      "(41.70306406882683, 43.34293593117317)\n",
      "z_critical : \n",
      "1.959963984540054\n",
      "confidence interval : \n",
      "(42.23806406882683, 43.87793593117317)\n",
      "z_critical : \n",
      "1.959963984540054\n",
      "confidence interval : \n",
      "(41.84506406882683, 43.48493593117317)\n",
      "z_critical : \n",
      "1.959963984540054\n",
      "confidence interval : \n",
      "(41.69606406882683, 43.33593593117317)\n",
      "z_critical : \n",
      "1.959963984540054\n",
      "confidence interval : \n",
      "(42.67506406882683, 44.31493593117317)\n",
      "z_critical : \n",
      "1.959963984540054\n",
      "confidence interval : \n",
      "(42.26606406882683, 43.90593593117317)\n",
      "z_critical : \n",
      "1.959963984540054\n",
      "confidence interval : \n",
      "(42.40006406882683, 44.03993593117317)\n",
      "z_critical : \n",
      "1.959963984540054\n",
      "confidence interval : \n",
      "(42.16906406882683, 43.80893593117317)\n",
      "z_critical : \n",
      "1.959963984540054\n",
      "confidence interval : \n",
      "(41.90106406882683, 43.540935931173166)\n",
      "z_critical : \n",
      "1.959963984540054\n",
      "confidence interval : \n",
      "(41.38606406882683, 43.02593593117317)\n",
      "z_critical : \n",
      "1.959963984540054\n",
      "confidence interval : \n",
      "(42.86606406882683, 44.50593593117317)\n",
      "z_critical : \n",
      "1.959963984540054\n",
      "confidence interval : \n",
      "(41.84106406882683, 43.48093593117317)\n",
      "z_critical : \n",
      "1.959963984540054\n",
      "confidence interval : \n",
      "(42.35006406882683, 43.98993593117317)\n",
      "z_critical : \n",
      "1.959963984540054\n",
      "confidence interval : \n",
      "(41.55506406882683, 43.19493593117317)\n",
      "z_critical : \n",
      "1.959963984540054\n",
      "confidence interval : \n",
      "(41.93506406882683, 43.57493593117317)\n",
      "z_critical : \n",
      "1.959963984540054\n",
      "confidence interval : \n",
      "(42.27206406882683, 43.91193593117317)\n",
      "z_critical : \n",
      "1.959963984540054\n",
      "confidence interval : \n",
      "(41.86606406882683, 43.50593593117317)\n",
      "z_critical : \n",
      "1.959963984540054\n",
      "confidence interval : \n",
      "(41.58206406882683, 43.22193593117317)\n",
      "z_critical : \n",
      "1.959963984540054\n",
      "confidence interval : \n",
      "(42.20806406882683, 43.84793593117317)\n",
      "z_critical : \n",
      "1.959963984540054\n",
      "confidence interval : \n",
      "(41.70506406882683, 43.34493593117317)\n",
      "z_critical : \n",
      "1.959963984540054\n",
      "confidence interval : \n",
      "(42.65906406882683, 44.29893593117317)\n",
      "z_critical : \n",
      "1.959963984540054\n",
      "confidence interval : \n",
      "(42.15906406882683, 43.79893593117317)\n",
      "z_critical : \n",
      "1.959963984540054\n",
      "confidence interval : \n",
      "(42.12006406882683, 43.75993593117317)\n",
      "z_critical : \n",
      "1.959963984540054\n",
      "confidence interval : \n",
      "(42.30906406882683, 43.94893593117317)\n",
      "z_critical : \n",
      "1.959963984540054\n",
      "confidence interval : \n",
      "(42.41306406882683, 44.05293593117317)\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(10)\n",
    "\n",
    "sample_size = 1000\n",
    "\n",
    "sample_means = []\n",
    "confidence_intervals = []\n",
    "\n",
    "for i in range(25):\n",
    "    \n",
    "    sample = np.random.choice(a = population_age,\n",
    "                             size = sample_size)\n",
    "    sample_mean = sample.mean()\n",
    "    sample_means.append(sample_mean)\n",
    "\n",
    "    # get the critical value \n",
    "    z_critcal = stats.norm.ppf(q = 0.975)\n",
    "\n",
    "    print('z_critical : ')\n",
    "    print(z_critical)\n",
    "\n",
    "    pop_std = population_age.std()\n",
    "    \n",
    "    stats.norm.ppf(q = 0.025)\n",
    "\n",
    "    # calculate the margin of the error \n",
    "\n",
    "    margin_of_error = z_critical * (pop_std/math.sqrt(sample_size))\n",
    "\n",
    "    # calculate the confidence interval\n",
    "\n",
    "    confidence_interval = (sample_mean -margin_of_error ,\n",
    "                          sample_mean + margin_of_error)\n",
    "    \n",
    "    confidence_intervals.append(confidence_interval)\n",
    "    print('confidence interval : ')\n",
    "    print(confidence_interval)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "56ad9e31",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x648 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot the aboove results \n",
    "\n",
    "plt.figure(figsize=(9,9))\n",
    "\n",
    "plt.errorbar(x=np.arange(0.1, 25, 1), \n",
    "             y=sample_means, \n",
    "             yerr=[(top-bot)/2 for top,bot in confidence_intervals],\n",
    "             fmt='o')\n",
    "\n",
    "plt.hlines(xmin=0, xmax=25,\n",
    "           y=43.0023, \n",
    "           linewidth=2.0,\n",
    "           color=\"red\");"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0dbeaa33",
   "metadata": {},
   "source": [
    "Notice that in the plot above, all but one of the 95% confidence intervals overlap the red line marking the true mean. This is to be expected: since a 95% confidence interval captures the true mean 95% of the time, we'd expect our interval to miss the true mean 5% of the time.\n",
    "\n",
    "If we don't know the standard deviation of the population, we have to use the standard deviation of our sample as a stand in when creating confidence intervals. Since the sample standard deviation may not match the population parameter the interval will have more error when you don't know the population standard deviation. To account for this error, we use what's known as a t-critical value instead of the z-critical value. \n",
    "\n",
    "The t-critical value is drawn from what's known as a t-distribution--a distribution that closely resembles the normal distribution but that gets wider and wider as the sample size falls. The t-distribution is available in scipy.stats with the nickname \"t\" so we can get t-critical values with stats.t.ppf()."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ea70375",
   "metadata": {},
   "source": [
    "Let's take a new, smaller sample and then create a confidence interval without the population standard deviation, using the t-distribution:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "478fbfba",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "t critical value : \n",
      "2.0638985616280205\n",
      "margin of the error : \n",
      "5.122887262989392\n",
      "confidence interval : \n",
      "(37.75711273701061, 48.0028872629894)\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(10)\n",
    "\n",
    "sample_size = 25\n",
    "\n",
    "sample = np.random.choice(a = population_age,\n",
    "                         size = sample_size)\n",
    "sample_mean = sample.mean()\n",
    "\n",
    "# get the t critical value \n",
    "\n",
    "t_critical = stats.t.ppf(q = 0.975,\n",
    "                        df = 24)\n",
    "\n",
    "print('t critical value : ')\n",
    "print(t_critical)\n",
    "\n",
    "\n",
    "sample_stdev = sample.std()\n",
    "\n",
    "# calculate the margin of the error \n",
    "\n",
    "margin_of_error = t_critical * (sample_stdev/math.sqrt(sample_size))\n",
    "\n",
    "print('margin of the error : ')\n",
    "print(margin_of_error)\n",
    "\n",
    "# calculate the confidence interval \n",
    "\n",
    "confidence_interval = (sample_mean - margin_of_error,\n",
    "                      sample_mean + margin_of_error)\n",
    "\n",
    "print('confidence interval : ')\n",
    "print(confidence_interval)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "57eec9be",
   "metadata": {},
   "source": [
    "* Note: when using the t-distribution, we have to supply the degrees of freedom (df). For this type of test, the degrees of freedom is equal to the sample size minus 1. If we have a large sample size, the t-distribution approaches the normal distribution."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "54e52e5e",
   "metadata": {},
   "source": [
    "* Notice that the t-critical value is larger than the z-critical value we used for 95% confidence interval. This allows the confidence interval to cast a larger net to make up for the variability caused by using the sample standard deviation in place of the population standard deviation. The end result is a much wider confidence interval (an interval with a larger margin of error.).\n",
    "\n",
    "* If we have a large sample, the t-critical value will approach the z-critical value so there is little difference between using the normal distribution vs. the t-distribution:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "01fb7b99",
   "metadata": {},
   "source": [
    "Instead of calculating a confidence interval for a mean point estimate by hand, we can calculate it using the Python function stats.t.interval():"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "8f0a45fd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(37.75711273701061, 48.0028872629894)"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sigma = sample_stdev/math.sqrt(sample_size)  # Standard deviation estimate\n",
    "\n",
    "stats.t.interval(alpha = 0.95,  # confidence interval\n",
    "                df = 24,  # degree of freedom\n",
    "                loc = sample_mean, # sample mean\n",
    "                scale = sigma) # standardd deviation estimate"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b4f94aea",
   "metadata": {},
   "source": [
    "We can also make a confidence interval for a point estimate of a population proportion. In this case, the margin of error equals:\n",
    "\n",
    "z * sqrt(p(p-1)/n)\n",
    " \n",
    "Where z is the z-critical value for our confidence level, p is the point estimate of the population proportion and n is the sample size"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc8de9c3",
   "metadata": {},
   "source": [
    "### Conclusion:\n",
    "* Estimating population parameters through sampling is a simple, yet powerful form of inference. \n",
    "* Point estimates combined with error margins let us create confidence intervals that capture the true population parameter with high probability."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ff5b0112",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}