inheritance_probability_distribution.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Inheritance with the Gaussian Class\n",
    "\n",
    "To give another example of inheritance, take a look at the code in this Jupyter notebook. The Gaussian distribution code is refactored into a generic Distribution class and a Gaussian distribution class. Read through the code in this Jupyter notebook to see how the code works.\n",
    "\n",
    "The Distribution class takes care of the initialization and the read_data_file method. Then the rest of the Gaussian code is in the Gaussian class. You'll later use this Distribution class in an exercise at the end of the lesson.\n",
    "\n",
    "Run the code in each cell of this Jupyter notebook. This is a code demonstration, so you do not need to write any code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Distribution:\n",
    "    \n",
    "    def __init__(self, mu=0, sigma=1):\n",
    "    \n",
    "        \"\"\" Generic distribution class for calculating and \n",
    "        visualizing a probability distribution.\n",
    "    \n",
    "        Attributes:\n",
    "            mean (float) representing the mean value of the distribution\n",
    "            stdev (float) representing the standard deviation of the distribution\n",
    "            data_list (list of floats) a list of floats extracted from the data file\n",
    "            \"\"\"\n",
    "        \n",
    "        self.mean = mu\n",
    "        self.stdev = sigma\n",
    "        self.data = []\n",
    "\n",
    "\n",
    "    def read_data_file(self, file_name):\n",
    "    \n",
    "        \"\"\"Function to read in data from a txt file. The txt file should have\n",
    "        one number (float) per line. The numbers are stored in the data attribute.\n",
    "                \n",
    "        Args:\n",
    "            file_name (string): name of a file to read from\n",
    "        \n",
    "        Returns:\n",
    "            None\n",
    "        \n",
    "        \"\"\"\n",
    "            \n",
    "        with open(file_name) as file:\n",
    "            data_list = []\n",
    "            line = file.readline()\n",
    "            while line:\n",
    "                data_list.append(int(line))\n",
    "                line = file.readline()\n",
    "        file.close()\n",
    "    \n",
    "        self.data = data_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "class Gaussian(Distribution):\n",
    "    \"\"\" Gaussian distribution class for calculating and \n",
    "    visualizing a Gaussian distribution.\n",
    "    \n",
    "    Attributes:\n",
    "        mean (float) representing the mean value of the distribution\n",
    "        stdev (float) representing the standard deviation of the distribution\n",
    "        data_list (list of floats) a list of floats extracted from the data file\n",
    "            \n",
    "    \"\"\"\n",
    "    def __init__(self, mu=0, sigma=1):\n",
    "        \n",
    "        Distribution.__init__(self, mu, sigma)\n",
    "    \n",
    "        \n",
    "    \n",
    "    def calculate_mean(self):\n",
    "    \n",
    "        \"\"\"Function to calculate the mean of the data set.\n",
    "        \n",
    "        Args: \n",
    "            None\n",
    "        \n",
    "        Returns: \n",
    "            float: mean of the data set\n",
    "    \n",
    "        \"\"\"\n",
    "                    \n",
    "        avg = 1.0 * sum(self.data) / len(self.data)\n",
    "        \n",
    "        self.mean = avg\n",
    "        \n",
    "        return self.mean\n",
    "\n",
    "\n",
    "\n",
    "    def calculate_stdev(self, sample=True):\n",
    "\n",
    "        \"\"\"Function to calculate the standard deviation of the data set.\n",
    "        \n",
    "        Args: \n",
    "            sample (bool): whether the data represents a sample or population\n",
    "        \n",
    "        Returns: \n",
    "            float: standard deviation of the data set\n",
    "    \n",
    "        \"\"\"\n",
    "\n",
    "        if sample:\n",
    "            n = len(self.data) - 1\n",
    "        else:\n",
    "            n = len(self.data)\n",
    "    \n",
    "        mean = self.calculate_mean()\n",
    "    \n",
    "        sigma = 0\n",
    "    \n",
    "        for d in self.data:\n",
    "            sigma += (d - mean) ** 2\n",
    "        \n",
    "        sigma = math.sqrt(sigma / n)\n",
    "    \n",
    "        self.stdev = sigma\n",
    "        \n",
    "        return self.stdev\n",
    "        \n",
    "        \n",
    "        \n",
    "    def plot_histogram(self):\n",
    "        \"\"\"Function to output a histogram of the instance variable data using \n",
    "        matplotlib pyplot library.\n",
    "        \n",
    "        Args:\n",
    "            None\n",
    "            \n",
    "        Returns:\n",
    "            None\n",
    "        \"\"\"\n",
    "        plt.hist(self.data)\n",
    "        plt.title('Histogram of Data')\n",
    "        plt.xlabel('data')\n",
    "        plt.ylabel('count')\n",
    "        \n",
    "        \n",
    "        \n",
    "    def pdf(self, x):\n",
    "        \"\"\"Probability density function calculator for the gaussian distribution.\n",
    "        \n",
    "        Args:\n",
    "            x (float): point for calculating the probability density function\n",
    "            \n",
    "        \n",
    "        Returns:\n",
    "            float: probability density function output\n",
    "        \"\"\"\n",
    "        \n",
    "        return (1.0 / (self.stdev * math.sqrt(2*math.pi))) * math.exp(-0.5*((x - self.mean) / self.stdev) ** 2)\n",
    "        \n",
    "\n",
    "    def plot_histogram_pdf(self, n_spaces = 50):\n",
    "\n",
    "        \"\"\"Function to plot the normalized histogram of the data and a plot of the \n",
    "        probability density function along the same range\n",
    "        \n",
    "        Args:\n",
    "            n_spaces (int): number of data points \n",
    "        \n",
    "        Returns:\n",
    "            list: x values for the pdf plot\n",
    "            list: y values for the pdf plot\n",
    "            \n",
    "        \"\"\"\n",
    "        \n",
    "        mu = self.mean\n",
    "        sigma = self.stdev\n",
    "\n",
    "        min_range = min(self.data)\n",
    "        max_range = max(self.data)\n",
    "        \n",
    "         # calculates the interval between x values\n",
    "        interval = 1.0 * (max_range - min_range) / n_spaces\n",
    "\n",
    "        x = []\n",
    "        y = []\n",
    "        \n",
    "        # calculate the x values to visualize\n",
    "        for i in range(n_spaces):\n",
    "            tmp = min_range + interval*i\n",
    "            x.append(tmp)\n",
    "            y.append(self.pdf(tmp))\n",
    "\n",
    "        # make the plots\n",
    "        fig, axes = plt.subplots(2,sharex=True)\n",
    "        fig.subplots_adjust(hspace=.5)\n",
    "        axes[0].hist(self.data, density=True)\n",
    "        axes[0].set_title('Normed Histogram of Data')\n",
    "        axes[0].set_ylabel('Density')\n",
    "\n",
    "        axes[1].plot(x, y)\n",
    "        axes[1].set_title('Normal Distribution for \\n Sample Mean and Sample Standard Deviation')\n",
    "        axes[0].set_ylabel('Density')\n",
    "        plt.show()\n",
    "\n",
    "        return x, y\n",
    "        \n",
    "    def __add__(self, other):\n",
    "        \n",
    "        \"\"\"Function to add together two Gaussian distributions\n",
    "        \n",
    "        Args:\n",
    "            other (Gaussian): Gaussian instance\n",
    "            \n",
    "        Returns:\n",
    "            Gaussian: Gaussian distribution\n",
    "            \n",
    "        \"\"\"\n",
    "        \n",
    "        result = Gaussian()\n",
    "        result.mean = self.mean + other.mean\n",
    "        result.stdev = math.sqrt(self.stdev ** 2 + other.stdev ** 2)\n",
    "        \n",
    "        return result\n",
    "        \n",
    "        \n",
    "    def __repr__(self):\n",
    "    \n",
    "        \"\"\"Function to output the characteristics of the Gaussian instance\n",
    "        \n",
    "        Args:\n",
    "            None\n",
    "        \n",
    "        Returns:\n",
    "            string: characteristics of the Gaussian\n",
    "        \n",
    "        \"\"\"\n",
    "        \n",
    "        return \"mean {}, standard deviation {}\".format(self.mean, self.stdev)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "92.87459776004906"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# initialize two gaussian distributions\n",
    "gaussian_one = Gaussian(25, 3)\n",
    "gaussian_two = Gaussian(30, 2)\n",
    "\n",
    "# initialize a third gaussian distribution reading in a data efile\n",
    "gaussian_three = Gaussian()\n",
    "gaussian_three.read_data_file('numbers.txt')\n",
    "gaussian_three.calculate_mean()\n",
    "gaussian_three.calculate_stdev()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25\n",
      "30\n",
      "3\n",
      "2\n",
      "78.0909090909091\n",
      "92.87459776004906\n"
     ]
    }
   ],
   "source": [
    "# print out the mean and standard deviations\n",
    "print(gaussian_one.mean)\n",
    "print(gaussian_two.mean)\n",
    "\n",
    "print(gaussian_one.stdev)\n",
    "print(gaussian_two.stdev)\n",
    "\n",
    "print(gaussian_three.mean)\n",
    "print(gaussian_three.stdev)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f69d13231d0>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "([1.0,\n",
       "  7.58,\n",
       "  14.16,\n",
       "  20.740000000000002,\n",
       "  27.32,\n",
       "  33.9,\n",
       "  40.480000000000004,\n",
       "  47.06,\n",
       "  53.64,\n",
       "  60.22,\n",
       "  66.8,\n",
       "  73.38,\n",
       "  79.96000000000001,\n",
       "  86.54,\n",
       "  93.12,\n",
       "  99.7,\n",
       "  106.28,\n",
       "  112.86,\n",
       "  119.44,\n",
       "  126.02,\n",
       "  132.6,\n",
       "  139.18,\n",
       "  145.76,\n",
       "  152.34,\n",
       "  158.92000000000002,\n",
       "  165.5,\n",
       "  172.08,\n",
       "  178.66,\n",
       "  185.24,\n",
       "  191.82,\n",
       "  198.4,\n",
       "  204.98,\n",
       "  211.56,\n",
       "  218.14000000000001,\n",
       "  224.72,\n",
       "  231.3,\n",
       "  237.88,\n",
       "  244.46,\n",
       "  251.04,\n",
       "  257.62,\n",
       "  264.2,\n",
       "  270.78000000000003,\n",
       "  277.36,\n",
       "  283.94,\n",
       "  290.52,\n",
       "  297.1,\n",
       "  303.68,\n",
       "  310.26,\n",
       "  316.84000000000003,\n",
       "  323.42],\n",
       " [0.0030436941280150395,\n",
       "  0.0032199635775976665,\n",
       "  0.003389385629106679,\n",
       "  0.0035498588092989685,\n",
       "  0.0036993144412822716,\n",
       "  0.0038357605437130374,\n",
       "  0.003957325730527453,\n",
       "  0.004062301768846044,\n",
       "  0.004149183447609647,\n",
       "  0.004216704458941581,\n",
       "  0.004263868097796145,\n",
       "  0.004289971740008139,\n",
       "  0.004294624258609417,\n",
       "  0.004277755775037969,\n",
       "  0.0042396194054553134,\n",
       "  0.004180784941175556,\n",
       "  0.004102124683731816,\n",
       "  0.004004791926750454,\n",
       "  0.0038901928264981145,\n",
       "  0.003759952619833299,\n",
       "  0.003615877323227138,\n",
       "  0.0034599121726495113,\n",
       "  0.003294098137140098,\n",
       "  0.003120527857220398,\n",
       "  0.002941302324101445,\n",
       "  0.002758489530620572,\n",
       "  0.002574086195982893,\n",
       "  0.002389983501515617,\n",
       "  0.002207937582926008,\n",
       "  0.0020295453159204953,\n",
       "  0.001856225716626904,\n",
       "  0.0016892070658496405,\n",
       "  0.0015295196657229566,\n",
       "  0.001377993956504496,\n",
       "  0.0012352635662074894,\n",
       "  0.0011017727408934497,\n",
       "  0.000977787511300198,\n",
       "  0.0008634098928327342,\n",
       "  0.0007585943899081439,\n",
       "  0.0006631660798856831,\n",
       "  0.0005768395828224327,\n",
       "  0.0004992382767035347,\n",
       "  0.0004299131886951978,\n",
       "  0.0003683610762264406,\n",
       "  0.0003140413022577166,\n",
       "  0.00026639120219446516,\n",
       "  0.00022483973132287702,\n",
       "  0.00018881926781767698,\n",
       "  0.00015777552448225903,\n",
       "  0.0001311755903990334])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# plot histogram of gaussian three\n",
    "gaussian_three.plot_histogram_pdf()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "mean 55, standard deviation 3.605551275463989"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# add gaussian_one and gaussian_two together\n",
    "gaussian_one + gaussian_two"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}