miniproject_5.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center><h1>Mini Project 5</h1></center>\n",
    "<center><h2>Watchanan Chantapakul (<a href=\"mailto:wcgzm@umsystem.edu\"><code>wcgzm</code></a>)</h2></center>\n",
    "<hr />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This question is to demonstrate that: 1) when the selected model is poor, the maximum-likelihood classifier does not produce satisfactory results; and 2) proper transformation of the data can compensate for poor models. The dataset[<sup>1</sup>](#fn1) used for this question is divided into training[<sup>2</sup>](#fn2) and test[<sup>3</sup>](#fn3) data, with each one consisting of 3 classes in a 2D-feature space.\n",
    "\n",
    "- a) Assuming Gaussian distribution for all three class conditional densities, and with unknown means and covariances, compute the **maximum likelihood estimates** for each class using the training data.\n",
    "- b) Ignore the priors, i.e. assume 1/3 for all three classes, and redo parts a) and b) of MiniProject 2, Question 1, and use those same Matlab functions in part c) below. Use the means and variances from part a) above.\n",
    "- c) Classify the test data and compute the test error using confusion matrix[<sup>4</sup>](#fn4).\n",
    "- d) **Bayesian estimates**. The data has a simpler description when seen in polar coordinates. Use *cart2pol()* to transform all the data points to polar coordinates. Use scatter() to plot the transformed points. What you should find is that the transformed data looks Gaussian on the radius r and uniform on the angle $\\theta$. So, ignore the angle $\\theta$ and classify the test data only on r as\n",
    "follows.\n",
    "\n",
    "The problem is now 1-D and again, if you inspect the data, Gaussian distribution is a more suitable pdf to describe all three classes. Assume then that each class has $p(r|\\omega_i) = \\mathcal{N}(\\mu_i, \\sigma^2)$ with $\\mu_i$ unknown and variance $\\sigma^2 = 0.25$ for all three classes. Let the only prior knowledge about $\\mu_i$ be $p(\\mu_i) = \\mathcal{N}(\\mu_0 = 0, \\sigma_0^2 = 100)$ and compute the Bayes estimates for $\\mu_i$ and the posterior distribution $p(\\mu_i|D_i)$ of all three classes. Next compute $p(r|\\omega_i,D_i) = \\int p(r|\\mu_i) p(\\mu_i|D_i) \\,d\\mu_i$ and use this density estimate to classify the test data and compute the test error using confusion matrix.\n",
    "\n",
    "**Do not forget to comment on the results from each step above.**\n",
    "<br /><br />\n",
    "<span id=\"fn1\"><sup>1</sup> http://vigir.missouri.edu/~gdesouza/ece7720/test_train_data_class3.mat</span><br />\n",
    "<span id=\"fn2\"><sup>2</sup> access the training data by TrainPts = Data.train</span><br />\n",
    "<span id=\"fn3\"><sup>3</sup> access the test data by TestPts = Data.test</span><br />\n",
    "<span id=\"fn4\"><sup>4</sup> http://vigir.missouri.edu/~gdesouza/ece7720/Lecture_Notes/Lecture10.pdf</span><br />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr />"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "\n",
    "import os\n",
    "\n",
    "import numpy as np\n",
    "import sympy\n",
    "import scipy\n",
    "import scipy.io\n",
    "\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib import cm\n",
    "from matplotlib.lines import Line2D\n",
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "\n",
    "from IPython.display import display, Math\n",
    "\n",
    "np.random.seed(7720)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "matplotlib.rcParams[\"figure.dpi\"] = 100\n",
    "matplotlib.rcParams['savefig.dpi'] = 600"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "<style>\n",
       ".jp-RenderedImage {\n",
       "    display: table-cell;\n",
       "    text-align: center;\n",
       "    vertical-align: middle;\n",
       "}\n",
       "</style>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.core.display import HTML\n",
    "HTML(\"\"\"\n",
    "<style>\n",
    ".jp-RenderedImage {\n",
    "    display: table-cell;\n",
    "    text-align: center;\n",
    "    vertical-align: middle;\n",
    "}\n",
    "</style>\n",
    "\"\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def show(text, ans, precision=4):\n",
    "    if type(ans) == np.ndarray:\n",
    "        t = r'\\begin{bmatrix} '\n",
    "        for i in ans:\n",
    "#             print(i, type(i))\n",
    "#             print(r' \\\\ '.join(i))\n",
    "            if type(i) != np.ndarray:\n",
    "                t += f'{i:.4f}' + r' \\\\ '\n",
    "            else:\n",
    "                a_str = np.array2string(i, precision=precision, separator=r' & ')\n",
    "                t += a_str[1:-1]\n",
    "                t += r' \\\\ '\n",
    "        t += r'\\end{bmatrix}'\n",
    "        display(Math(f'{text} = {t}'))\n",
    "    else:\n",
    "        display(Math(f'{text} = {ans:.{precision}f}'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Load data from the `test_train_data_class3.mat` file. The customized `loadmat` function of scipy is needed here as the original `loadmat` function cannot cope with nested dictionaries."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# credit: https://stackoverflow.com/a/29126361/7150241\n",
    "def loadmat(filename):\n",
    "    '''\n",
    "    this function should be called instead of direct spio.loadmat\n",
    "    as it cures the problem of not properly recovering python dictionaries\n",
    "    from mat files. It calls the function check keys to cure all entries\n",
    "    which are still mat-objects\n",
    "    '''\n",
    "    def _check_keys(d):\n",
    "        '''\n",
    "        checks if entries in dictionary are mat-objects. If yes\n",
    "        todict is called to change them to nested dictionaries\n",
    "        '''\n",
    "        for key in d:\n",
    "            if isinstance(d[key], scipy.io.matlab.mio5_params.mat_struct):\n",
    "                d[key] = _todict(d[key])\n",
    "        return d\n",
    "\n",
    "    def _todict(matobj):\n",
    "        '''\n",
    "        A recursive function which constructs from matobjects nested dictionaries\n",
    "        '''\n",
    "        d = {}\n",
    "        for strg in matobj._fieldnames:\n",
    "            elem = matobj.__dict__[strg]\n",
    "            if isinstance(elem, scipy.io.matlab.mio5_params.mat_struct):\n",
    "                d[strg] = _todict(elem)\n",
    "            elif isinstance(elem, np.ndarray):\n",
    "                d[strg] = _tolist(elem)\n",
    "            else:\n",
    "                d[strg] = elem\n",
    "        return d\n",
    "\n",
    "    def _tolist(ndarray):\n",
    "        '''\n",
    "        A recursive function which constructs lists from cellarrays\n",
    "        (which are loaded as numpy ndarrays), recursing into the elements\n",
    "        if they contain matobjects.\n",
    "        '''\n",
    "        elem_list = []\n",
    "        for sub_elem in ndarray:\n",
    "            if isinstance(sub_elem, scipy.io.matlab.mio5_params.mat_struct):\n",
    "                elem_list.append(_todict(sub_elem))\n",
    "            elif isinstance(sub_elem, np.ndarray):\n",
    "                elem_list.append(_tolist(sub_elem))\n",
    "            else:\n",
    "                elem_list.append(sub_elem)\n",
    "        return elem_list\n",
    "    data = scipy.io.loadmat(filename, struct_as_record=False, squeeze_me=True)\n",
    "    return _check_keys(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "mat = loadmat(os.path.join(\"data\", \"test_train_data_class3.mat\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['test', 'train'])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mat['Data'].keys()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The stored `Data` variable contains two subsets including *test* and *train*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_mat = mat['Data']['train']\n",
    "test_mat = mat['Data']['test']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We dig deeper into the number of classes and the number of dimensions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C = 3 classes\n",
      "d = 2 dimensions\n"
     ]
    }
   ],
   "source": [
    "C = len(train_mat)\n",
    "d = len(train_mat[0])\n",
    "print(f'C = {C} classes')\n",
    "print(f'd = {d} dimensions')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_data, test_data = [], []\n",
    "\n",
    "for c in range(C):\n",
    "    train_data.append(np.array(train_mat[c]).T)\n",
    "    test_data.append(np.array(test_mat[c]).T)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[train]\tclass 1 = 30 samples\n",
      "[test]\tclass 1 = 70 samples\n",
      "------------------------------\n",
      "[train]\tclass 2 = 50 samples\n",
      "[test]\tclass 2 = 94 samples\n",
      "------------------------------\n",
      "[train]\tclass 3 = 20 samples\n",
      "[test]\tclass 3 = 46 samples\n",
      "------------------------------\n"
     ]
    }
   ],
   "source": [
    "for c in range(C):\n",
    "    print(f'[train]\\tclass {c+1} = {len(train_data[c])} samples')\n",
    "    print(f'[test]\\tclass {c+1} = {len(test_data[c])} samples')\n",
    "    print('-' * 30)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data Visualization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_2d_features(data, mu=None, cov=None, title=\"\", x_label=\"$x_1$\", y_label=\"$x_2$\"):\n",
    "    sample_colors = ('deepskyblue', 'hotpink', 'mediumseagreen')\n",
    "    sample_markers = ('o', 's', '^')\n",
    "    mean_colors = ('blue', 'deeppink', 'green')\n",
    "\n",
    "    fig, ax = plt.subplots(figsize=(8, 8))\n",
    "\n",
    "    for c in range(C):\n",
    "        # samples\n",
    "        ax.scatter(data[c][:, 0], data[c][:, 1], color=sample_colors[c], marker=sample_markers[c], label=f\"$\\omega_{c+1}$\")\n",
    "        \n",
    "        # means\n",
    "        if mu is not None:\n",
    "            ax.scatter(mu[c][0], mu[c][1], color=mean_colors[c], marker='X', s=100, edgecolor='black', label=r\"$\\vec{\\mu}_\" + str(c+1) + \"$\")\n",
    "\n",
    "        # covariances\n",
    "        if cov is not None:\n",
    "            eigval, eigvec = np.linalg.eig(cov[c])\n",
    "            std_values = eigval\n",
    "\n",
    "            major_idx = np.argmax(eigval)\n",
    "            minor_idx = 1 if major_idx == 0 else 0\n",
    "\n",
    "            alpha = np.arctan2(eigvec[1, major_idx], eigvec[0, major_idx])\n",
    "            major_r_x = std_values[major_idx]\n",
    "            major_r_y = std_values[minor_idx]\n",
    "\n",
    "            theta = np.linspace(0, 2*np.pi, 100)\n",
    "            mean_x, mean_y = mu[c]\n",
    "            e_X = major_r_x * np.cos(theta) * np.cos(alpha) - major_r_y * np.sin(theta) * np.sin(alpha) + mean_x\n",
    "            e_Y = major_r_x * np.cos(theta) * np.sin(alpha) + major_r_y * np.sin(theta) * np.cos(alpha) + mean_y\n",
    "            ax.plot(e_X, e_Y, color=mean_colors[c], linestyle=\"--\")\n",
    "\n",
    "            # legends\n",
    "            handles, labels = ax.get_legend_handles_labels()\n",
    "            handles.append(Line2D([0], [0], color=\"gray\", linewidth=3, linestyle='--'))\n",
    "            labels.append(\"$\\sigma_{j}^2$\")\n",
    "\n",
    "    ax.set_title(title, fontsize=14)\n",
    "    ax.set_xlabel(x_label, fontsize=14)\n",
    "    ax.set_ylabel(y_label, fontsize=14)\n",
    "    ax.set_aspect(1)\n",
    "    if cov is None:\n",
    "        handles, labels = ax.get_legend_handles_labels()\n",
    "    ax.legend(handles, labels, loc='center left', bbox_to_anchor=(1, 0.5), prop={'size': 12})\n",
    "\n",
    "    plt.close(fig)\n",
    "    return fig"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 800x800 with 1 Axes>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot_2d_features(train_data, title=\"Training samples in Cartesian coordinates\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Maximum Likelihood Estimation (MLE)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Assume that the **class-conditional densities** $p(\\mathbf{x}|\\omega_i)$ are in the form of Gaussian distribution with unknown parameters, means $\\mathbf{\\mu}_i$ and covariance matrices $\\mathbf{\\Sigma}_i$. But we can estimate those parameters by using a method called maximum likelihood estimation (MLE) on the given training data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From the training data, we have $C=3$ classes. Thus, there are 3 sets, $D_1, D_2,$ and $D_3$. All samples in each set are i.i.d. (independent and identically distributed). Also, we use the samples in $D_i$ only to estimate $\\theta_i$ without interfering with other classes.\n",
    "\n",
    "There are $n_i$ samples, $x_1, \\dots, x_{n_i}$, in $D_i$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Log-likelihood $\\ln p(x_k | \\mathbf{\\theta})$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since the data are in 2D space, the class-conditional densities are **multivariate Gaussian** distribution with the following parameters $\\vec{\\theta}$:\n",
    "- $\\theta_1 = \\mu$ (mean)\n",
    "- $\\theta_2 = \\Sigma$ (covariance matrix)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Our log-likelihood $\\ln p(x_k | \\vec{\\theta})$ of a single sample $x_k$ is then defined as:\n",
    "\n",
    "$$\n",
    "\\ln p(x_k | \\vec{\\theta}) = -\\frac{1}{2}(x_k-\\mu_i)^\\mathsf{T}\\Sigma_i^{-1}(x_k-\\mu_i) -\\frac{d}{2}\\ln (2\\pi) - \\frac{1}{2} \\ln |\\Sigma_i| + \\ln P(\\omega_i)\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def log_likelihood(x, mean, cov, prior):\n",
    "    d = len(x)\n",
    "    A = -0.5 * ((mahalanobis_distance(x, mean, cov)) ** 2)\n",
    "    B = - ((d/2) * np.log(2 * np.pi))\n",
    "    C = - (0.5 * np.log(determinant(cov))) + np.log(prior)\n",
    "    return A + B + C"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Log-likelihood $l$ of the dataset $D = [x_1, \\dots, x_{n_i}]$ is:\n",
    "$$\n",
    "l(\\vec{\\theta}) = \\sum_{k=1}^{n} \\ln p(x_k | \\vec{\\theta})\n",
    "$$\n",
    "\n",
    "We arrive at the gradients or the derivatives of the log-likelihood $l$ w.r.t. $\\vec{\\theta} = [\\theta_1\\ \\theta_2]^{\\mathsf{T}}$ as follows:\n",
    "$$\n",
    "\\nabla_{\\vec{\\theta}} l = \\sum_{k=1}^{n} \\nabla_{\\vec{\\theta}} \\ln p(x_k | \\vec{\\theta})\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To estimate $\\vec{\\theta}$, we set the gradients to be zero to obtain the maximum likelihood estimate of $\\vec{\\theta}$,\n",
    "$$\n",
    "\\nabla_{\\vec{\\theta}} l = \\vec{0}\n",
    "$$\n",
    "\n",
    "\n",
    "$$\n",
    "\\nabla_{\\vec{\\theta}} l = \n",
    "\\begin{bmatrix}\n",
    "\\frac{\\partial l}{\\partial \\theta_1}\\\\\n",
    "\\frac{\\partial l}{\\partial \\theta_2}\n",
    "\\end{bmatrix}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "#### Estimate $\\theta_1 = \\mu$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\n",
    "\\frac{\\partial l}{\\partial \\theta_1}\n",
    "= \\frac{\\partial l}{\\partial \\mu}\n",
    "= \\frac{\\partial}{\\partial \\mu} \\left( \\sum_{k=1}^{n} -\\frac{1}{2}(x_k-\\mu_i)^\\mathsf{T}\\Sigma_i^{-1}(x_k-\\mu_i) \\right)\n",
    "= \\vec{0}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\n",
    "\\frac{\\partial}{\\partial \\mu} \\left( \\sum_{k=1}^{n} (x_k-\\mu_i)^\\mathsf{T}\\Sigma_i^{-1}(x_k-\\mu_i) \\right)\n",
    "= \\vec{0}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\n",
    "\\frac{\\partial}{\\partial \\mu} \\left( \\sum_{k=1}^{n}\n",
    "(x_k^{\\mathsf{T}}\\Sigma_i^{-1}-\\mu_i^{\\mathsf{T}}\\Sigma_i^{-1}) (x_k-\\mu_i)\n",
    "\\right)\n",
    "= \\vec{0}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\n",
    "\\frac{\\partial}{\\partial \\mu} \\left( \\sum_{k=1}^{n}\n",
    "(x_k^{\\mathsf{T}}\\Sigma_i^{-1}x_k - 2\\mu_i^{\\mathsf{T}}\\Sigma_i^{-1}x_k + \\mu_i^{\\mathsf{T}} \\Sigma_i^{-1} \\mu_i)\n",
    "\\right)\n",
    "= \\vec{0}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\n",
    "\\sum_{k=1}^{n}\n",
    "(0 - 2\\Sigma_i^{-1}x_k + 2 \\Sigma_i^{-1} \\mu_i)\n",
    "= \\vec{0}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\n",
    "\\sum_{k=1}^{n}\n",
    "(- \\Sigma_i^{-1}x_k + \\Sigma_i^{-1} \\mu_i)\n",
    "= \\vec{0}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\n",
    "\\sum_{k=1}^{n}\n",
    "(\\Sigma_i^{-1} \\mu_i - \\Sigma_i^{-1}x_k)\n",
    "= \\vec{0}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\n",
    "\\sum_{k=1}^{n}\n",
    "\\left(\\Sigma_i^{-1} (\\mu_i - x_k) \\right)\n",
    "= \\vec{0}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\n",
    "\\Sigma_i^{-1}\n",
    "\\sum_{k=1}^{n}\n",
    "\\left(\\mu_i - x_k \\right)\n",
    "= \\vec{0}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Multiplying both sides by $\\Sigma$,\n",
    "$$\n",
    "\\sum_{k=1}^{n}\n",
    "\\left(\\mu_i - x_k \\right)\n",
    "= \\vec{0}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\n",
    "n \\mu_i - \\sum_{k=1}^{n} x_k\n",
    "= \\vec{0}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\n",
    "\\mu_i = \\frac{1}{n} \\sum_{k=1}^{n} x_k\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_mean(X, axis=0):\n",
    "    return np.sum(X, axis=axis) / len(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\vec{\\mu}_1 = \\begin{bmatrix} 0.2754 \\\\ -0.1763 \\\\ \\end{bmatrix}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\vec{\\mu}_2 = \\begin{bmatrix} 0.3218 \\\\ 0.2207 \\\\ \\end{bmatrix}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\vec{\\mu}_3 = \\begin{bmatrix} 0.5813 \\\\ 0.4961 \\\\ \\end{bmatrix}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "mu = np.zeros((C, d))\n",
    "for c in range(C):\n",
    "    mu[c] = compute_mean(train_data[c])\n",
    "    show(r'\\vec{\\mu}_' + str(c+1), mu[c])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\mathrm{Numpy}\\ \\vec{\\mu}_1 = \\begin{bmatrix} 0.2754 \\\\ -0.1763 \\\\ \\end{bmatrix}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\mathrm{Numpy}\\ \\vec{\\mu}_2 = \\begin{bmatrix} 0.3218 \\\\ 0.2207 \\\\ \\end{bmatrix}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\mathrm{Numpy}\\ \\vec{\\mu}_3 = \\begin{bmatrix} 0.5813 \\\\ 0.4961 \\\\ \\end{bmatrix}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "np_mu = np.zeros((C, d))\n",
    "for c in range(C):\n",
    "    np_mu[c] = np.mean(train_data[c], axis=0)\n",
    "    show(r'\\mathrm{Numpy}\\ \\vec{\\mu}_' + str(c+1), np_mu[c])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "np.mean == compute_mean? True\n"
     ]
    }
   ],
   "source": [
    "print(\"np.mean == compute_mean?\", np.allclose(np_mu, mu))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "#### Estimate $\\theta_2 = \\Sigma$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is a biased estimate for a covariance matrix $\\Sigma_i$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\n",
    "\\frac{\\partial l}{\\partial \\theta_2}\n",
    "= \\frac{\\partial l}{\\partial \\Sigma}\n",
    "= \\frac{\\partial}{\\partial \\Sigma} \\left( \\sum_{k=1}^{n} \\left( -\\frac{1}{2}(x_k-\\mu_i)^\\mathsf{T}\\Sigma_i^{-1}(x_k-\\mu_i) - \\frac{1}{2} \\ln |\\Sigma_i| \\right) \\right)\n",
    "= \\vec{0}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\n",
    "\\frac{\\partial}{\\partial \\Sigma} \\left( \\sum_{k=1}^{n} \\left( (x_k-\\mu_i)^\\mathsf{T}\\Sigma_i^{-1}(x_k-\\mu_i) + \\ln |\\Sigma_i| \\right) \\right)\n",
    "= \\vec{0}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As the determinant of the inverse of a matrix is the inverse of the determinant, we arrive at:\n",
    "\n",
    "$$\n",
    "\\frac{\\partial}{\\partial \\Sigma} \\left( \\sum_{k=1}^{n} \\left( (x_k-\\mu_i)^\\mathsf{T}\\Sigma_i^{-1}(x_k-\\mu_i) + \\ln |\\Sigma_i^{-1}| \\right) \\right)\n",
    "= \\vec{0}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\n",
    "\\sum_{k=1}^{n} \\left( -(x_k-\\mu_i)(x_k-\\mu_i)^\\mathsf{T} + \\frac{1}{\\Sigma_i^{-1}} \\right)\n",
    "= \\vec{0}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\n",
    "- \\sum_{k=1}^{n} \\left((x_k-\\mu_i)(x_k-\\mu_i)^\\mathsf{T} \\right) + n\\Sigma_i\n",
    "= \\vec{0}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Thus, we can estimate a covariance matrix $\\Sigma_i$ with\n",
    "\n",
    "$$\n",
    "\\Sigma_i\n",
    "= \\frac{1}{n} \\sum_{k=1}^{n} \\left((x_k-\\mu_i)(x_k-\\mu_i)^\\mathsf{T} \\right) \n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def transpose(m):\n",
    "    if type(m[0]) not in (list, np.ndarray):\n",
    "        return m\n",
    "    return list(map(list,zip(*m)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_covariance_matrix(X, mean, bias_term=0):\n",
    "    cov = np.zeros((len(mean), len(mean)))\n",
    "    for x in X:\n",
    "        a = np.array(x) - np.array(mean)\n",
    "        cov += a[:, None] @ transpose(a)[None, :]\n",
    "    cov /= len(X) - bias_term\n",
    "    return cov"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\mathbf{\\Sigma}_1 = \\begin{bmatrix}  1.1624 & -0.0383 \\\\ -0.0383 &  0.6878 \\\\ \\end{bmatrix}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\mathbf{\\Sigma}_2 = \\begin{bmatrix} 2.7287 & 0.1974 \\\\ 0.1974 & 3.6929 \\\\ \\end{bmatrix}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\mathbf{\\Sigma}_3 = \\begin{bmatrix}  5.2658 & -0.4554 \\\\ -0.4554 &  6.5497 \\\\ \\end{bmatrix}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "cov = np.zeros((C, d, d))\n",
    "for c in range(C):\n",
    "    cov[c] = compute_covariance_matrix(train_data[c], mu[c])\n",
    "    show(r'\\mathbf{\\Sigma}_' + str(c+1), cov[c])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cross-check with the Numpy's built-in function `np.cov`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\mathrm{Numpy}\\ \\mathbf{\\Sigma}_1 = \\begin{bmatrix}  1.1624 & -0.0383 \\\\ -0.0383 &  0.6878 \\\\ \\end{bmatrix}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\mathrm{Numpy}\\ \\mathbf{\\Sigma}_2 = \\begin{bmatrix} 2.7287 & 0.1974 \\\\ 0.1974 & 3.6929 \\\\ \\end{bmatrix}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\mathrm{Numpy}\\ \\mathbf{\\Sigma}_3 = \\begin{bmatrix}  5.2658 & -0.4554 \\\\ -0.4554 &  6.5497 \\\\ \\end{bmatrix}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "np_cov = np.zeros((C, d, d))\n",
    "for c in range(C):\n",
    "    np_cov[c] = np.cov(train_data[c].T, bias=True)\n",
    "    show(r'\\mathrm{Numpy}\\ \\mathbf{\\Sigma}_' + str(c+1), np_cov[c])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[biased] np.cov == compute_covariance_matrix? True\n"
     ]
    }
   ],
   "source": [
    "print(\"[biased] np.cov == compute_covariance_matrix?\", np.allclose(np_cov, cov))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 800x800 with 1 Axes>"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot_2d_features(train_data, mu, cov, title=\"Training samples in Cartesian coordinates\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Classification"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mahalanobis Distance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$ r = \\sqrt{(\\vec{x} - \\vec{y})^{\\mathsf{T}} \\mathbf{\\Sigma}^{-1} (\\vec{x} - \\vec{y})} $$\n",
    "\n",
    "In this case, we can substitute $\\vec{y}$ with the mean and the covariance matrix of class $i$, so we get:\n",
    "\n",
    "$$ r = \\sqrt{(\\vec{x} - \\vec{\\mu}_i)^{\\mathsf{T}} \\mathbf{\\Sigma_i}^{-1} (\\vec{x} - \\vec{\\mu}_i)} $$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def determinant(A):\n",
    "    if len(A) == 2:\n",
    "        det = (A[0][0] * A[1][1]) - (A[1][0] * A[0][1])\n",
    "        return det"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "def inverse_matrix(A):\n",
    "    if len(A) == 2:\n",
    "        inv_A = [\n",
    "            [A[1][1], -A[0][1]],\n",
    "            [-A[1][0], A[0][0]]\n",
    "        ]\n",
    "        return np.array(inv_A) / determinant(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mahalanobis_distance(x, y, cov):\n",
    "    a = np.array(x) - np.array(y)\n",
    "    r2 = transpose(a) @ inverse_matrix(cov) @ a\n",
    "    return np.sqrt(r2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "#### Classification Rule"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We predict the class of a sample $\\vec{x}$ based on the minimum Mahalanobis distance:\n",
    "\n",
    "$$\n",
    "\\hat{y}(\\vec{x}) = \\operatorname*{argmin}_{i} r_i(\\vec{x})\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "confusion_matrix = np.zeros((C, C))\n",
    "\n",
    "for c in range(C):\n",
    "    for x in test_data[c]:\n",
    "        distances = np.zeros(C)\n",
    "        for i in range(C):\n",
    "            distances[i] = mahalanobis_distance(x, mu[i], cov[i])\n",
    "        pred_class = np.argmin(distances)\n",
    "        confusion_matrix[c][pred_class] += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.,  9., 60.],\n",
       "       [ 0.,  0., 94.],\n",
       "       [ 0.,  0., 46.]])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "confusion_matrix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| | (predicted) 1 | (predicted) 2 | (predicted) 3 |\n",
    "| :-: | :-: | :-: | :-: |\n",
    "|<b>(actual) 1</b>|1|9|60|\n",
    "|<b>(actual) 2</b>|0|0|94|\n",
    "|<b>(actual) 3</b>|0|0|46|\n",
    "<center>Table 1: Confusion matrix of the model with the estimated parameter $\\mu_i$ and <strong>biased</strong> $\\Sigma_i$ using Maximum Likelihood Estimation, and classifying based on <strong>Mahalanobis distance</strong></center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The confusion matrix from using Mahalanobis distance only does not look promising. The test samples are mostly classified as class 3. Some interesting points are:\n",
    "\n",
    "- The test samples from class 1 are mostly misclassified as class 3, some are misclasslfieid as class 2.\n",
    "- Only 1 test samples from class 1 are correctly classified.\n",
    "- The test samples from class 2 are all misclassified as class 3.\n",
    "- The test samples from class 3 are all classified correctly.\n",
    "\n",
    "The reason would be we just take only means $\\mu_i$ and the inverse of covariance matrices $\\Sigma_i^{-1}$ into account. All means are very close together. The dominant factor then is the covariance matrix of class 3. The class 3 covers most of the area as shown in the scatter plot above.\n",
    "\n",
    "Thus, we are moving on to discriminant function as our classification criterion."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Discriminant function $g_i(\\cdot)$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since we don't know anything a priori, the **priors** $P(\\omega_i)$ for all classes are uninformative or equally probable with probability of $\\frac{1}{3}$ each."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "priors = [1/3, 1/3, 1/3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From MiniProject 2, the discriminant function with the following generic form is given by:\n",
    "$$ g_i(x) = -\\frac{1}{2}(x-\\mu_i)^t\\Sigma_i^{-1}(x-\\mu_i)-\\frac{d}{2}\\ln (2\\pi) - \\frac{1}{2} \\ln |\\Sigma_i| + \\ln P(\\omega_i) $$\n",
    "also for any given $d$ dimensional data, mean, covariance matrix and prior probabilities.\n",
    "\n",
    "<u>Note</u>: these below functions are from MiniProject 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "def discriminant_fx(x, mean, cov, prior):\n",
    "    d = len(x)\n",
    "    A = -0.5 * ((mahalanobis_distance(x, mean, cov)) ** 2)\n",
    "    B = - ((d/2) * np.log(2 * np.pi))\n",
    "    C = - (0.5 * np.log(determinant(cov))) + np.log(prior)\n",
    "    return A + B + C"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "#### Classification Rule"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We predict the class of a sample $\\vec{x}$ based on the following equation:\n",
    "\n",
    "$$\n",
    "\\hat{y}(\\vec{x}) = \\operatorname*{argmax}_{i} g_i(\\vec{x})\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "confusion_matrix = np.zeros((C, C))\n",
    "\n",
    "for c in range(C):\n",
    "    for x in test_data[c]:\n",
    "        g = np.zeros(C)\n",
    "        for i in range(C):\n",
    "            g[i] = discriminant_fx(x, mu[i], cov[i], priors[i])\n",
    "        pred_class = np.argmax(g)\n",
    "        confusion_matrix[c][pred_class] += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Confusion Matrix\n",
    "\n",
    "Confusion matrix is a tool that we can use to see the performance of a classifier. It is simply a table."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[59., 11.,  0.],\n",
       "       [15., 61., 18.],\n",
       "       [ 0.,  7., 39.]])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "confusion_matrix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| | (predicted) 1 | (predicted) 2 | (predicted) 3 |\n",
    "| :-: | :-: | :-: | :-: |\n",
    "|<b>(actual) 1</b>|59|11|0|\n",
    "|<b>(actual) 2</b>|15|61|18|\n",
    "|<b>(actual) 3</b>|0|7|39|\n",
    "<center>Table 2: Confusion matrix of the model with the estimated parameter $\\mu_i$ and $\\Sigma_i$ using Maximum Likelihood Estimation, and classifying based on <strong>discriminant function</strong></center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "According to the confusion matrix shown above, most of the samples are classified correctly. They are placed in the diagonal of the confusion matrix. On the other hand, there are misclassified samples that are off-diagonal of the confusion matrix.\n",
    "\n",
    "- 11 samples are classified as class 2 but actually they are from class 1\n",
    "- 15 samples are classified as class 1 but actually they are from class 2\n",
    "- 7 samples are classified as class 2 but actually they are from class 3\n",
    "\n",
    "No samples of class 1 are misclassified as class 3, and vice versa. The reason is the class 1 samples are compact and are in the most inner part as opposed to the class 3 samples. If they will be misclassified, they should be classified as class 2 more than class 3."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can compute an accuracy out of the confusion matrix $\\mathbf{CM}$ as follows:\n",
    "\n",
    "$$\n",
    "\\mathrm{Accuracy}\n",
    "= \\operatorname{tr}(\\mathbf{CM})\n",
    "= \\frac{\\sum_{i=1}^{C} \\mathbf{CM}_{ii}}{\\sum_{i=1}^{C}\\sum_{j=1}^{C} \\mathbf{CM}_{ij}}\n",
    "= \\frac{1}{N} \\sum_{i=1}^{C} \\mathbf{CM}_{ii}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Obviously, we can also calculate an error by subtracting the accuracy from 1.\n",
    "\n",
    "$$\n",
    "\\mathrm{Error} = 1 - \\mathrm{Accuracy}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\mathrm{Test\\ Accuracy} = 0.7571$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\mathrm{Test\\ Error} = 0.2429$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "accuracy = confusion_matrix.trace() / confusion_matrix.sum()\n",
    "error = 1 - accuracy\n",
    "\n",
    "show('\\mathrm{Test\\ Accuracy}', accuracy)\n",
    "show('\\mathrm{Test\\ Error}', error)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can achieve the test accuracy of up to $75.71\\%$ which also results in the test error of $24.29\\%$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Unbiased Covariance Matrix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since the above case, the estimated covariance matrices are biased by nature. It is also interesting to see how unbiased covariance matrices differ from the biased ones. Thus, we can estimate an unbiased covariance matrix $\\Sigma_i$ with"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "$$\n",
    "\\Sigma_i\n",
    "= \\frac{1}{n-1} \\sum_{k=1}^{n} \\left((x_k-\\mu_i)(x_k-\\mu_i)^\\mathsf{T} \\right) \n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\mathrm{Unbiased}\\ \\mathbf{\\Sigma}_1 = \\begin{bmatrix}  1.2025 & -0.0396 \\\\ -0.0396 &  0.7115 \\\\ \\end{bmatrix}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\mathrm{Unbiased}\\ \\mathbf{\\Sigma}_2 = \\begin{bmatrix} 2.7844 & 0.2014 \\\\ 0.2014 & 3.7683 \\\\ \\end{bmatrix}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\mathrm{Unbiased}\\ \\mathbf{\\Sigma}_3 = \\begin{bmatrix}  5.5429 & -0.4794 \\\\ -0.4794 &  6.8944 \\\\ \\end{bmatrix}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "unbiased_cov = np.zeros((C, d, d))\n",
    "for c in range(C):\n",
    "    unbiased_cov[c] = compute_covariance_matrix(train_data[c], mu[c], bias_term=1)\n",
    "    show(r'\\mathrm{Unbiased}\\ \\mathbf{\\Sigma}_' + str(c+1), unbiased_cov[c])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\mathrm{Unbiased\\ Numpy}\\ \\mathbf{\\Sigma}_1 = \\begin{bmatrix}  1.2025 & -0.0396 \\\\ -0.0396 &  0.7115 \\\\ \\end{bmatrix}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\mathrm{Unbiased\\ Numpy}\\ \\mathbf{\\Sigma}_2 = \\begin{bmatrix} 2.7844 & 0.2014 \\\\ 0.2014 & 3.7683 \\\\ \\end{bmatrix}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\mathrm{Unbiased\\ Numpy}\\ \\mathbf{\\Sigma}_3 = \\begin{bmatrix}  5.5429 & -0.4794 \\\\ -0.4794 &  6.8944 \\\\ \\end{bmatrix}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "np_unbiased_cov = np.zeros((C, d, d))\n",
    "for c in range(C):\n",
    "    np_unbiased_cov[c] = np.cov(train_data[c].T, bias=False)\n",
    "    show(r'\\mathrm{Unbiased\\ Numpy}\\ \\mathbf{\\Sigma}_' + str(c+1), np_unbiased_cov[c])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[unbiased] np.cov == compute_covariance_matrix? True\n"
     ]
    }
   ],
   "source": [
    "print(\"[unbiased] np.cov == compute_covariance_matrix?\", np.allclose(np_unbiased_cov, unbiased_cov))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "unbiased_confusion_matrix = np.zeros((C, C))\n",
    "\n",
    "for c in range(C):\n",
    "    for x in test_data[c]:\n",
    "        g = np.zeros(C)\n",
    "        for i in range(C):\n",
    "            g[i] = discriminant_fx(x, mu[i], unbiased_cov[i], priors[i])\n",
    "        pred_class = np.argmax(g)\n",
    "        unbiased_confusion_matrix[c][pred_class] += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[59., 11.,  0.],\n",
       "       [17., 62., 15.],\n",
       "       [ 0.,  7., 39.]])"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "unbiased_confusion_matrix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| | (predicted) 1 | (predicted) 2 | (predicted) 3 |\n",
    "| :-: | :-: | :-: | :-: |\n",
    "|<b>(actual) 1</b>|59|11|0|\n",
    "|<b>(actual) 2</b>|15|61|18|\n",
    "|<b>(actual) 3</b>|0|7|39|\n",
    "<center>Table 3: Confusion matrix of the model with the estimated parameter $\\mu_i$ and <strong>unbiased</strong> $\\Sigma_i$ using Maximum Likelihood Estimation, and classifying based on <strong>discriminant function</strong></center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Well, the results from using biased and unbiased covariance matrices are different a little bit. Again, no samples of class 1 are misclassified as class 3, and vice versa.\n",
    "\n",
    "Some noticeable changes are as follows:\n",
    "\n",
    "- The number of samples are classified as class 1 but actually they are from class 2: changed from 15 to 17\n",
    "- The number of samples are classified as class 2 and actually they are from class 2: increased from 61 to 62\n",
    "- The number of samples are classified as class 3 but actually they are from class 2: changed from 18 to 15\n",
    "\n",
    "Obviously, the test samples that are affected are only from class 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\mathrm{[Unbiased]\\ Test\\ Accuracy} = 0.7619$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\mathrm{[Unbiased]\\ Test\\ Error} = 0.2381$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "unbiased_accuracy = unbiased_confusion_matrix.trace() / unbiased_confusion_matrix.sum()\n",
    "unbiased_error = 1 - unbiased_accuracy\n",
    "\n",
    "show('\\mathrm{[Unbiased]\\ Test\\ Accuracy}', unbiased_accuracy)\n",
    "show('\\mathrm{[Unbiased]\\ Test\\ Error}', unbiased_error)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Well, the good news is the test accuracy from using the unbiased covariance matrices are increased by $0.48\\%$ (from $75.71\\%$ to $76.19\\%$). Therefore, the test error also decreases by the same amount."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Bayesian Estimation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, we transform the data by converting them from Cartesian Coordinates $(x, y)$ to Polar Coordinates $(r, \\theta)$ using the `cart2pol` function below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cart2pol(x, y):\n",
    "    rho = np.sqrt(x**2 + y**2)\n",
    "    theta = np.arctan2(y, x)\n",
    "    return rho, theta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "transformed_train_data, transformed_test_data = [], []\n",
    "\n",
    "for c in range(C):\n",
    "    rho, theta = cart2pol(train_data[c][:, 0], train_data[c][:, 1])\n",
    "    transformed_train_data.append(np.vstack((rho, theta)).T)\n",
    "    \n",
    "    rho, theta = cart2pol(test_data[c][:, 0], test_data[c][:, 1])\n",
    "    transformed_test_data.append(np.vstack((rho, theta)).T)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's visualize the transformed training samples in polar coordinates. The scatter plot of them are shown below. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 800x800 with 1 Axes>"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot_2d_features(transformed_train_data, x_label=\"$r$\", y_label=r\"$\\theta$\", title=\"Training samples in polar coordinates\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ditch the dimension of $\\theta$, we are now interested in the dimension of $r$ only. The reason is we cannot use the information of $\\theta$ to distinguish the samples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_1d_feature(data, is_sort=False):\n",
    "    sample_colors = ('deepskyblue', 'hotpink', 'mediumseagreen')\n",
    "    sample_markers = ('o', 's', '^')\n",
    "    \n",
    "    fig, ax = plt.subplots(figsize=(8, 2))\n",
    "\n",
    "    for c in range(C):\n",
    "        X = data[c][:, 0]\n",
    "        if is_sort:\n",
    "            X = np.sort(X)\n",
    "            offsets = np.arange(0, len(X), 1) * 0.001\n",
    "        else:\n",
    "            offsets = 0\n",
    "        ax.scatter(X, np.zeros_like(X) + offsets, color=sample_colors[c], edgecolor=\"black\", linewidth=0.4, alpha=0.7, marker=sample_markers[c], label=f\"$\\omega_{c+1}$\")\n",
    "\n",
    "    ax.get_yaxis().set_ticks([])\n",
    "    for side in (\"left\", \"right\", \"top\"):\n",
    "        ax.spines[side].set_visible(False)\n",
    "\n",
    "    ax.set_title(\"Training samples in polar coordinates\", fontsize=14)\n",
    "    ax.set_xlabel(\"$r$\", fontsize=14)\n",
    "    ax.set_ylim(-0.025, 0.08)\n",
    "    ax.legend(loc='center left', bbox_to_anchor=(1, 0.5), prop={'size': 12})\n",
    "\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 800x200 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_1d_feature(transformed_train_data, is_sort=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We only have one axis (1-d) data, but for the sake of visualization, the height of each sample is added. This allows us to see some overlapped samples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 800x200 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_1d_feature(transformed_train_data, is_sort=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Assume that each class has the following properties:\n",
    "\n",
    "- $p(r|\\omega_i) \\sim \\mathcal{N}(\\mu_i, \\sigma^2)$\n",
    "- Unknown $\\mu_i$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Known variance $\\sigma^2 = 0.25$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "var = 0.25"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Prior $p(\\mu_i) \\sim \\mathcal{N}(\\mu_0 = 0, \\sigma_0^2 = 100)$ "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "prior_mu = [0, 0, 0]\n",
    "prior_var = [100, 100, 100]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The Desired Class-conditional Density $p(r | \\omega_i, D_i)$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\n",
    "p(r|\\omega_i,D_i) = \\int p(r|\\mu_i) p(\\mu_i|D_i) \\,d\\mu_i\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we know from the question that,\n",
    "$$\n",
    "p(r|\\mu_i) \\sim \\mathcal{N}(\\mu_i, \\sigma^2)\n",
    "$$\n",
    "\n",
    "This means that a posteriori density $p(\\mu_i | \\mathcal{D}_i)$ is the only term that we need to derive."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\n",
    "\\begin{align*}\n",
    "p(\\mu | \\mathcal{D})\n",
    "&= \\frac{p(\\mathcal{D} | \\mu) p(\\mu)}{\\int p(\\mathcal{D} | \\mu) p(\\mu) d\\,\\mu}\\\\\n",
    "&= \\frac{\\prod_{k=1}^{n} p(\\mathcal{x_k} | \\mu) p(\\mu)}{\\int \\prod_{k=1}^{n} p(\\mathcal{x_k} | \\mu) p(\\mu) d\\,\\mu}\\\\\n",
    "&= \\alpha \\prod_{k=1}^{n} p(\\mathcal{x_k} | \\mu) p(\\mu)\\\\\n",
    "\\end{align*}\n",
    "$$\n",
    "\n",
    "We have the constant $\\alpha$ that represents a normalization factor (integration in the denominator) since it does not depend on $\\mu$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\n",
    "\\begin{align*}\n",
    "p(\\mu | \\mathcal{D})\n",
    "&= \\alpha \\prod_{k=1}^{n} p(\\mathcal{x_k} | \\mu) \\cdot p(\\mu)\\\\\n",
    "&= \\alpha \\prod_{k=1}^{n} \\frac{1}{\\sqrt{2 \\pi} \\sigma} e^{-\\frac{1}{2} \\left( \\frac{x_k - \\mu}{\\sigma} \\right)^2} \\cdot \\frac{1}{\\sqrt{2 \\pi} \\sigma_0} e^{-\\frac{1}{2} \\left( \\frac{\\mu - \\mu_0}{\\sigma_0} \\right)^2}\\\\\n",
    "&= \\alpha \\frac{1}{\\sqrt{2 \\pi} \\sigma} \\frac{1}{\\sqrt{2 \\pi} \\sigma_0} \\prod_{k=1}^{n} e^{-\\frac{1}{2} \\left( \\frac{x_k - \\mu}{\\sigma} \\right)^2} \\cdot e^{-\\frac{1}{2} \\left( \\frac{\\mu - \\mu_0}{\\sigma_0} \\right)^2}\\\\\n",
    "&= \\alpha' \\prod_{k=1}^{n} e^{-\\frac{1}{2} \\left( \\frac{x_k - \\mu}{\\sigma} \\right)^2} \\cdot e^{-\\frac{1}{2} \\left( \\frac{\\mu - \\mu_0}{\\sigma_0} \\right)^2}\\\\\n",
    "&= \\alpha' \\exp{\\left( \\sum_{k=1}^{n} -\\frac{1}{2} \\left( \\frac{x_k - \\mu}{\\sigma} \\right)^2 + \\left[-\\frac{1}{2} \\left( \\frac{\\mu - \\mu_0}{\\sigma_0} \\right)^2 \\right] \\right)}\\\\\n",
    "&= \\alpha' \\exp{\\left( -\\frac{1}{2} \\left[ \\sum_{k=1}^{n} \\left( \\frac{x_k - \\mu}{\\sigma} \\right)^2 + \\left( \\frac{\\mu - \\mu_0}{\\sigma_0} \\right)^2 \\right] \\right)}\\\\\n",
    "&= \\alpha' \\exp{\\left( -\\frac{1}{2} \\left[ \\sum_{k=1}^{n} \\frac{(x_k - \\mu)^2}{\\sigma^2}  + \\frac{(\\mu - \\mu_0)^2}{\\sigma_0^2} \\right] \\right)}\\\\\n",
    "&= \\alpha' \\exp{\\left( -\\frac{1}{2} \\left[ \\sum_{k=1}^{n} \\frac{x_k^2 - 2 x_k \\mu + \\mu^2}{\\sigma^2}  + \\frac{\\mu^2 - 2 \\mu \\mu_0 + \\mu_0^2}{\\sigma_0^2} \\right] \\right)}\\\\\n",
    "&= \\alpha' \\exp{\\left( -\\frac{1}{2} \\left[ \\frac{\\sum_{k=1}^{n}x_k^2}{\\sigma^2} - \\frac{\\sum_{k=1}^{n} 2 x_k \\mu}{\\sigma^2} + \\frac{n\\mu^2}{\\sigma^2} + \\frac{\\mu^2}{\\sigma_0^2} - \\frac{2 \\mu \\mu_0}{\\sigma_0^2} + \\frac{\\mu_0^2}{\\sigma_0^2} \\right] \\right)}\\\\\n",
    "&= \\alpha' \\exp{\\left( -\\frac{1}{2} \\left[\n",
    "\\left(\n",
    "\\frac{n\\mu^2}{\\sigma^2} + \\frac{\\mu^2}{\\sigma_0^2} \\right)\n",
    "+ \\left(- \\frac{\\sum_{k=1}^{n} 2 x_k \\mu}{\\sigma^2} - \\frac{2 \\mu \\mu_0}{\\sigma_0^2} \\right)\\\\\n",
    "+ \\left( \\frac{\\sum_{k=1}^{n}x_k^2}{\\sigma^2} + \\frac{\\mu_0^2}{\\sigma_0^2}\n",
    "\\right)\n",
    "\\right] \\right)}\\\\\n",
    "&= \\alpha'' \\exp{\\left( -\\frac{1}{2} \\left[ \\left( \\frac{n\\mu^2}{\\sigma^2} + \\frac{\\mu^2}{\\sigma_0^2} \\right) + \\left(- \\frac{\\sum_{k=1}^{n} 2 x_k \\mu}{\\sigma^2} - \\frac{2 \\mu \\mu_0}{\\sigma_0^2} \\right) \\right] \\right)}\\\\\n",
    "&= \\alpha'' \\exp{\\left( -\\frac{1}{2} \\left[ \\left( \\frac{n}{\\sigma^2} + \\frac{1}{\\sigma_0^2} \\right)\\mu^2 - 2 \\mu\\left(\\frac{\\sum_{k=1}^{n} x_k}{\\sigma^2} + \\frac{\\mu_0}{\\sigma_0^2} \\right) \\right] \\right)}\\\\\n",
    "\\end{align*}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$p(\\mu|\\mathcal{D})$ is in the form of an exponential function of $\\mu^2$ and $\\mu$. If we assume that $p(\\mu|\\mathcal{D})$ is a normal density as follows:\n",
    "\n",
    "$$\n",
    "p(\\mu|\\mathcal{D}) \\sim \\mathcal{N}(\\mu_n, \\sigma_n^2)\n",
    "$$\n",
    "\n",
    "where $\\mu_n$ is the estimated mean, and $\\sigma_n^2$ is the estimated variance.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\n",
    "\\begin{align*}\n",
    "p(\\mu | \\mathcal{D})\n",
    "&= \\frac{1}{\\sqrt{2 \\pi} \\sigma_n} \\exp{\\left( -\\frac{1}{2} \\left( \\frac{(\\mu - \\mu_n)^2}{\\sigma_n^2} \\right) \\right)}\\\\\n",
    "&= \\frac{1}{\\sqrt{2 \\pi} \\sigma_n} \\exp{\\left( -\\frac{1}{2} \\left( \\frac{\\mu^2 - 2 \\mu \\mu_n + \\mu_n^2}{\\sigma_n^2} \\right) \\right)}\\\\\n",
    "&= \\frac{1}{\\sqrt{2 \\pi} \\sigma_n} \\exp{\\left( -\\frac{1}{2} \\left( \\frac{\\mu^2}{\\sigma_n^2} - \\frac{2 \\mu \\mu_n}{\\sigma_n^2} + \\frac{\\mu_n^2}{\\sigma_n^2} \\right) \\right)}\\\\\n",
    "&= \\frac{1}{\\sqrt{2 \\pi} \\sigma_n} \\exp{\\left( -\\frac{1}{2} \\left( \\left[ \\frac{1}{\\sigma_n^2} \\right] \\mu^2 - 2 \\mu \\left[ \\frac{\\mu_n}{\\sigma_n^2} \\right] + \\frac{\\mu_n^2}{\\sigma_n^2} \\right) \\right)}\\\\\n",
    "\\end{align*}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Thus, we can estimate $\\mu_n$ and $\\sigma_n^2$ by equating the above equation with a normal distribution."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\n",
    "\\begin{align*}\n",
    "p(\\mu | \\mathcal{D}) &= \\frac{1}{\\sqrt{2 \\pi} \\sigma_n} \\exp{\\left( -\\frac{1}{2} \\left( \\left[ \\frac{1}{\\sigma_n^2} \\right] \\mu^2 - 2 \\mu \\left[ \\frac{\\mu_n}{\\sigma_n^2} \\right] + \\frac{\\mu_n^2}{\\sigma_n^2} \\right) \\right)}\\\\\n",
    "p(\\mu | \\mathcal{D}) &= \\alpha'' \\exp{\\left( -\\frac{1}{2} \\left( \\left[ \\frac{n}{\\sigma^2} + \\frac{1}{\\sigma_0^2} \\right]\\mu^2 - 2 \\mu \\left[\\frac{\\sum_{k=1}^{n} x_k}{\\sigma^2} + \\frac{\\mu_0}{\\sigma_0^2} \\right] \\right) \\right)}\\\\\n",
    "\\end{align*}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Comparing the coefficients of the first terms in the exponential ($\\mu_n^2$ and $\\mu^2$) between left hand side and right hand side gives us:\n",
    "\n",
    "$$\n",
    "\\begin{align*}\n",
    "\\frac{1}{\\sigma_n^2} &= \\frac{n}{\\sigma^2} + \\frac{1}{\\sigma_0^2}\\\\\n",
    "\\frac{1}{\\sigma_n^2} &= \\frac{n \\sigma_0^2 + \\sigma^2}{\\sigma^2 \\sigma_0^2}\\\\\n",
    "\\sigma_n^2 &= \\frac{\\sigma^2 \\sigma_0^2}{n \\sigma_0^2 + \\sigma^2}\n",
    "\\end{align*}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\sigma^2_1 = 0.0083$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\sigma^2_2 = 0.0050$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\sigma^2_3 = 0.0125$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "bayes_var = np.zeros(C)\n",
    "\n",
    "for c in range(C):\n",
    "    X = transformed_train_data[c][:, 0]\n",
    "    n = len(X)\n",
    "    bayes_var[c] = (var * prior_var[c]) / ((n * prior_var[c]) + var)\n",
    "    show(r'\\sigma^2_'+str(c+1), bayes_var[c], precision=4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also compare the coefficients of the second terms in the exponential ($\\mu_n$ and $\\mu$) between left hand side and right hand side. This gives us:\n",
    "\n",
    "$$\n",
    "\\begin{align*}\n",
    "\\frac{\\mu_n}{\\sigma_n^2}\n",
    "&= \\frac{\\sum_{k=1}^{n} x_k}{\\sigma^2} + \\frac{\\mu_0}{\\sigma_0^2}\\\\\n",
    "&= \\frac{1}{\\sigma^2} \\sum_{k=1}^{n} x_k + \\frac{\\mu_0}{\\sigma_0^2}\\\\\n",
    "&= \\frac{1}{\\sigma^2} \\frac{n}{n} \\sum_{k=1}^{n} x_k + \\frac{\\mu_0}{\\sigma_0^2}\\\\\n",
    "&= \\frac{1}{\\sigma^2} n \\left[ \\frac{1}{n} \\sum_{k=1}^{n} x_k \\right] + \\frac{\\mu_0}{\\sigma_0^2}\\\\\n",
    "&= \\frac{1}{\\sigma^2} n \\bar{x_n} + \\frac{\\mu_0}{\\sigma_0^2}\\\\\n",
    "\\frac{\\mu_n}{\\sigma_n^2}\n",
    "&= \\frac{n}{\\sigma^2} \\bar{x_n} + \\frac{\\mu_0}{\\sigma_0^2}\\\\\n",
    "\\mu_n\n",
    "&= \\sigma_n^2 \\left( \\frac{n}{\\sigma^2} \\bar{x_n} + \\frac{\\mu_0}{\\sigma_0^2} \\right)\\\\\n",
    "&= \\frac{n \\sigma_n^2}{\\sigma^2} \\bar{x_n} + \\frac{\\sigma_n^2}{\\sigma_0^2} \\mu_0 \\\\\n",
    "&= \\frac{n}{\\sigma^2} \\left[ \\frac{\\sigma^2 \\sigma_0^2}{n \\sigma_0^2 + \\sigma^2} \\right] \\bar{x_n} + \\frac{1}{\\sigma_0^2} \\left[ \\frac{\\sigma^2 \\sigma_0^2}{n \\sigma_0^2 + \\sigma^2} \\right] \\mu_0 \\\\\n",
    "\\mu_n\n",
    "&= \\frac{n \\sigma_0^2}{n \\sigma_0^2 + \\sigma^2} \\bar{x_n} + \\frac{\\sigma^2}{n \\sigma_0^2 + \\sigma^2} \\mu_0 \\\\\n",
    "\\end{align*}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "where the sample mean $\\bar{x}_n$ is:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\n",
    "\\bar{x}_n = \\frac{1}{n} \\sum_{k=1}^{n} x_k\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Based on the derived $\\sigma_n^2$, we can arrive at a final form of computing $\\mu_n$ without the dependency of $\\sigma_n^2$. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "def estimate_bayes_mu(X, var, prior_mu, prior_var):\n",
    "    n = len(X)\n",
    "    x_bar = compute_mean(X)\n",
    "    bayes_mu = ((n * prior_var) / ((n * prior_var) + var)) * x_bar\n",
    "    bayes_mu += (var / ((n * prior_var) + var)) * prior_mu\n",
    "    return bayes_mu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\mu_1 = 1.2673$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\mu_2 = 2.5134$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\mu_3 = 3.4866$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "bayes_mu = np.zeros(C)\n",
    "\n",
    "for c in range(C):\n",
    "    X = transformed_train_data[c][:, 0]\n",
    "    bayes_mu[c] = estimate_bayes_mu(X, var, prior_mu[c], prior_var[c])\n",
    "    show(r'\\mu_' + str(c+1), bayes_mu[c])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, the desired class-conditional density $p(r|\\mathcal{D})$ will be derived based on the a posteriori density $p(\\mu|\\mathcal{D})$.\n",
    "\n",
    "<u>Note</u>: Whereas we are focusing on $p(r|\\mathcal{D})$, its true form is actually $p(r|\\omega_i, \\mathcal{D_i})$. We just drop the class distinctions for simplicity.\n",
    "- $\\mathcal{D}$ is the dataset of a class. It can be $\\mathcal{D}_i$ where $i = 1, \\dots, C$.\n",
    "\n",
    "As we use both the prior probability $p(\\mu_i | \\mathcal{D})$ and the probability density $p(r | \\mu_i)$, we arrive at:\n",
    "$$\n",
    "\\begin{align*}\n",
    "p(r|\\mathcal{D}) \n",
    "&= \\int p(r|\\mu_i) \\cdot p(\\mu_i|\\mathcal{D}) \\,d\\mu_i\\\\\n",
    "&= \\int \\frac{1}{\\sqrt{2 \\pi} \\sigma} \\exp \\left[ -\\frac{1}{2} \\left( \\frac{x - \\mu}{\\sigma} \\right)^2 \\right]\n",
    "\\cdot \\int \\frac{1}{\\sqrt{2 \\pi} \\sigma_n} \\exp \\left[ -\\frac{1}{2} \\left( \\frac{\\mu - \\mu_n}{\\sigma_n} \\right)^2 \\right] \\,d\\mu\\\\\n",
    "\\end{align*}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We pull the terms that do not relate to $\\mu$ out, we get\n",
    "\n",
    "$$\n",
    "\\begin{align*}\n",
    "p(r|\\mathcal{D}) \n",
    "&= \\frac{1}{2 \\pi \\sigma \\sigma_n} \\exp \\left[ -\\frac{1}{2} \\frac{(x - \\mu_n)^2}{\\sigma^2 + \\sigma_n^2} \\right]\n",
    "\\cdot \\int \\exp \\left[ -\\frac{1}{2} \\frac{\\sigma^2 + \\sigma_n^2}{\\sigma^2 \\sigma_n^2} \\left( \\mu - \\frac{\\sigma_n^2 x + \\sigma^2 \\mu_n}{\\sigma^2 + \\sigma_n^2} \\right)^2 \\right] \\,d\\mu\\\\\n",
    "\\end{align*}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From the first term of the above equation, we can see that $p(r|\\mathcal{D})$ can be viewed as an approximate normal distribution where $\\mu_n$ is the mean, and $\\sigma^2 + \\sigma_n^2$ is the variance."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\n",
    "p(r|\\mathcal{D}) \\sim \\mathcal{N}(\\mu_n, \\sigma^2 + \\sigma_n^2)\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "def normal_distribution(x, mu, var):\n",
    "    return np.exp(-0.5 * ((x - mu)**2 / var)) / np.sqrt(2 * np.pi * var)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_posteriori_densities = []\n",
    "\n",
    "x_values = np.arange(0, 5.001, 0.001)\n",
    "for c in range(C):\n",
    "    y_values = [normal_distribution(x, bayes_mu[c], var + bayes_var[c]) for x in x_values]\n",
    "    y_values /= np.sum(y_values)\n",
    "    a_posteriori_densities.append(y_values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "mean_colors = ('blue', 'deeppink', 'green')\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(10, 6))\n",
    "\n",
    "for c, y_values in enumerate(a_posteriori_densities):\n",
    "    ax.plot(x_values, y_values, linewidth=4, color=mean_colors[c], label=r\"$p(r|D_\" + str(c+1) + \")$\")\n",
    "\n",
    "ax.set_xlabel(r\"$r$\", size=14)\n",
    "ax.set_ylabel(r\"$p(r|D_i)$\", size=14)\n",
    "ax.set_title(\"The desired class-conditional densities\")\n",
    "ax.legend()\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Classification"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We use the estimated class-conditional densities to classify the test data. Again, the class $i$ with the maximum class-conditional densities at $r$ will be selected."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\n",
    "\\hat{y}(r) = \\operatorname*{argmax}_{i} p(r|\\omega_i, \\mathcal{D}_i)\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Confusion Matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "bayes_confusion_matrix = np.zeros((C, C))\n",
    "\n",
    "for c in range(C):\n",
    "    for x, _ in transformed_test_data[c]:\n",
    "        class_conditional_densities = np.zeros(C)\n",
    "        for i in range(C):\n",
    "            class_conditional_densities[i] = normal_distribution(x, bayes_mu[i], var + bayes_var[i])\n",
    "        pred_class = np.argmax(class_conditional_densities)\n",
    "        bayes_confusion_matrix[c][pred_class] += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[66.,  4.,  0.],\n",
       "       [10., 67., 17.],\n",
       "       [ 0.,  3., 43.]])"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bayes_confusion_matrix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| | (predicted) 1 | (predicted) 2 | (predicted) 3 |\n",
    "| :-: | :-: | :-: | :-: |\n",
    "|<b>(actual) 1</b>|66|4|0|\n",
    "|<b>(actual) 2</b>|10|67|17|\n",
    "|<b>(actual) 3</b>|0|3|43|\n",
    "\n",
    "<center>Table 4: Confusion matrix of the model with the estimated parameter $\\mu_i$ using <strong>Bayesian Estimation</strong>, and classifying based on the desired <strong>class-conditional densities</strong></center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "According to the confusion matrix shown above, most of the samples are classified correctly. They are placed in the diagonal of the confusion matrix. On the other hand, there are misclassified samples that are off-diagonal of the confusion matrix.\n",
    "\n",
    "- 4 samples are classified as class 2 but actually they are from class 1\n",
    "- 10 samples are classified as class 1 but actually they are from class 2\n",
    "- 17 samples are classified as class 3 but actually they are from class 2\n",
    "- 3 samples are classified as class 2 but actually they are from class 3\n",
    "\n",
    "Again, no samples of class 1 are misclassified as class 3, and vice versa."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\mathrm{Test\\ Accuracy} = 0.8381$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\mathrm{Test\\ Error} = 0.1619$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "bayes_accuracy = bayes_confusion_matrix.trace() / bayes_confusion_matrix.sum()\n",
    "bayes_error = 1 - bayes_accuracy\n",
    "\n",
    "show('\\mathrm{Test\\ Accuracy}', bayes_accuracy)\n",
    "show('\\mathrm{Test\\ Error}', bayes_error)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This time, the test accuracy based on the estimated parameters $\\mu_i$ using Bayesian Estimation can attain $83.81\\%$ test accuracy. The test error is then equal to $16.19\\%$.\n",
    "\n",
    "- Comparing this to the previous MLE method with **biased** covariance matrices, BE provides us a better test accuracy by a margin of $8.1\\%$.\n",
    "- Comparing this to the previous MLE method with **unbiased** covariance matrices, BE provides us a better test accuracy by a margin of $7.62\\%$."
   ]
  }
 ],
 "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.8.5"
  },
  "toc-autonumbering": false,
  "toc-showcode": false,
  "toc-showmarkdowntxt": false,
  "toc-showtags": false
 },
 "nbformat": 4,
 "nbformat_minor": 4
}