0208_LDA-QDA.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Linear and Quadratic Discriminant Analysis\n",
    "\n",
    "## Linear Discriminant Analysis\n",
    "\n",
    "### Classifying with Bayes' Theorem\n",
    "\n",
    "In a previous chapter we discussed logistic regression for the case of two response classes (e.g. 0 and 1). It models the conditional probability $\\Pr(Y=k|X=x)$ directly through the use of the Sigmoid function. In this chapter we discuss an alternative approach that models the distribution of the predictors $X$ separately for each response class (i.e. given $Y$), and then uses Bayes' theorem to transform these into conditional probabilities for $\\Pr(Y=k|X=x)$. Its main advantage compared to logistic regressions is that if classes are well-separated, parameter estimates for logistic regression tend to be unstable whereas linear discriminant analysis (LDA) does not suffer from this problem. Beyond that, LDA is a popular algorithm for multi-class classification (i.e. the response has more than two classes, for example buy/hold/sell etc.) where logistic regression is not used that often (James et al. (2013)).\n",
    "\n",
    "LDA assigns an object to class $k$ for which the computed probability is highest. These probabilities are calculated using Bayes' rule which states that\n",
    "\n",
    "\\begin{equation}\n",
    "\\begin{aligned}\n",
    "\\underbrace{\\Pr(Y=k|X)}_{\\text{posterior probability}} &= \\frac{\\overbrace{\\Pr(X|Y=k)}^{\\text{conditional probability}}  \\quad \\overbrace{\\Pr(k)}^{\\text{prior probability}}}{\\underbrace{\\Pr(X)}_{\\text{evidence}}} \\\\[3ex] \n",
    " &= \\frac{\\Pr(X|Y=k) \\Pr(k)}{\\sum_{\\ell=1}^K \\Pr(X|Y=\\ell) \\Pr(\\ell)}\n",
    "\\end{aligned}\n",
    "\\end{equation}\n",
    "\n",
    "Above, $\\Pr(k)$ is simply the prior probability of class $k$ (with $\\sum_{k=1}^K \\Pr(k) = 1$) that a randomly chosen observation is drawn from the $k$th class. $\\Pr(X|Y=k)$ on the other hand is the class conditional density of $X$ in class $Y=k$. Following the notation in (Friedman et al. (2001)), we denote $\\Pr(X|Y=k) \\equiv f_k(x)$ to indicate that it is a density function. LDA's decision rule thus classifies an observation into class $k$ if \n",
    "\n",
    "\\begin{align}\n",
    "\\Pr(Y=k|X) &> \\Pr(Y=j|X) \\qquad \\forall j \\neq k \\nonumber \\\\\n",
    "\\end{align}\n",
    "\n",
    "or, if we substitute both sides of the inequality with Bayes' rule:\n",
    "\n",
    "\\begin{align}\n",
    "\\frac{f_k(x) \\Pr(k)}{\\sum_{\\ell=1}^K f_\\ell(x) \\Pr(\\ell)} &> \\frac{f_j(x) \\Pr(j)}{\\sum_{\\ell=1}^K f_\\ell(x) \\Pr(\\ell)} \\qquad \\forall j \\neq k \\nonumber\n",
    "\\end{align}\n",
    "\n",
    "\n",
    "The evidence term (denominator in above equation) can be omitted from the decision rule because it is merely a scaling factor (Raschka (2014)). This then yields the following simple decision boundary:\n",
    "\n",
    "\\begin{align}\n",
    "f_k(x) \\Pr(k) &> f_j(x) \\Pr(j)  \\qquad \\forall j \\neq k\n",
    "\\end{align}\n",
    "\n",
    "This expression can also be written as\n",
    "\\begin{equation}\n",
    "\\delta_k(x) = \\arg \\max_k \\; f_k(x) \\Pr(k) \n",
    "\\end{equation}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Bayes Decision Rule in LDA with One Feature\n",
    "\n",
    "Suppose that $f_k(x)$ follows a Gaussian distribution. For the one-dimensional setting, that is if we have just one feature $p=1$, the normal density takes the well known form\n",
    "\n",
    "\\begin{equation}\n",
    "f_k(x) = \\frac{1}{\\sqrt{2\\pi \\sigma_k^2}} \\, \\exp\\left( - \\frac{(x - \\mu_k)^2}{2 \\sigma_k^2} \\right)\n",
    "\\end{equation}\n",
    "\n",
    "where $\\mu_k$ and $\\sigma_k^2$ are the mean and variance for the $k$th class, respectively. For the moment let us also assume that there is a shared variance term across all $K$ classes, i.e. $\\sigma_1^2 = \\sigma_2^2 = \\ldots = \\sigma_k^2$. Then plugging the normal distribution into our maximization problem, taking the log and doing some algebra - see the appendix of the script for detailed steps - we find that an observation is assigned to class $k$ for which $\\delta_k(x)$ is greatest:\n",
    "\n",
    "\\begin{equation}\n",
    "\\delta_k(x) = \\arg \\max_k \\left[\\frac{x \\mu_k}{\\sigma^2} - \\frac{\\mu_k}{2\\sigma^2} + \\ln(\\Pr(k)) \\right]\n",
    "\\end{equation}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below figure shows how LDA classifies data based on the above result. In the left subplot we see two separate normal densities representing a situation with two classes ($K \\in \\{\\text{blue, green\\}}$). $\\Pr(k=\\text{blue}) = \\Pr(k=\\text{green}) = 0.5$; equal for both classes. Both densities have the same variance $\\sigma_1^2 = \\sigma_2^2 = 1$ but different location parameter, $\\mu_1 = -1.25, \\mu_2 = 1.25$. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"Graphics/0208_BayesDescBoundary1d.png\" alt=\"BayesDescBoundary1d\" style=\"width: 1000px;\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we were to know these parameter, then LDA's decision boundary would be drawn exactly at zero (dashed line). If $\\Pr(k=\\text{blue}) > \\Pr(k=\\text{green})$, Bayes' decision boundary would move to the right, if $\\Pr(k=\\text{blue}) < \\Pr(k=\\text{green})$, to the left. There is some overlapping area leading to some uncertainty, but overall the error rate is minimized to a minimum. In reality however, we do not know the true location and scale parameter and hence we have to estimate them - what we will discuss momentarily. The right plot displays histograms of 50 randomly drawn observations from the aforementioned normal distribution. Given this data, LDA calculates $\\mu_k, \\sigma^2$ and uses $\\delta_k(x)$ to draw the decision boundary (solid vertical line). Data points to the left will be labeled 'blue class', all others to the 'green class'. The dashed vertical line again displays the optimal decision boundary. Because we don't know the true location and scale parameter LDA relies on estimates. This introduces inaccuracy that is reduced the larger the data sample is (assuming our normal assumption is correct)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Assumptions and Parameter Estimation\n",
    "\n",
    "So far we have discussed how LDA draws its decision boundary with the help of Bayes rule and given the assumptions that the features follow a normal distribution. But in order to follow through with our classification task, estimates for $\\Pr(k), \\mu_k$, and $\\sigma^2$ are required. Estimating the prior probability $\\Pr(k)$ is no difficult job: we simply compute the fraction of training observations that belong to the $k$th class: $\\hat{\\Pr}(k) = n_k / n$, where $n_k$ represents the count of samples from class $k$ and $n$ the count of all samples. Location parameter $\\mu_k$ is estimated using the average of training observation of the $k$th class and $\\sigma^2$, the scale parameter, is the weighted average of the sample variance for each of the $K$ classes (Note that Friedman et al. (2001) and James et al (2013) both use a biased corrected version of $\\hat{\\sigma}^2$ (and $\\hat{\\Sigma}$ for the case of $p>1$) by dividing the summed terms by $n-K$ instead of $n$. The formula given here uses an uncorrected estimate of $\\sigma$ and in that follows `Sklearn`'s implementation.)\n",
    "\n",
    "\\begin{align}\n",
    "\\hat{\\mu}_k &= \\frac{1}{n_k} \\sum_{i:y_i=k} x_i \\\\\n",
    "\\hat{\\sigma}^2 &= \\frac{1}{n} \\sum_{k=1}^K \\sum_{i:y_i=k} (x_i - \\hat{\\mu}_k)^2\n",
    "\\end{align}\n",
    "\n",
    "Given the assumption of normality and given these estimates for location and scale we are able to establish a decision rule that assigns each new data point to the class for which $\\delta_k(x)$ is highest."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Bayes Decision Rule in LDA with More Than One Feature\n",
    "\n",
    "Above we have used the one-dimensional case with one predictor to introduce how LDA classifies an observation. Now we extend the classifier to work with multiple features ($p>1$). Again we assume that $X = (X_1, X_2, \\ldots, X_p)$ is drawn from a (multivariate) normal distribution with a class specific mean vector $\\mu_k$ of length $p$ and common covariance matrix $\\Sigma$ of dimension $p \\times p$. This is expressed as $X \\sim N(\\mu, \\Sigma)$. The multivariate Gaussian density is defined as\n",
    "\n",
    "\\begin{equation}\n",
    "f_k(x) = \\frac{1}{(2\\pi)^{p/2}|\\Sigma|^{1/2}} \\, \\exp \\left( -\\frac{1}{2} (x-\\mu_k)^T \\Sigma^{-1} (x-\\mu_k) \\right)\n",
    "\\end{equation}\n",
    "\n",
    "As before we plug this expression into our maximization problem, take the logarithm and perform a little bit of algebra (For the interested the different steps are shown in the appendix of the script). This yields to the following LDA's Bayes classifier rule, based on which an observation $X=x$ is assigned to the class for which $\\delta_k(x)$ is largest.\n",
    "\n",
    "\\begin{equation}\n",
    "\\delta_k(x) = \\arg \\max_k \\left[x^T \\Sigma^{-1} \\mu_k - \\frac{1}{2} \\mu_k^T\\Sigma^{-1}\\mu_k + \\ln(\\Pr(k))\\right]\n",
    "\\end{equation}\n",
    "\n",
    "The estimates for $\\Pr(k), \\mu_k$, and $\\Sigma$ follow again the same approach as in the case of only one predictor.\n",
    "\n",
    "The next figure plots LDA's Bayes decision boundary for a random training set with two features $X_1, X_2$. The colors indicate the binary response with blue circles indicating customers who accepted a product offer and green circles representing those who declined it. The bivariate normal contours (ellipses) represent iso-lines with the same probabilities. LDA uses Bayes' decision rule discussed above to classify any new data point into class $k$. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"Graphics/0208_BayesDescBoundary2d.png\" alt=\"BayesDescBoundary2d\" style=\"width: 1000px;\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### LDA in Python\n",
    "#### Setup\n",
    "\n",
    "We will apply LDA in Python with the functions that are provided through the `sklearn` package and the 'Default' data set we used to introduce logistic regression in a previous chapter. `Sklearn`, short for Scikit-learn, is a key resource for clustering, classification or regression algorithms in machine learning. It offers an abundant variety of functions and functionalities and is actively developed by a large community. \n",
    "\n",
    "`Sklearn` is one of the most extensive package in Python with hundreds, if not thousands, of functions. It is good practice to not load the full library as we did for example with `numpy` but to only load those functions that are needed to run your task at hand. This saves computer memory and with that improves the efficiency of your algorithm, especially if you are using your household PC to run it on larger data sets. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn import metrics\n",
    "plt.rcParams['font.size'] = 14\n",
    "plt.style.use('seaborn-whitegrid')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "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>default</th>\n",
       "      <th>student</th>\n",
       "      <th>balance</th>\n",
       "      <th>income</th>\n",
       "      <th>defaultFac</th>\n",
       "      <th>studentFac</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>No</td>\n",
       "      <td>No</td>\n",
       "      <td>729.526495</td>\n",
       "      <td>44361.625074</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>No</td>\n",
       "      <td>Yes</td>\n",
       "      <td>817.180407</td>\n",
       "      <td>12106.134700</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>No</td>\n",
       "      <td>No</td>\n",
       "      <td>1073.549164</td>\n",
       "      <td>31767.138947</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>No</td>\n",
       "      <td>No</td>\n",
       "      <td>529.250605</td>\n",
       "      <td>35704.493935</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>No</td>\n",
       "      <td>No</td>\n",
       "      <td>785.655883</td>\n",
       "      <td>38463.495879</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  default student      balance        income  defaultFac  studentFac\n",
       "0      No      No   729.526495  44361.625074           0           0\n",
       "1      No     Yes   817.180407  12106.134700           0           1\n",
       "2      No      No  1073.549164  31767.138947           0           0\n",
       "3      No      No   529.250605  35704.493935           0           0\n",
       "4      No      No   785.655883  38463.495879           0           0"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Default data set is not available online. Data was extracted from R package \"ISLR\"\n",
    "df = pd.read_csv('Data/Default.csv', sep=',')\n",
    "\n",
    "# Factorize 'No' and 'Yes' in columns 'default' and 'student'\n",
    "df['defaultFac'] = df.default.factorize()[0]\n",
    "df['studentFac'] = df.student.factorize()[0]\n",
    "df.head(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Assign data to feature matrix X_train and response vector y_train\n",
    "X_train = df[['balance', 'income', 'studentFac']]\n",
    "y_train = df.defaultFac"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### LDA Classifier Object & Fit\n",
    "Now we are in a position to run the LDA classifier. This, as you can see from the three lines below, is as easy as it gets. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LinearDiscriminantAnalysis(solver='lsqr')"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.discriminant_analysis import LinearDiscriminantAnalysis as LDA\n",
    "\n",
    "# Create LDA object and run classifier\n",
    "lda = LDA(solver='lsqr')\n",
    "lda = lda.fit(X_train, y_train)\n",
    "lda"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The parameter `solver='lsqr'` specifies the method by which the covariance matrix is estimated. `lsqr` follows the approach introduced in the preceding subsection. Others such as `svd` or `eigen` are available. See [Scikit-learn's guide](http://scikit-learn.org/stable/modules/lda_qda.html#estimation-algorithms) or the [function description](http://scikit-learn.org/stable/modules/generated/sklearn.discriminant_analysis.LinearDiscriminantAnalysis.html).\n",
    "\n",
    "Every function in `sklearn` has different attributes and methods. `Sklearn`s convention is to store anything that is derived from the data in attributes that end with a trailing underscore. That is to separate them from parameters that are set by the user (Mueller and Guido (2017)). For example the estimated covariance matrix can be printed with this command."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 2.05277550e+05, -9.37165654e+05,  4.21453998e+01],\n",
       "       [-9.37165654e+05,  1.77777941e+08, -4.57857337e+03],\n",
       "       [ 4.21453998e+01, -4.57857337e+03,  2.07468022e-01]])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lda.covariance_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In a Jupyter notebook, to see all options you can simply type `lda.` and hit tab.\n",
    "\n",
    "#### LDA Performance\n",
    "\n",
    "Here are some basic metrics on how the LDA classifier performed on the training data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "default-rate:  0.0333\n",
      "score:         0.9725\n",
      "error-rate:    0.0275\n"
     ]
    }
   ],
   "source": [
    "print('default-rate: {0: .4f}'.format(np.sum(y_train)/len(y_train)))\n",
    "print('score:        {0: .4f}'.format(lda.score(X_train, y_train)))\n",
    "print('error-rate:   {0: .4f}'.format(1-lda.score(X_train, y_train)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Overall, 3.33% of all observations defaulted. If we would simply label each entry as 'non-default' we would have an error rate of this magnitude. So, in comparison to this *naive* classifier, LDA seems to have some skill in predicting the default."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **IMPORTANT NOTE: In order to be in line with James et al. (2015), the textbook for this course, we have not performed any train/test split of the data. Therefore we will use the same full matrix `X_train` and response vector `y_train` as test data. Performance metrics might be applied to both test and training data but in the end the results on the test set are those that we are ultimately interested in. To drive this point home, I have relabeled the  `X_train` and `y_train` to `X_test`, `y_test`.  Nevertheless, be aware that in this unique case it is the same data!**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us print the confusion matrix introduced in the previous chapter to see the class-wise performance. For reference the confusion matrix is also printed as `DataFrame` but moving forward be sure to know that row represent the true values and columns predicted labels."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[9645   22]\n",
      " [ 253   80]]\n",
      "Predicted default status    No  Yes\n",
      "True default status                \n",
      "No                        9645   22\n",
      "Yes                        253   80\n"
     ]
    }
   ],
   "source": [
    "# Relabel variables as discussed\n",
    "X_test = X_train\n",
    "y_test = y_train\n",
    "\n",
    "# Predict labels\n",
    "y_pred = lda.predict(X_test)\n",
    "\n",
    "# Sklearn's confusion matrix\n",
    "print(metrics.confusion_matrix(y_test, y_pred))\n",
    "\n",
    "# Manual confusion matrix as pandas DataFrame\n",
    "confm = pd.DataFrame({'Predicted default status': y_pred,\n",
    "                      'True default status': y_test})\n",
    "confm.replace(to_replace={0:'No', 1:'Yes'}, inplace=True)\n",
    "print(confm.groupby(['True default status','Predicted default status']).size().unstack('Predicted default status'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The confusion matrix tells us that for the non-defaulters, LDA only misclassified 22 of them. This is an excellent rate. However, out of the 333 (=253 + 80) people who actually defaulted, LDA classified only 80 correctly. This means our classifier missed out on 76.0% of those who actually defaulted! For a credit card applicant with a bad credit score this is good news. For a credit card company, not so much. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Varying the Threshold Levels\n",
    "Why does LDA miss all these 'defaulters'? Implicitly, Bayes classifier minimizes the **overall** error rate, meaning that it yields the smallest possible total number of misclassified observations - irrespective of the class-specific error rate. Bayes classifier works by assigning an observation to class 'default' for which the posterior probability $Pr(\\text{default = Yes}|X=x) > 0.5$. For a credit card company who seeks to have as few defaults as possible, this threshold might be too large. Instead, such a company might decide to label any customer with a posterior probability of default above 20% to the 'default' class ($Pr(\\text{default = Yes}|X=x) > 0.2$). Let us investigate how the results in such a case would look like."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.996778  , 0.003222  ],\n",
       "       [0.99731184, 0.00268816],\n",
       "       [0.98529382, 0.01470618],\n",
       "       [0.99881647, 0.00118353],\n",
       "       [0.99597848, 0.00402152]])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Calculated posterior probabilities\n",
    "posteriors = lda.predict_proba(X_test)\n",
    "posteriors[:5, :]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function `lda.predict_proba()` provides the posterior probabilities of $\\Pr(\\text{default = 0}|X=x)$ in the first column and $\\Pr(\\text{default = 1}|X=x)$ in the second. The latter column is what we are interested in. Out of convenience we use `sklearn`'s `binarize` function to classify all probabilities above the threshold of 0.2 as 1 (=default) and generate the confusion matrix."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[9435  232]\n",
      " [ 140  193]]\n"
     ]
    }
   ],
   "source": [
    "from sklearn.preprocessing import binarize\n",
    "\n",
    "# Set threshold and get classes\n",
    "thresh = 0.2\n",
    "y_pred020 = binarize([posteriors[:, 1]], threshold=thresh)[0]\n",
    "\n",
    "# new confusion matrix (threshold of 0.2)\n",
    "print(metrics.confusion_matrix(y_test, y_pred020))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now LDA misclassifies only 140 out of 333 defaults, or 42.0%. Thats a sharp improvement over the 76.0% from before. But this comes at a price: Before, of those who did not default LDA mislabeled only 22 (or 0.2%) incorrectly. This number increased now to 232 (or 2.4%). Combined, the total error rate increased from 2.75% to 3.72%. For a credit card company, this might be a price they are willing to pay to have a more accurate identification of individuals who default. \n",
    "\n",
    "Below code snippet calculates and plots the overall error rate, the proportion of missed defaulting customers and the fraction of error among the non-defaulting customers as a function of the threshold value for the posterior probability that is used to assign classes. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Array of thresholds\n",
    "thresh = np.linspace(0, 0.5, num=100)\n",
    "\n",
    "er   = []  # Total error rate\n",
    "der  = []  # Defaults error rate\n",
    "nder = []  # Non-Defaults error rate\n",
    "\n",
    "for t in thresh:\n",
    "    # Sort/arrange data\n",
    "    y_pred_class = binarize([posteriors[:, 1]], threshold=t)[0]\n",
    "    confm = metrics.confusion_matrix(y_test, y_pred_class)\n",
    "    \n",
    "    # Calculate error rates\n",
    "    er   = np.append(er, (confm[0, 1] + confm[1, 0]) / len(posteriors))\n",
    "    der  = np.append(der, confm[1, 0] / np.sum(confm[1, :]))\n",
    "    nder = np.append(nder, confm[0, 1] / np.sum(confm[0, :]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot\n",
    "plt.figure(figsize=(12, 6))\n",
    "plt.plot(thresh, er, label='Total error rate')\n",
    "plt.plot(thresh, der, label='Missed defaults')\n",
    "plt.plot(thresh, nder, label='Missed non-defaults')\n",
    "plt.xlim(0, 0.5)\n",
    "plt.xlabel('Threshold')\n",
    "plt.ylabel('Error Rate')\n",
    "plt.legend();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How do we know what threshold value is best? Unfortunately there's no formula for it. \"Such a decision must be based on *domain knowledge*, such as detailed information about costs associated with defaults\" (James et al. (2013, p.147)) and it will always be a **trade-off: if we increase the threshold we reduce the missed non-defaults but at the same time increase the missed defaults**.\n",
    "\n",
    "## Performance Metrics\n",
    "\n",
    "This is now the perfect opportunity to refresh our memory on a few classification performance measures introduced in the previous chapters and add a few more to have a more rounded bag of performance metrics. The following table will help in doing this."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"Graphics/0208_ConfusionMatrixDefault.png\" alt=\"ConfusionMatrixDefault\" style=\"width: 800px;\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will use the following abbreviations ([Markham (2016)](https://github.com/justmarkham/scikit-learn-videos/blob/master/09_classification_metrics.ipynb)): \n",
    "\n",
    "* True Positives (TP): correctly predicted defaults\n",
    "* True Negatives (TN): correctly predicted non-defaults\n",
    "* False Positives (FP): incorrectly predicted defaults (\"Type I error\")\n",
    "* False Negatives (FN): incorrectly predicted non-defaults (\"Type II error\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[9645   22]\n",
      " [ 253   80]]\n"
     ]
    }
   ],
   "source": [
    "# Assign confusion matrix values to variables\n",
    "confm = metrics.confusion_matrix(y_test, y_pred)\n",
    "print(confm)\n",
    "TP = confm[1, 1]  # True positives\n",
    "TN = confm[0, 0]  # True negatives\n",
    "FP = confm[0, 1]  # False positives\n",
    "FN = confm[1, 0]  # False negatives"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So far we've encountered the following performance metrics: \n",
    "\n",
    "* Score\n",
    "* Error rate\n",
    "* Sensitivity and \n",
    "* Specificity. \n",
    "\n",
    "We briefly recapture their meaning, how they are calculated and how to call them in Scikit-learn. We will make use of the functions in the `metrics` sublibrary of `sklearn`\n",
    "\n",
    "#### Score\n",
    "* Score = (TN + TP) / (TN + TP + FP + FN)\n",
    "* Fraction of (overall) correctly predicted classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9725\n",
      "0.9725\n",
      "0.9725\n"
     ]
    }
   ],
   "source": [
    "print((TN + TP) / (TN + TP + FP + FN))\n",
    "print(metrics.accuracy_score(y_test, y_pred))\n",
    "print(lda.score(X_test, y_test))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Error rate\n",
    "* Error rate = 1 - Score or Error rate = (FP + FN) / (TN + TP + FP + FN)\n",
    "* Fraction of (overall) incorrectly predicted classes\n",
    "* Also known as \"Misclassification Rate\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0275\n",
      "0.02749999999999997\n",
      "0.02749999999999997\n"
     ]
    }
   ],
   "source": [
    "print((FP + FN) / (TN + TP + FP + FN))\n",
    "print(1 - metrics.accuracy_score(y_test, y_pred))\n",
    "print(1 - lda.score(X_test, y_test))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Specificity\n",
    "\n",
    "* Specificity = TN / (TN + FP)\n",
    "* Fraction of correctly predicted negatives (e.g. 'non-defaults')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9977242164063308\n"
     ]
    }
   ],
   "source": [
    "print(TN / (TN + FP))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Sensitivity or Recall\n",
    "* Sensitivity = TP / (TP + FN)\n",
    "* Fraction of correctly predicted 'positives' (e.g. 'defaults'). Basically asks the question: \"When the actual value is positive, how often is the prediction correct?\"\n",
    "* Also known as **True positive rate**\n",
    "* Counterpart to *Precision*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.24024024024024024\n",
      "0.24024024024024024\n"
     ]
    }
   ],
   "source": [
    "print(TP / (TP + FN))\n",
    "print(metrics.recall_score(y_test, y_pred))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above four classification performance metrics we already encountered. There are two more metrics we want to cover: **Precision** and the **F-Score**.\n",
    "\n",
    "\n",
    "#### Precision\n",
    "* Precision = TP / (TP + FP)\n",
    "* Refers to the accuracy of a positive ('default') prediction. Basically asks the question: \"When a positive value is predicted, how often is the prediction correct?\" \n",
    "* Counterpart to *Recall*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.7843137254901961\n",
      "0.7843137254901961\n"
     ]
    }
   ],
   "source": [
    "print(TP / (TP + FP))\n",
    "print(metrics.precision_score(y_test, y_pred))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"Graphics/0208_ConfusionMatrixDefault.png\" alt=\"ConfusionMatrixDefault\" style=\"width: 800px;\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### F-Score\n",
    "\n",
    "Van Rijsbergen (1979) introduced a measure that is still widely used to evaluate the accuracy of predictions in two-class (binary) classification problems: the F-Score. It combines Precision and Recall (aka Sensitivity) in one metric and tells us something about the relations between data's positive labels and those given by a classifier. It is a single measure of a classification procedure's usefullness and in general the rule is that the higher the F-Score, the better the predictive power of the classification procedure. It is defined as:\n",
    "\n",
    "\\begin{align}\n",
    "F_{\\beta} &= \\frac{(1 + \\beta^2) \\cdot \\text{precision} \\cdot \\text{recall}}{\\beta^2 \\cdot \\text{precision} + \\text{recall}} \\\\[2ex]\n",
    "          &= \\frac{(1+\\beta^2) \\cdot TP}{(1+\\beta^2) \\cdot TP + \\beta^2 \\cdot FN + FP}\n",
    "\\end{align}\n",
    "\n",
    "This measure employs a parameter $\\beta$ that captures a user's preference (Guggenbuehler (2015)). The most common value for $\\beta$ is 1. This $F_1$-score weights both precision and recall evenly (simple harmonic mean). In rare cases the $F_2$-score is used, which puts twice as much weights on recall as on precision (Hripcsak and Rotschild (2005)).\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[9645   22]\n",
      " [ 253   80]]\n",
      "0.367816091954023\n",
      "0.367816091954023\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.97      1.00      0.99      9667\n",
      "           1       0.78      0.24      0.37       333\n",
      "\n",
      "    accuracy                           0.97     10000\n",
      "   macro avg       0.88      0.62      0.68     10000\n",
      "weighted avg       0.97      0.97      0.97     10000\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(metrics.confusion_matrix(y_test, y_pred))\n",
    "print(metrics.f1_score(y_test, y_pred))\n",
    "print(((1+1**2) * TP)/((1+1**2) * TP + FN + FP))\n",
    "print(metrics.classification_report(y_test, y_pred))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us compare this to the situation where we set the posterior probability threshold for 'default' at 20%."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[9435  232]\n",
      " [ 140  193]]\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.99      0.98      0.98      9667\n",
      "           1       0.45      0.58      0.51       333\n",
      "\n",
      "    accuracy                           0.96     10000\n",
      "   macro avg       0.72      0.78      0.74     10000\n",
      "weighted avg       0.97      0.96      0.96     10000\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Confusion matrix & clf-report for cut-off \n",
    "# value Pr(default=yes | X = x) > 0.20\n",
    "print(metrics.confusion_matrix(y_test, y_pred020))\n",
    "print(metrics.classification_report(y_test, y_pred020))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see that by reducing the cut-off level from $\\Pr(\\text{default} = 1| X=x) > 0.5$ to $\\Pr(\\text{default} = 1| X=x) > 0.2$ precision decreases but recall improves. This changes the $F_1$-score. \n",
    "\n",
    "Does this mean that a threshold of 20% is more appropriate? In general, one could argue for a 'yes'. Yet, as mentioned before, this boils down to domain knowledge. Where the $F_1$-score is of help, together with the other metrics introduced, is when we compare models against each other and want to determine which one performed best. For example if we compare results from logistic regression and LDA (and both used a cut-off level of 50%) the F-score would suggest that the one with the higher value performed better."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For a summary on performance metrics the following two ressources are recommended:\n",
    "\n",
    "* For the interested reader an excellent and easily accessible summary on performance metrics is the article by [Sokolova and Lapalme (2009)](http://rali.iro.umontreal.ca/rali/sites/default/files/publis/SokolovaLapalme-JIPM09.pdf). \n",
    "\n",
    "* For further details and examples please also consider the [scikit-learn discription](https://scikit-learn.org/stable/modules/model_evaluation.html#precision-recall-f-measure-metrics)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Precision-Recall Curve\n",
    "\n",
    "If one is interested in understanding how precision and recall varies given different level of thresholds, then there is a function to do this. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Precision:  [0.05540765 0.05525046 0.05525965 ... 1.         1.         1.        ]\n",
      "Recall:     [1.         0.996997   0.996997   ... 0.00600601 0.003003   0.        ]\n"
     ]
    }
   ],
   "source": [
    "# Extract data displayed in above plot\n",
    "precision, recall, _ = metrics.precision_recall_curve(y_test, posteriors[:, 1])\n",
    "\n",
    "print('Precision: ', precision)\n",
    "print('Recall:    ', recall)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This one can easily visualize - done in the next code snippet.  Note that the \n",
    "funciton `PrecisionRecallDisplay` has been added to `sklearn` version 0.22. \n",
    "\n",
    "We also add some more information to the plot by displaying the *Average Precision (AP)* and the *Area under the Curve (AUC)*. The former summarizes the plot in that it calculates the weighted mean of precisions achieved at each threshold, with the increase in recall from the previous threshold used as the weight [see further description here](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.average_precision_score.html). The latter calculates the area under the curve using the trapezoidal rule. Notice that ideally the function hugs the top-right corner. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.metrics import PrecisionRecallDisplay\n",
    "\n",
    "# Calculate the average precisions score\n",
    "y_dec_bry = lda.decision_function(X_test)\n",
    "average_precision = metrics.average_precision_score(y_test, y_dec_bry)\n",
    "\n",
    "# Calculate AUC\n",
    "prec_recall_auc = metrics.auc(recall, precision)\n",
    "\n",
    "# Plot Precision/Recall variations given different\n",
    "# levels of thresholds\n",
    "fig_pr = PrecisionRecallDisplay(precision=precision, \n",
    "                                recall=recall).plot()\n",
    "fig_pr.ax_.set_title('2-class Precision-Recall curve: \\n AP={0:0.2f} / AUC={1:0.2f}'.format(\n",
    "                     average_precision, prec_recall_auc));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ROC Curve\n",
    "\n",
    "Having introduced the major performance measures, let us now discuss the so called ROC curve (short for \"receiver operating characteristics\"). This is a very popular way of visualizing the performance of binary classifiers. Its origin are in signal detection theory durign WWII (Flaach (2017)) but it has since found application in medical decision making and machine learning ([Fawcett (2006)](http://people.inf.elte.hu/kiss/13dwhdm/roc.pdf)). ROC investigates the relationship between sensitivity and specificity of a binary classifier. Sensitivity (or true positive rate) measures the proportion of positives (defaults) correctly classified. Specificity (or true negative rate) measures the proportion of negatives (non-defaults) correctly classified. \n",
    "\n",
    "Above we calculated that if we use $\\Pr(\\text{default = Yes}|X=x) > 0.5$ to classify posterior probabilities as defaults, LDA has its best overall error rate but misses on 76.0% of the customers who acutally defaulted. By decreasing the threshold to 0.2 we improved the accuracy of detecting defaults but this came at the cost of a higher overall error rate. This was the trade-off we faced. The ROC curve serves to visualize a variation of this trade-off. It varies the cut-off threshold from 0 to 1 and calculates for each threshold the true positive rate (aka sensitivity) and false positive rate (equals 1 - specificity). These values are then plotted with the former on the vertical and the later on the horizontal axis. \n",
    "\n",
    "Though this might feel a bit abstract if one is not familiar with all these technical terms, the interpretation is fortunately fairly simple. The ideal ROC curve will hug the top left corner. In that case, the area under the curve (AUC) is biggest. The bigger the AUC, the better the classifier. A perfect classifier has an AUC of 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig_roc = metrics.plot_roc_curve(lda, X_test, y_test);\n",
    "fig_roc.ax_.set_title('Receiver operating characteristic (ROC)');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Please be aware that by default `estimators.classes_[1]` is considered as the positive class. You can change this with the `pos_label` parameter within the `plot_roc_curve` function. Note also, that this function was introduced with version 0.22 but will be removed in 1.2 in favor of `sklearn.metric.RocCurveDisplay.from_predictions` or `sklearn.metric.RocCurveDisplay.from_estimator`. \n",
    "\n",
    "If you wish to overlay ROCs from multiple models [see this example.](https://scikit-learn.org/stable/auto_examples/plot_roc_curve_visualization_api.html)\n",
    "\n",
    "Below is a more extensive, yet more approachable code that does the same. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Compute ROC curve and ROC area (AUC) for each class\n",
    "fpr, tpr, thresholds = metrics.roc_curve(y_test, posteriors[:, 1])\n",
    "roc_auc = metrics.auc(fpr, tpr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(6, 6))\n",
    "plt.plot(fpr, tpr, lw=2, label='ROC curve (area = {0: 0.2f})'.format(roc_auc))\n",
    "plt.plot([0, 1], [0, 1], lw=2, c = 'k', linestyle='--')\n",
    "plt.xlim([-0.01, 1.0])\n",
    "plt.ylim([-0.01, 1.01])\n",
    "plt.xlabel('False Positive Rate (1 - Specificity)')\n",
    "plt.ylabel('True Positive Rate (Sensitivity)')\n",
    "plt.title('Receiver operating characteristic (ROC)', fontweight='bold', fontsize=18)\n",
    "plt.legend(loc=\"lower right\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An AUC value of 0.95 is close to the maximum of 1 and should be deemed very good. The dashed black line puts this in perspective: it represents the \"no information\" classifier; this is what we would expect if the probability of default is not associated with 'student' status and 'balance'. Such a classifier, that performs no better than chance, is expected to have an AUC of 0.5. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Quadratic Discriminant Analysis\n",
    "\n",
    "### Underlying Assumptions\n",
    "\n",
    "For LDA we assume that observations within each class are drawn from a multivariate normal distribution with a class-specific mean vector and a common covariance metrix: $X \\sim N(\\mu_k, \\Sigma)$. Quadratic discriminant analysis (QDA) relaxes these assumptions somewhat. The basic assumption is still that the observations follow a multivariate normal distribution, however, QDA allows for class specific means and covariance matrices: $X \\sim N(\\mu_k, \\Sigma_k)$, where $\\Sigma_k$ is a covariance matrix for the $k$th class. With that, the Bayes classifier assigns an observation to the class for which \n",
    "\n",
    "\\begin{equation}\n",
    "\\delta_k(x) = \\arg \\max_k \\; - \\frac{1}{2} \\ln(|\\Sigma_k|) - \\frac{1}{2} (x - \\mu_k)^T \\Sigma_k^{-1} (x - \\mu_k) + \\ln(\\Pr(k))\n",
    "\\end{equation}\n",
    "\n",
    "is highest. For a derivation of this result see again the appendix of the script. As was the case for LDA, parameter $\\mu_k, \\Sigma_k$ and $\\Pr(k)$ are again estimated from the training data with the same formulas introduced in this notebook. \n",
    "\n",
    "Below figure depict both LDA and QDA. Both classifiers were trained on the same data. Due to the different variability of the two classes the QDA algorithm seems to perform slightly better in this case."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"Graphics/0208_QDABayesDescBoundary2d.png\" alt=\"QDABayesDescBoundary2d\" style=\"width: 1000px;\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Under what circumstances should we prefer QDA over LDA? As always, there's no straight answer to this question. Obviously, performance should be king. However, it is said that LDA tends to be a better bet than QDA if the training set is small. In contrast, if the hold-out set is large or the assumption of a common covariance matrix is clearly incorrect, then QDA is recommended. Beyond that, we have to keep in mind that QDA estimates $K p(p+1)/2$ parameters. So if the number of parameters $p$ is large, QDA might take some time to process (James et al. (2013)). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Naive Bayes**\n",
    "\n",
    "> Naive Bayes is the name for a family of popular ML algorithms that are often used in text mining. Text mining is a field of ML that deals with extracting quantitative information from text. A simple example of it is the analysis of Twitter feeds in order to predict stock market reactions. There exist different variations of Naive Bayes applications. One is called 'Gaussian Naive Bayes' and works similar to QDA - with the exception that contrary to QDA the covariance matrices $\\Sigma$ are assumed to be diagonal. This means $\\Sigma_k$ only contains the variances of the different features for class $k$. Its covariance terms (the off-diagonal elements) are assumed to be zero. Because of its popularity, Naive Bayes is well documented in text books and on the web. A good starting point is Scikit-learn's tutorial on [Naive Bayes](http://scikit-learn.org/stable/modules/naive_bayes.html), Collins (2013) or Russell and Norvig (2009, p.499). To apply the algorithm in Python you want to use `sklearn.naive_bayes.GaussianNB()` or (for text mining preferably) `sklearn.naive_bayes.MultinomialNB()`. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### QDA in Python\n",
    "\n",
    "The application of QDA follows the one detailed for LDA. Therefore we let the code speak for itself."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "QuadraticDiscriminantAnalysis()"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis as QDA\n",
    "\n",
    "# Run qda on training data\n",
    "qda = QDA().fit(X_train, y_train)\n",
    "qda"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[9636   31]\n",
      " [ 239   94]]\n",
      "0.973\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.98      1.00      0.99      9667\n",
      "           1       0.75      0.28      0.41       333\n",
      "\n",
      "    accuracy                           0.97     10000\n",
      "   macro avg       0.86      0.64      0.70     10000\n",
      "weighted avg       0.97      0.97      0.97     10000\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Predict classes for qda\n",
    "y_pred_qda = qda.predict(X_test)\n",
    "posteriors_qda = qda.predict_proba(X_test)[:, 1]\n",
    "\n",
    "# Print performance metrics\n",
    "print(metrics.confusion_matrix(y_test, y_pred_qda))\n",
    "print(qda.score(X_test, y_test))\n",
    "print(metrics.classification_report(y_test, y_pred_qda))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The performance seems to be slightly better than with LDA. Let's plot the ROC curve for both LDA and QDA."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Compute ROC curve and ROC area (AUC) for each class\n",
    "fpr_qda, tpr_qda, _ = metrics.roc_curve(y_test, posteriors_qda)\n",
    "roc_auc_qda = metrics.auc(fpr_qda, tpr_qda)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(6, 6))\n",
    "plt.plot(fpr, tpr, lw=2, label='LDA ROC (AUC = {0: 0.2f})'.format(roc_auc))\n",
    "plt.plot(fpr_qda, tpr_qda, lw=2, label='QDA ROC (AUC = {0: 0.2f})'.format(roc_auc_qda))\n",
    "plt.plot([0, 1], [0, 1], lw=2, c = 'k', linestyle='--')\n",
    "plt.xlim([-0.01, 1.0])\n",
    "plt.ylim([-0.01, 1.01])\n",
    "plt.xlabel('False Positive Rate (1 - Specificity)')\n",
    "plt.ylabel('True Positive Rate (Sensitivity)')\n",
    "plt.title('ROC Curve', fontweight='bold', fontsize=18)\n",
    "plt.legend(loc=\"lower right\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With respect to Sensitivity (Recall) and Specificity LDA and QDA perform virtually identical. Therefore, one might give the edge here to QDA because of its slighly better Recall and $F_1$-Score. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reality and the Gaussian Assumption for LDA & QDA\n",
    "\n",
    "Despite the rather strict assumptions regarding normal distribution, LDA and QDA perform well on an amazingly large and diverse set of classification tasks. Friedman et al. (2001, p. 111) put it this way:\n",
    "\n",
    "> \"*Both techniques are widely used, and entire books are devoted to LDA. It seems that whatever exotic tools are the rage of the day, we should always have available these two simple tools. The question arises why LDA and QDA have such a good track record. The reason is not likely to be that the data are approximately Gaussian, and in addition for LDA that the covariances are approximately equal. More likely a reason is that the data can only support simple decision boundaries such as linear or quadratic, and the estimates provided via the Gaussian models are stable. This is a bias variance tradeoff - we can put up with the bias of a linear decision boundary because it can be estimated with much lower variance than more exotic alternatives. This argument is less believable for QDA, since it can have many parameters itself - although perhaps fewer than the non-parametric alternatives.*\"\n",
    "\n",
    "Whether LDA or QDA should be applied to categorical/binary features warrants a separate note. It is true that discriminant analysis was designed for continuous features (Ronald A. Fisher (1936)) where the underlying assumption is that the values are normally distributed. However, as above quote shows, studies have proven the robustness of the model even in light of violations of the rather rigid normality assumption. This is not only true for continuous features but also for categorical/binary features. For more details see Huberty et al. (1986). It follows that applying LDA and QDA is possible, though the user should cautiously control the output. We will discuss appropriate cross validation methods to do so in the next chapter. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Further Ressources\n",
    "\n",
    "\n",
    "In writing this notebook, many ressources were consulted. For internet ressources the links are provided within the textflow above and will therefore not be listed again. Beyond these links, the following ressources were consulted and are recommended as further reading on the discussed topics:\n",
    "\n",
    "* Collins, Michael, 2013, The Naive Bayes Model, Maximum-Likelihood Estimation, and the EM Algorithm, Technical report, Columbia University, New York.\n",
    "* Fawcett, Tom, 2006, An introduction to ROC analysis, *Pattern Recognition Letters* 27, 861–874.\n",
    "* Fisher, Roland A., 1936, The Use of Multiple Measurements in Taxonomic Problems, *Annals of Human Genetics* 7, 179-188.\n",
    "* Flach, Peter A., 2017, Roc analysis, in Claude Sammut, and Geoffrey I. Webb, eds., *Encyclopedia of Machine Learning and Data Mining*, 1109–1116 (Springer Science & Business Media, New York, NY).\n",
    "* Friedman, Jerome, Trevor Hastie, and Robert Tibshirani, 2001, *The Elements of Statistical Learning* (Springer, New York, NY).\n",
    "* Guggenbuehler, Jan P., 2015, Predicting Net New Money Using Machine Learning Algorithms and Newspaper Articles, Technical report, University of Zurich, Zurich.\n",
    "* James, Gareth, Daniela Witten, Trevor Hastie, and Robert Tibshirani, 2013, *An Introduction to Statistical Learning: With Applications in R* (Springer Science & Business Media, New York, NY).\n",
    "* Jobson, J. David, and Bob Korkie, 1980, Estimation for Markowitz Efficient Portfolios, *Journal of the American Statistical Association* 75, 544–554.\n",
    "* Hripcsak, George, and Adam S Rothschild, 2005, Agreement, the F-measure, and Reliability in Information Retrieval, *Journal of the American Medical Informatics Association* 12, 296–298.\n",
    "* Huberty, Carl J., Joseph M. Wisenbaker, Jerry D. Smith, and Janet C. Smith, 1986, Using Categorical Variables in Discriminant Analysis, *Multivariate Behavioral Research* 21, 479-496.\n",
    "* Ledoit, Olivier, and Michael Wolf, 2004, Honey, i shrunk the sample covariance matrix, *The Journal of Portfolio Management* 30, 110–119.\n",
    "* Müller, Andreas C., and Sarah Guido, 2017, *Introduction to Machine Learning with Python* (O’Reilly Media, Sebastopol, CA).\n",
    "* Raschka, Sebastian, 2014, Naive Bayes and Text Classification I - Introduction and Theory from website, http://sebastianraschka.com/Articles/2014_naive_bayes_1.html, 08/31/2017\n",
    "* Russell, Stuart, and Peter Norvig, 2009, *Artificial Intelligence: A Modern Approach* (Prentice Hall Press, Upper Saddle River, NJ).\n",
    "* Sokolova, Marina, and Guy Lapalme, 2009, A systematic analysis of performance measures for classification tasks, *Information Processing & Management* 45, 427–437.\n",
    "* Van Rijsbergen, Cornelis Joost, 1979, *Information Retrieval* (Butterworths, London)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Addendum\n",
    "\n",
    "## predict, predict_proba, and decision_function\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us quickly discuss the difference between the \n",
    "* `classifier.predict()`, \n",
    "* `classifier.predict_proba()`, and \n",
    "* `classifier.decision_function()`. \n",
    "\n",
    "`classifier.predict()` we already know: it simply predicts the label given the traineded classifier and a feature matrix X (preferably a test set)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0], dtype=int64)"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lda.predict(X_test)[:10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`classifier.predict_proba()` we have also introduced above: it provides probabilities of $\\Pr(y = 0|X=x)$ in the first column and $\\Pr(y = 1|X=x)$ in the second. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[9.96778003e-01, 3.22199657e-03],\n",
       "       [9.97311835e-01, 2.68816484e-03],\n",
       "       [9.85293824e-01, 1.47061759e-02],\n",
       "       [9.98816468e-01, 1.18353192e-03],\n",
       "       [9.95978476e-01, 4.02152411e-03],\n",
       "       [9.95793515e-01, 4.20648549e-03],\n",
       "       [9.95593550e-01, 4.40644998e-03],\n",
       "       [9.97315195e-01, 2.68480456e-03],\n",
       "       [9.77081674e-01, 2.29183256e-02],\n",
       "       [9.99906164e-01, 9.38359460e-05]])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lda.predict_proba(X_test)[:10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, `classifier.decision_function()` predicts confidence scores given the feature matrix. The confidence scores for a feature matrix is the signed distance of that sample to the hyperplane. What this exaclty means should become more clear once we have discussed the support vector classifier (SVC). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-5.73452686, -5.91620475, -4.20467236, -6.73806793, -5.51206468,\n",
       "       -5.46691242, -5.42026972, -5.91745893, -3.75263341, -9.27386872])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lda.decision_function(X_test)[:10]"
   ]
  }
 ],
 "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}