winery-classification-bivariate.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Winery classification with the bivariate Gaussian\n",
    "\n",
    "Our first generative model for Winery classification used just one feature. Now we use two features, modeling each class by a **bivariate Gaussian**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Load in the data set"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As in the univariate case, we start by loading in the Wine data set. Make sure the file `wine.data.txt` is in the same directory as this notebook.\n",
    "\n",
    "Recall that there are 178 data points, each with 13 features and a label (1,2,3). As before, we will divide this into a training set of 130 points and a test set of 48 points."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Standard includes\n",
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "# Useful module for dealing with the Gaussian density\n",
    "from scipy.stats import norm, multivariate_normal \n",
    "# installing packages for interactive graphs\n",
    "import ipywidgets as widgets\n",
    "from IPython.display import display\n",
    "from ipywidgets import interact, interactive, fixed, interact_manual, IntSlider"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load data set.\n",
    "data = np.loadtxt('wine.data.txt', delimiter=',')\n",
    "# Names of features\n",
    "featurenames = ['Alcohol', 'Malic acid', 'Ash', 'Alcalinity of ash','Magnesium', 'Total phenols', \n",
    "                'Flavanoids', 'Nonflavanoid phenols', 'Proanthocyanins', 'Color intensity', 'Hue', \n",
    "                'OD280/OD315 of diluted wines', 'Proline']\n",
    "# Split 178 instances into training set (trainx, trainy) of size 130 and test set (testx, testy) of size 48\n",
    "np.random.seed(0)\n",
    "perm = np.random.permutation(178)\n",
    "trainx = data[perm[0:130],1:14]\n",
    "trainy = data[perm[0:130],0]\n",
    "testx = data[perm[130:178], 1:14]\n",
    "testy = data[perm[130:178],0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Look at the distribution of two features from one of the wineries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Our goal is to plot the distribution of two features from a particular winery. We will use several helper functions for this. It is worth understanding each of these."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first helper function fits a Gaussian to a data set, restricting attention to specified features.\n",
    "It returns the mean and covariance matrix of the Gaussian."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fit a Gaussian to a data set using the selected features\n",
    "def fit_gaussian(x, features):\n",
    "    mu = np.mean(x[:,features], axis=0)\n",
    "    covar = np.cov(x[:,features], rowvar=0, bias=1)\n",
    "    return mu, covar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For example, let's look at the Gaussian we get for winery 1, using features 0 ('alcohol') and 6 ('flavanoids')."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean:\n",
      "[13.78534884  2.99627907]\n",
      "Covariance matrix:\n",
      "[[0.23325279 0.07526874]\n",
      " [0.07526874 0.15240941]]\n"
     ]
    }
   ],
   "source": [
    "f1 = 0\n",
    "f2 = 6\n",
    "label = 1\n",
    "mu, covar = fit_gaussian(trainx[trainy==label,:], [f1,f2])\n",
    "print (\"Mean:\\n\" + str(mu))\n",
    "print (\"Covariance matrix:\\n\" + str(covar))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we will construct a routine for displaying points sampled from a two-dimensional Gaussian, as well as a few contour lines. Part of doing this involves deciding what range to use for each axis. We begin with a little helper function that takes as input an array of numbers (values along a single feature) and returns the range in which these numbers lie."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Find the range within which an array of numbers lie, with a little buffer\n",
    "def find_range(x):\n",
    "    lower = min(x)\n",
    "    upper = max(x)\n",
    "    width = upper - lower\n",
    "    lower = lower - 0.2 * width\n",
    "    upper = upper + 0.2 * width\n",
    "    return lower, upper"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next we define a routine that plots a few contour lines of a given two-dimensional Gaussian.\n",
    "It takes as input:\n",
    "* `mu`, `cov`: the parameters of the Gaussian\n",
    "* `x1g`, `x2g`: the grid (along the two axes) at which the density is to be computed\n",
    "* `col`: the color of the contour lines"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_contours(mu, cov, x1g, x2g, col):\n",
    "    rv = multivariate_normal(mean=mu, cov=cov)\n",
    "    z = np.zeros((len(x1g),len(x2g)))\n",
    "    for i in range(0,len(x1g)):\n",
    "        for j in range(0,len(x2g)):\n",
    "            z[j,i] = rv.logpdf([x1g[i], x2g[j]]) \n",
    "    sign, logdet = np.linalg.slogdet(cov)\n",
    "    normalizer = -0.5 * (2 * np.log(6.28) + sign * logdet)\n",
    "    for offset in range(1,4):\n",
    "        plt.contour(x1g,x2g,z, levels=[normalizer - offset], colors=col, linewidths=2.0, linestyles='solid')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function **two_features_plot** takes an input two features and a label, and displays the distribution for the specified winery and pair of features.\n",
    "\n",
    "The first line allows you to specify the parameters interactively using sliders."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "fb1e6585d3434dd4bb3ecddf4120fba6",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(IntSlider(value=0, description='f1', max=12), IntSlider(value=6, description='f2', max=1…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "@interact_manual( f1=IntSlider(0,0,12,1), f2=IntSlider(6,0,12,1), label=IntSlider(1,1,3,1) )\n",
    "def two_features_plot(f1,f2,label):\n",
    "    if f1 == f2: # we need f1 != f2\n",
    "        print (\"Please choose different features for f1 and f2.\")\n",
    "        return  \n",
    "    \n",
    "    # Set up plot\n",
    "    x1_lower, x1_upper = find_range(trainx[trainy==label,f1])\n",
    "    x2_lower, x2_upper = find_range(trainx[trainy==label,f2])\n",
    "    plt.xlim(x1_lower, x1_upper) # limit along x1-axis\n",
    "    plt.ylim(x2_lower, x2_upper) # limit along x2-axis\n",
    "    \n",
    "    # Plot the training points along the two selected features\n",
    "    plt.plot(trainx[trainy==label, f1], trainx[trainy==label, f2], 'ro')\n",
    "\n",
    "    # Define a grid along each axis; the density will be computed at each grid point\n",
    "    res = 200 # resolution\n",
    "    x1g = np.linspace(x1_lower, x1_upper, res)\n",
    "    x2g = np.linspace(x2_lower, x2_upper, res)\n",
    "\n",
    "    # Now plot a few contour lines of the density\n",
    "    mu, cov = fit_gaussian(trainx[trainy==label,:], [f1,f2])\n",
    "    plot_contours(mu, cov, x1g, x2g, 'k')\n",
    "    \n",
    "    # Finally, display\n",
    "    plt.xlabel(featurenames[f1], fontsize=14, color='red')\n",
    "    plt.ylabel(featurenames[f2], fontsize=14, color='red')\n",
    "    plt.title('Class ' + str(label), fontsize=14, color='blue')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Fit a Gaussian to each class"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now define a function that will fit a Gaussian generative model to the three classes, restricted to a given list of features. The function returns:\n",
    "* `mu`: the means of the Gaussians, one per row\n",
    "* `covar`: covariance matrices of each of the Gaussians\n",
    "* `pi`: list of three class weights summing to 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Assumes y takes on values 1,2,3\n",
    "def fit_generative_model(x, y, features):\n",
    "    k = 3 # number of classes\n",
    "    d = len(features) # number of features\n",
    "    mu = np.zeros((k+1,d)) # list of means\n",
    "    covar = np.zeros((k+1,d,d)) # list of covariance matrices\n",
    "    pi = np.zeros(k+1) # list of class weights\n",
    "    for label in range(1,k+1):\n",
    "        indices = (y==label)\n",
    "        mu[label,:], covar[label,:,:] = fit_gaussian(x[indices,:], features)\n",
    "        pi[label] = float(sum(indices))/float(len(y))\n",
    "    return mu, covar, pi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we will plot the three Gaussians."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ba334152a0374fb5986b042382b519d1",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(IntSlider(value=0, description='f1', max=12), IntSlider(value=6, description='f2', max=1…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "@interact_manual( f1=IntSlider(0,0,12,1), f2=IntSlider(6,0,12,1) )\n",
    "def three_class_plot(f1,f2):\n",
    "    if f1 == f2: # we need f1 != f2\n",
    "        print (\"Please choose different features for f1 and f2.\")\n",
    "        return  \n",
    "    \n",
    "    # Set up plot\n",
    "    x1_lower, x1_upper = find_range(trainx[:,f1])\n",
    "    x2_lower, x2_upper = find_range(trainx[:,f2])\n",
    "    plt.xlim(x1_lower, x1_upper) # limit along x1-axis\n",
    "    plt.ylim(x2_lower, x2_upper) # limit along x2-axis\n",
    "    \n",
    "    # Plot the training points along the two selected features\n",
    "    colors = ['r', 'k', 'g']\n",
    "    for label in range(1,4):\n",
    "        plt.plot(trainx[trainy==label,f1], trainx[trainy==label,f2], marker='o', ls='None', c=colors[label-1])\n",
    "\n",
    "    # Define a grid along each axis; the density will be computed at each grid point\n",
    "    res = 200 # resolution\n",
    "    x1g = np.linspace(x1_lower, x1_upper, res)\n",
    "    x2g = np.linspace(x2_lower, x2_upper, res)\n",
    "\n",
    "    # Show the Gaussian fit to each class, using features f1,f2\n",
    "    mu, covar, pi = fit_generative_model(trainx, trainy, [f1,f2])\n",
    "    for label in range(1,4):\n",
    "        gmean = mu[label,:]\n",
    "        gcov = covar[label,:,:]\n",
    "        plot_contours(gmean, gcov, x1g, x2g, colors[label-1])\n",
    "\n",
    "    # Finally, display\n",
    "    plt.xlabel(featurenames[f1], fontsize=14, color='red')\n",
    "    plt.ylabel(featurenames[f2], fontsize=14, color='red')\n",
    "    plt.title('Wine data', fontsize=14, color='blue')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Predict labels for the test points"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How well we can predict the class (1,2,3) based just on these two features?\n",
    "\n",
    "We start with a testing procedure that is analogous to what we developed in the 1-d case."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6052f09f077c463098a761a12dfc63b2",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(IntSlider(value=0, description='f1', max=12), IntSlider(value=6, description='f2', max=1…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Now test the performance of a predictor based on a subset of features\n",
    "@interact( f1=IntSlider(0,0,12,1), f2=IntSlider(6,0,12,1) )\n",
    "def test_model(f1, f2):\n",
    "    if f1 == f2: # need f1 != f2\n",
    "        print (\"Please choose different features for f1 and f2.\")\n",
    "        return  \n",
    "    features= [f1,f2]\n",
    "    mu, covar, pi = fit_generative_model(trainx, trainy, features)\n",
    "    \n",
    "    k = 3 # Labels 1,2,...,k\n",
    "    nt = len(testy) # Number of test points\n",
    "    score = np.zeros((nt,k+1))\n",
    "    for i in range(0,nt):\n",
    "        for label in range(1,k+1):\n",
    "            score[i,label] = np.log(pi[label]) + \\\n",
    "            multivariate_normal.logpdf(testx[i,features], mean=mu[label,:], cov=covar[label,:,:])\n",
    "    predictions = np.argmax(score[:,1:4], axis=1) + 1\n",
    "    # Finally, tally up score\n",
    "    errors = np.sum(predictions != testy)\n",
    "    print (\"Test error using feature(s): \",)\n",
    "    for f in features:\n",
    "        print (\"'\" + featurenames[f] + \"'\" + \" \",)\n",
    "    print\n",
    "    print (\"Errors: \" + str(errors) + \"/\" + str(nt))# Now test the performance of a predictor based on a subset of features"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color=\"magenta\">Fast exercise 1</font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Different pairs of features yield different test errors.\n",
    "* What is the smallest achievable test error?\n",
    "* Which pair of features achieves this minimum test error?\n",
    "\n",
    "*Make a note of your answers to these questions, as you will need to enter them as part of this week's assignment.*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## 5. The decision boundary "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function **show_decision_boundary** takes as input two features, builds a classifier based only on these two features, and shows a plot that contains both the training data and the decision boundary.\n",
    "\n",
    "To compute the decision boundary, a dense grid is defined on the two-dimensional input space and the classifier is applied to every grid point. The built-in `pyplot.contour` function can then be invoked to depict the boundary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "def show_decision_boundary(f1,f2):\n",
    "    # Fit Gaussian to each class\n",
    "    mu, covar, pi = fit_generative_model(trainx, trainy, [f1,f2])\n",
    "    \n",
    "    # Set up dimensions of plot\n",
    "    x1_lower, x1_upper = find_range(trainx[:,f1])\n",
    "    x2_lower, x2_upper = find_range(trainx[:,f2])\n",
    "    plt.xlim([x1_lower,x1_upper])\n",
    "    plt.ylim([x2_lower,x2_upper])\n",
    "\n",
    "    # Plot points in training set\n",
    "    colors = ['r', 'k', 'g']\n",
    "    for label in range(1,4):\n",
    "        plt.plot(trainx[trainy==label,f1], trainx[trainy==label,f2], marker='o', ls='None', c=colors[label-1])\n",
    "\n",
    "    # Define a dense grid; every point in the grid will be classified according to the generative model\n",
    "    res = 200\n",
    "    x1g = np.linspace(x1_lower, x1_upper, res)\n",
    "    x2g = np.linspace(x2_lower, x2_upper, res)\n",
    "\n",
    "    # Declare random variables corresponding to each class density\n",
    "    random_vars = {}\n",
    "    for label in range(1,4):\n",
    "        random_vars[label] = multivariate_normal(mean=mu[label,:],cov=covar[label,:,:])\n",
    "\n",
    "    # Classify every point in the grid; these are stored in an array Z[]\n",
    "    Z = np.zeros((len(x1g), len(x2g)))\n",
    "    for i in range(0,len(x1g)):\n",
    "        for j in range(0,len(x2g)):\n",
    "            scores = []\n",
    "            for label in range(1,4):\n",
    "                scores.append(np.log(pi[label]) + random_vars[label].logpdf([x1g[i],x2g[j]]))\n",
    "            Z[i,j] = np.argmax(scores) + 1\n",
    "\n",
    "    # Plot the contour lines\n",
    "    plt.contour(x1g,x2g,Z.T,3,cmap='seismic')\n",
    "    \n",
    "    # Finally, show the image\n",
    "    plt.xlabel(featurenames[f1], fontsize=14, color='red')\n",
    "    plt.ylabel(featurenames[f2], fontsize=14, color='red')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's use the function above to draw the decision boundary using features 0 ('alcohol') and 6 ('flavanoids')."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "show_decision_boundary(0,6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "show_decision_boundary(6,9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color=\"magenta\">Fast exercise 2</font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Can you add interactive sliders to function **show_decision_boundary**?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7f3195cd839944e89cb1cf095d2e56fb",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(IntSlider(value=0, description='f1', max=12), IntSlider(value=6, description='f2', max=1…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "@interact_manual( f1=IntSlider(0,0,12,1), f2=IntSlider(6,0,12,1) )\n",
    "def show_decision_boundary1(f1,f2):\n",
    "    # Fit Gaussian to each class\n",
    "    mu, covar, pi = fit_generative_model(trainx, trainy, [f1,f2])\n",
    "    \n",
    "    # Set up dimensions of plot\n",
    "    x1_lower, x1_upper = find_range(trainx[:,f1])\n",
    "    x2_lower, x2_upper = find_range(trainx[:,f2])\n",
    "    plt.xlim([x1_lower,x1_upper])\n",
    "    plt.ylim([x2_lower,x2_upper])\n",
    "\n",
    "    # Plot points in training set\n",
    "    colors = ['r', 'k', 'g']\n",
    "    for label in range(1,4):\n",
    "        plt.plot(trainx[trainy==label,f1], trainx[trainy==label,f2], marker='o', ls='None', c=colors[label-1])\n",
    "\n",
    "    # Define a dense grid; every point in the grid will be classified according to the generative model\n",
    "    res = 200\n",
    "    x1g = np.linspace(x1_lower, x1_upper, res)\n",
    "    x2g = np.linspace(x2_lower, x2_upper, res)\n",
    "\n",
    "    # Declare random variables corresponding to each class density\n",
    "    random_vars = {}\n",
    "    for label in range(1,4):\n",
    "        random_vars[label] = multivariate_normal(mean=mu[label,:],cov=covar[label,:,:])\n",
    "\n",
    "    # Classify every point in the grid; these are stored in an array Z[]\n",
    "    Z = np.zeros((len(x1g), len(x2g)))\n",
    "    for i in range(0,len(x1g)):\n",
    "        for j in range(0,len(x2g)):\n",
    "            scores = []\n",
    "            for label in range(1,4):\n",
    "                scores.append(np.log(pi[label]) + random_vars[label].logpdf([x1g[i],x2g[j]]))\n",
    "            Z[i,j] = np.argmax(scores) + 1\n",
    "\n",
    "    # Plot the contour lines\n",
    "    plt.contour(x1g,x2g,Z.T,3,cmap='seismic')\n",
    "    \n",
    "    # Finally, show the image\n",
    "    plt.xlabel(featurenames[f1], fontsize=14, color='red')\n",
    "    plt.ylabel(featurenames[f2], fontsize=14, color='red')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color=\"magenta\">Fast exercise 3</font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Produce a plot similar to that of **show_decision_boundary**, but in which just the **test** data is shown.\n",
    "Look back at your answer to *Fast exercise 1*. Is it corroborated by your plot? Are the errors clearly visible?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "def show_decision_boundary_test(f1,f2):\n",
    "    # Fit Gaussian to each class\n",
    "    mu, covar, pi = fit_generative_model(testx, testy, [f1,f2])\n",
    "    \n",
    "    # Set up dimensions of plot\n",
    "    x1_lower, x1_upper = find_range(testx[:,f1])\n",
    "    x2_lower, x2_upper = find_range(testx[:,f2])\n",
    "    plt.xlim([x1_lower,x1_upper])\n",
    "    plt.ylim([x2_lower,x2_upper])\n",
    "\n",
    "    # Plot points in training set\n",
    "    colors = ['r', 'k', 'g']\n",
    "    for label in range(1,4):\n",
    "        plt.plot(testx[testy==label,f1], testx[testy==label,f2], marker='o', ls='None', c=colors[label-1])\n",
    "\n",
    "    # Define a dense grid; every point in the grid will be classified according to the generative model\n",
    "    res = 200\n",
    "    x1g = np.linspace(x1_lower, x1_upper, res)\n",
    "    x2g = np.linspace(x2_lower, x2_upper, res)\n",
    "\n",
    "    # Declare random variables corresponding to each class density\n",
    "    random_vars = {}\n",
    "    for label in range(1,4):\n",
    "        random_vars[label] = multivariate_normal(mean=mu[label,:],cov=covar[label,:,:])\n",
    "\n",
    "    # Classify every point in the grid; these are stored in an array Z[]\n",
    "    Z = np.zeros((len(x1g), len(x2g)))\n",
    "    for i in range(0,len(x1g)):\n",
    "        for j in range(0,len(x2g)):\n",
    "            scores = []\n",
    "            for label in range(1,4):\n",
    "                scores.append(np.log(pi[label]) + random_vars[label].logpdf([x1g[i],x2g[j]]))\n",
    "            Z[i,j] = np.argmax(scores) + 1\n",
    "\n",
    "    # Plot the contour lines\n",
    "    plt.contour(x1g,x2g,Z.T,3,cmap='seismic')\n",
    "    \n",
    "    # Finally, show the image\n",
    "    plt.xlabel(featurenames[f1], fontsize=14, color='red')\n",
    "    plt.ylabel(featurenames[f2], fontsize=14, color='red')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "show_decision_boundary_test(0,6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "show_decision_boundary_test(6,9)"
   ]
  },
  {
   "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.7.1"
  },
  "toc": {
   "colors": {
    "hover_highlight": "#DAA520",
    "navigate_num": "#000000",
    "navigate_text": "#333333",
    "running_highlight": "#FF0000",
    "selected_highlight": "#FFD700",
    "sidebar_border": "#EEEEEE",
    "wrapper_background": "#FFFFFF"
   },
   "moveMenuLeft": true,
   "nav_menu": {
    "height": "12px",
    "width": "252px"
   },
   "navigate_menu": true,
   "number_sections": false,
   "sideBar": true,
   "threshold": 4,
   "toc_cell": false,
   "toc_section_display": "block",
   "toc_window_display": false,
   "widenNotebook": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}