07_module.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Measures of Variability"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Range\n",
    "\n",
    "The Range is the difference between the lowest and highest values.\n",
    "\n",
    "Example: In {4, 6, 9, 3, 7} the lowest value is 3, and the highest is 9.\n",
    "\n",
    "So the range is 9 − 3 = 6."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### The Range can be misleading\n",
    "\n",
    "The range can sometimes be misleading when there are extremely high or low values.\n",
    "\n",
    "Example: In {8, 11, 5, 9, 7, 6, 3616}:\n",
    "\n",
    "+ the lowest value is 5,\n",
    "+ and the highest is 3616,\n",
    "\n",
    "So the range is 3616 − 5 = 3611.\n",
    "\n",
    "The single value of 3616 makes the range large, but most values are around 10."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Interquartile Range\n",
    "\n",
    "The interquartile range (IQR) contains the second and third quartiles, or the middle half of your data set. Whereas the range gives you the spread of the whole data set, the interquartile range gives you the range of the middle half of a data set"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The interquartile range is not vulnerable to outliers, and whatever the distribution of the data, we know that 50% of them will lie within IQR"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tasks\n",
    "\n",
    "Write a function that takes in an array of numerical values and returns the range of that array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_range(array):   \n",
    "    return max(array) - min(array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "\n",
    "houses = pd.read_table('data/AmesHousing_1.txt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "742211"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "find_range(houses['SalePrice'])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Standard Deviation\n",
    "\n",
    "Standard deviation is a statistic that measures the dispersion of a dataset relative to its mean and is calculated as the square root of the variance. The standard deviation is calculated as the square root of variance by determining each data point's deviation relative to the mean.\n",
    "\n",
    "If the data points are further from the mean, there is a higher deviation within the data set; thus, the more spread out the data, the higher the standard deviation. "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "Write a function that takes in a numerical array and returns the mean absolute deviation. Inside the function:\n",
    "\n",
    "+ Compute the mean of the array.\n",
    "+ Loop through the values of the array. For each iteration:\n",
    "\n",
    "    + Compute the absolute distance (deviation). You can use the `abs()` function.\n",
    "    + Append the absolute distance to a list.\n",
    "\n",
    "+ Return the mean of the list containing all the absolute distances.\n",
    "\n",
    "Compute the mean absolute deviation of distribution C  and assign the result to a variable named mad.\n",
    "\n",
    "+ Is the result considerably less than 20 but greater than 0, as we expected?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "C = [1,1,1,1,1,1,1,1,1,21]\n",
    "\n",
    "def mean_absolute_deviation(array):  \n",
    "    reference_point = sum(array) / len(array) \n",
    "    \n",
    "    distances = []    \n",
    "    \n",
    "    for value in array:     \n",
    "        absolute_distance = abs(value - reference_point)\n",
    "        distances.append(absolute_distance)  \n",
    "        return sum(distances) / len(distances)\n",
    " \n",
    "mad = mean_absolute_deviation(C)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variance\n",
    "\n",
    "The term variance refers to a statistical measurement of the spread between numbers in a data set. More specifically, variance measures how far each number in the set is from the mean (average), and thus from every other number in the set.\n",
    "\n",
    "Write a function that takes in a numerical array and returns the variance of that array. Inside the function:\n",
    "\n",
    "+ Compute the mean of the array.\n",
    "+ Loop through the values of the array. For each iteration:\n",
    "    + Compute the squared distance (squared deviation).\n",
    "    + Append the squared distance to a list.\n",
    "+ Return the mean of the list of squared distances.\n",
    "\n",
    "Compute the variance of distribution C, and assign the result to a variable named variance_C.\n",
    "\n",
    "+ Is the result considerably less than 20 but greater than 0, as we expected?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# not working correctly?\n",
    "def calc_variance(array):  \n",
    "    reference_point = sum(array) / len(array) \n",
    "    \n",
    "    distances = []    \n",
    "    \n",
    "    for value in array:     \n",
    "        absolute_distance = abs(value - reference_point)\n",
    "        square_distance = absolute_distance**2\n",
    "        distances.append(square_distance)  \n",
    "        return sum(distances)\n",
    " \n",
    "my_var =calc_variance(C)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A function for standard deviation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import sqrt\n",
    "\n",
    "def standard_deviation(array):\n",
    "    reference_point = sum(array) / len(array)\n",
    "    \n",
    "    distances = []\n",
    "    for value in array:\n",
    "        squared_distance = (value - reference_point)**2\n",
    "        distances.append(squared_distance)\n",
    "        \n",
    "    variance = sum(distances) / len(distances)\n",
    "    \n",
    "    return sqrt(variance)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6.0"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "standard_deviation(C)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " standard deviation of the SalePrice variable should give us a picture about the diversity of prices on the real estate market.\n",
    "\n",
    "+ Find the year with the greatest variability of prices and assign the answer as an integer to the variable greatest_variability.\n",
    "+ Find the year with the lowest variability of prices and assign the answer as an integer to the variable lowest_variability.\n",
    "+ Use the function you wrote in the previous screen to measure the standard deviation of each year.\n",
    "+ You can find information about the years of sale in the Yr Sold column."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "years = {}\n",
    "\n",
    "for year in houses['Yr Sold'].unique():\n",
    "    year_segment = houses[houses['Yr Sold'] == year]\n",
    "    st_dev = standard_deviation(year_segment['SalePrice'])\n",
    "    years[year] = st_dev\n",
    "\n",
    "# Get years of max and min variability\n",
    "greatest_variability = max(years, key = years.get) # outputs directly the year with the maximum variability\n",
    "lowest_variability = min(years, key = years.get) # outputs directly the year with the minimum variability"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### sd: a measure of spread\n",
    "\n",
    "Another way to understand standard deviation is as a measure of spread in a distribution — values in a distribution can be more or less spread. We took four random samples of 50 sample points each from the SalePrice distribution, and plotted their histograms to visualize the spread for each sample:\n",
    "\n",
    "![Measuring spread](img/s2m4_spreads.svg)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "According to our visual estimates, sample 2 has the biggest spread, while the other three samples have a similar spread, with sample 3 seemingly having the lowest spread. The standard deviations of these four distributions fit our visual estimates fairly well:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sample 1: 81785.0811515768\n",
      "Sample 2: 100370.62998094413\n",
      "Sample 3: 60676.038515710636\n",
      "Sample 4: 64436.40016450328\n"
     ]
    }
   ],
   "source": [
    "for i in range(1,5):\n",
    "    sample = houses['SalePrice'].sample(50, random_state = i)\n",
    "    # we used the same random states for the samples in the graph above\n",
    "    st_dev = standard_deviation(sample)\n",
    "    print('Sample ' + str(i) + ': ' + str(st_dev))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Generate 4 random samples for \"Year Built\" and discuss their distribution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sample 1: 29.239589600403075\n",
      "Sample 2: 32.466234767832255\n",
      "Sample 3: 29.649344006233928\n",
      "Sample 4: 28.253141418256483\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "plt.figure()\n",
    "for i in range(1,5):\n",
    "    sample = houses['Year Built'].sample(50, random_state = i)\n",
    "    # we used the same random states for the samples in the graph above\n",
    "    st_dev = standard_deviation(sample)\n",
    "    sample.plot.hist() \n",
    "    plt.subplot(2,2,i)\n",
    "    print('Sample ' + str(i) + ': ' + str(st_dev))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sample Standard Deviation\n",
    " Let's consider the data we have for SalePrice a population and sample it 5000 times. For each of the 5000 iterations of a for loop:\n",
    "    \n",
    "  + Sample 10 data points from the SalePrice variable using the Series.sample() method.\n",
    "        + The random_state of Series.sample() should be 0 for the first iteration, 1 for the second iteration, 2 for the third, and so on.\n",
    "  + Compute the standard deviation of the sample using the standard_deviation() function.\n",
    "  + Append the standard deviation to a list that will eventually store all the 5000 sample standard deviations.\n",
    "\n",
    "Generate a histogram using `plt.hist()` to visualize the distribution of the 5000 sample standard deviations.\n",
    "\n",
    "Draw a vertical line using `plt.axvline()` to mark the population standard deviation.\n",
    "\n",
    "Examine the histogram and try to figure out whether most sample standard deviations cluster above or below the population standard deviation, or right at the center of it.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.lines.Line2D at 0x7f081a575940>"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "st_devs = []\n",
    "\n",
    "for i in range(5000):\n",
    "    sample = houses['SalePrice'].sample(10, random_state = i)\n",
    "    st_dev = standard_deviation(sample)\n",
    "    st_devs.append(st_dev)\n",
    "    \n",
    "plt.hist(st_devs)\n",
    "plt.axvline(standard_deviation(houses['SalePrice']))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Bessel's Correction\n",
    "\n",
    "we plotted the histogram of 5000 sample standard deviations and compared them against the population standard deviation. Notice that most sample standard deviations are clustered below the population standard deviation:\n",
    "\n",
    "![Cluster](img/s2m4_cluster.svg)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This suggests that the sample standard deviation usually underestimates the population standard deviation. We can also see that the mean of the 5000 sample standard deviations is below the population standard deviation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "71303.64762671624"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(st_devs) / 5000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "79873.05865192247"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "standard_deviation(houses['SalePrice'])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So we can say that the sample standard deviation underestimates on average the population standard deviation. Some sample standard deviations are lower than the population standard deviation, some are greater, some may even be equal to the population standard deviation, but on average the sample standard deviation is lower than the population standard deviation."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can get a good intuition for why the sample standard deviation underestimates if we think in terms of distribution spread. When we sample a population, it's generally more likely to get a sample with a spread that's lower than the population's spread. This generally translates to a lower standard deviation than in the population.\n",
    "\n",
    "![less variance](img/s2m4_less_var.svg)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Getting a sample with a higher standard deviation than in the population is possible, but this is less likely. This is mostly specific to samples with a high spread and no clusters.\n",
    "\n",
    "![more variance](img/s2m4_more_var.svg)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll decrease by 1 the denominator in the sample standard deviation formula to account for the underestimation"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Implement Bessel's correction in standard deviation function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.lines.Line2D at 0x7f081987c400>"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def standard_deviation(array):\n",
    "    reference_point = sum(array) / len(array)\n",
    "    \n",
    "    distances = []\n",
    "    for value in array:\n",
    "        squared_distance = (value - reference_point)**2\n",
    "        distances.append(squared_distance)\n",
    "    \n",
    "    variance = sum(distances) / (len(distances) - 1)\n",
    "    \n",
    "    return sqrt(variance)\n",
    "\n",
    "st_devs = []\n",
    "\n",
    "for i in range(5000):\n",
    "    sample = houses['SalePrice'].sample(10, random_state = i)\n",
    "    st_dev = standard_deviation(sample)\n",
    "    st_devs.append(st_dev)\n",
    "    \n",
    "plt.hist(st_devs)\n",
    "plt.axvline(standard_deviation(houses['SalePrice']))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "+ Use the `Series.std()` method to compute the sample standard deviation for the SalePrice column. You can use the ddof parameter to choose between n and n−1. Save the result to a variable named pandas_stdev.\n",
    "\n",
    "+ Use the `numpy.std()` function to compute the sample standard deviation for the SalePrice column. You can use the ddof parameter to choose between nand n−1.   Save the result to a variable named numpy_stdev.\n",
    "\n",
    "+ Compare pandas_stdev with numpy_stdev using the == operator. Assign the result of the comparison to a variable named equal_stdevs.\n",
    "\n",
    "+ Use the `Series.var()` method to compute the sample variance for the SalePrice column. Assign the result to pandas_var.\n",
    "\n",
    "+ Use the `numpy.var()` function to compute the sample variance for the SalePrice column. Assign the result to numpy_var.\n",
    "\n",
    "+ Compare pandas_var with numpy_var using the == operator. Assign the result of the comparison to a variable named equal_vars."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "sample = houses.sample(100, random_state = 1)\n",
    "from numpy import std, var\n",
    "pandas_stdev = sample['SalePrice'].std(ddof = 1) # default ddof = 1\n",
    "numpy_stdev = std(sample['SalePrice'], ddof = 1) # default ddof = 0\n",
    "equal_stdevs = pandas_stdev == numpy_stdev\n",
    "\n",
    "pandas_var = sample['SalePrice'].var(ddof = 1) # default ddof = 1\n",
    "numpy_var = var(sample['SalePrice'], ddof = 1) #default ddof = 0\n",
    "equal_vars = pandas_var == numpy_var"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "equal_vars"
   ]
  }
 ],
 "metadata": {
  "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.10.9"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "0e1f169f5711a90ff09b1ce155e8835a9bac5ac4c242468736f19be364069406"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}