Week6 - Naive Bayes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Naive Bayes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Imports\n",
    "\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Benoulli NB: Implementation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "class BernoulliNB(object):\n",
    "\n",
    "    def __init__(self, alpha=1.0):\n",
    "        self.alpha = alpha\n",
    "\n",
    "    def fit(self, X, y):\n",
    "        '''Estimates parameters for Bernoulli NB\n",
    "        Args:\n",
    "            X: Feature matrix of shape (n,m)\n",
    "            y: Label vector of shape (n,)\n",
    "\n",
    "        Returns:\n",
    "            w_{j y_c}, w_prior\n",
    "        '''\n",
    "        n_samples, n_features = X.shape\n",
    "        class_count = np.unique(y)\n",
    "        n_classes = len(class_count)\n",
    "\n",
    "        #Initialise the weight vector\n",
    "        self.w = np.zeros((n_classes, n_features), dtype=np.float64)\n",
    "        self.w_priors = np.zeros(n_classes, dtype=np.float64)\n",
    "\n",
    "        for c in range(n_classes):# Processing samples for each class seperately\n",
    "        \n",
    "            # Get example with label = c\n",
    "            X_c = X[y == c]\n",
    "\n",
    "            ## Estimating w_{j y_c} = P(x_j | y_c = c) \n",
    "            self.w[c, :] = (np.sum(X_c, axis=0) + self.alpha)/(X_c.shape[0] + 2.0 * self.alpha)\n",
    "\n",
    "            # Estimating prior\n",
    "            self.w_priors[c] = (X_c.shape[0] + self.alpha)/(float(n_samples) + n_classes * self.alpha)\n",
    "\n",
    "        print(\"Class conditional density: \", self.w)\n",
    "        print(\"Prior: \", self.w_priors)\n",
    "\n",
    "    def log_likelihood_prior_prod(self, X):\n",
    "        return X @(np.log(self.w).T) + (1 - X) @ (np.log((1 - self.w)).T) + np.log(self.w_priors)\n",
    "\n",
    "    def predict_proba(self, X):\n",
    "        q = self.log_likelihood_prior_prod(X)\n",
    "        return np.exp(q) / np.expand_dims(np.sum(np.exp(q), axis=1), axis = 1)\n",
    "    \n",
    "    def predict(self, X):\n",
    "        return np.argmax(self.log_likelihood_prior_prod(X), axis=1)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Demo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Binary labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = np.array([[1,0], [0,1], [0,1], [1,0]])\n",
    "y = np.array([1, 0, 0, 1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Class conditional density:  [[0.25 0.75]\n",
      " [0.75 0.25]]\n",
      "Prior:  [0.5 0.5]\n"
     ]
    }
   ],
   "source": [
    "bernoulli_nb = BernoulliNB()\n",
    "bernoulli_nb.fit(X, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 0, 0, 1], dtype=int64)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bernoulli_nb.predict(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-3.4657359 , -1.26851133],\n",
       "       [-1.26851133, -3.4657359 ],\n",
       "       [-1.26851133, -3.4657359 ],\n",
       "       [-3.4657359 , -1.26851133]])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bernoulli_nb.log_likelihood_prior_prod(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.1, 0.9],\n",
       "       [0.9, 0.1],\n",
       "       [0.9, 0.1],\n",
       "       [0.1, 0.9]])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bernoulli_nb.predict_proba(X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Multiclass setup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = np.array([[1,0], [0,1], [0,1], [1,0], [1, 1], [1, 1]])\n",
    "y = np.array([1, 0, 0, 1, 2, 2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Class conditional density:  [[0.25 0.75]\n",
      " [0.75 0.25]\n",
      " [0.75 0.75]]\n",
      "Prior:  [0.33333333 0.33333333 0.33333333]\n"
     ]
    }
   ],
   "source": [
    "bernoulli_nb = BernoulliNB()\n",
    "bernoulli_nb.fit(X, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 0, 0, 1, 2, 2], dtype=int64)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bernoulli_nb.predict(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-3.87120101, -1.67397643, -2.77258872],\n",
       "       [-1.67397643, -3.87120101, -2.77258872],\n",
       "       [-1.67397643, -3.87120101, -2.77258872],\n",
       "       [-3.87120101, -1.67397643, -2.77258872],\n",
       "       [-2.77258872, -2.77258872, -1.67397643],\n",
       "       [-2.77258872, -2.77258872, -1.67397643]])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bernoulli_nb.log_likelihood_prior_prod(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.07692308, 0.69230769, 0.23076923],\n",
       "       [0.69230769, 0.07692308, 0.23076923],\n",
       "       [0.69230769, 0.07692308, 0.23076923],\n",
       "       [0.07692308, 0.69230769, 0.23076923],\n",
       "       [0.2       , 0.2       , 0.6       ],\n",
       "       [0.2       , 0.2       , 0.6       ]])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bernoulli_nb.predict_proba(X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Gaussian NB: Implementation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "class GaussianNB(object):\n",
    "    def fit(self, X, y):\n",
    "        '''Parameter estimation for Gaussian NB'''\n",
    "\n",
    "        n_samples, n_features = X.shape\n",
    "        self._classes = np.unique(y)\n",
    "        n_classes = len(self._classes)\n",
    "\n",
    "        # Initialise mean, var, and prior for each class.\n",
    "        self._mean = np.zeros((n_classes, n_features), dtype=np.float64)\n",
    "        self._var = np.zeros((n_classes, n_features), dtype=np.float64)\n",
    "        self._priors = np.zeros(n_classes, dtype=np.float64)\n",
    "\n",
    "        for idx, c in enumerate(self._classes):\n",
    "\n",
    "            #Get examples with label y=c\n",
    "            X_c = X[y == c]\n",
    "\n",
    "            #Estimate mean from the training examples of class c.\n",
    "            self._mean[idx, :] = X_c.mean(axis=0)\n",
    "\n",
    "            #Estimate variance from the training examples of class c.\n",
    "            self._var[idx, :] = X_c.var(axis=0)\n",
    "\n",
    "            #Estimate priors.\n",
    "            self._priors[idx] = X_c.shape[0] / float(n_samples)\n",
    "\n",
    "        print(\"Mean: \", self._mean)\n",
    "        print(\"Variance: \", self._var)\n",
    "        print(\"Priors: \", self._priors)\n",
    "\n",
    "    def _calc_pdf(self, class_idx, X):\n",
    "        '''Calculates probability density for samples for class label class_idx'''\n",
    "\n",
    "        mean = self._mean[class_idx]\n",
    "        var = np.diag(self._var[class_idx])\n",
    "        z = np.power(2 * np.pi, X.shape[0]/2) * np.power(np.linalg.det(var), 1/2)\n",
    "        return (1/z) * np.exp(-(1/2)*(X - mean).T @ (np.linalg.inv(var)) @ (X - mean))\n",
    "\n",
    "    def _calc_prod_likelihood_prior(self, X):\n",
    "        '''Calculates product of likelihood and priors.'''\n",
    "\n",
    "        self._prod_likelihood_prior = np.zeros((X.shape[0], len(self._classes)), dtype=np.float64)\n",
    "\n",
    "        for x_idx, x in enumerate(X):\n",
    "            for idx, c in enumerate(self._classes):\n",
    "                self._prod_likelihood_prior[x_idx, c] = (np.log(self._calc_pdf(idx, x)) + np.log(self._priors[idx]))\n",
    "\n",
    "    def predict(self, X):\n",
    "        '''Predicts class labels for each example'''\n",
    "        \n",
    "        self._calc_prod_likelihood_prior(X)\n",
    "\n",
    "        return np.argmax(self._prod_likelihood_prior, axis=1)\n",
    "\n",
    "    def predict_proba(self, X):\n",
    "        '''Calculates probability of each example belonging to different classes.'''\n",
    "\n",
    "        self._calc_prod_likelihood_prior(X)\n",
    "\n",
    "        return np.exp(self._prod_likelihood_prior) / np.expand_dims(np.sum(np.exp(self._prod_likelihood_prior), axis = 1), axis = 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Demo\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Binary classification"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.datasets import make_classification, make_blobs\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "# Generate data points\n",
    "X, y = make_blobs(n_samples = 100,\n",
    "                n_features=2,\n",
    "                centers=[[5,5],[10,10]],\n",
    "                cluster_std=1.5,\n",
    "                random_state=2)\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=123)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean:  [[ 4.55853975  5.01739665]\n",
      " [10.30431548 10.08580617]]\n",
      "Variance:  [[2.13298417 2.30222002]\n",
      " [3.22242307 2.20662074]]\n",
      "Priors:  [0.5125 0.4875]\n"
     ]
    }
   ],
   "source": [
    "gaussian_nb = GaussianNB()\n",
    "gaussian_nb.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "ax.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='RdBu')\n",
    "\n",
    "xlim = (min(X[:, 0]) - 2, max(X[:, 0]) + 2 )\n",
    "ylim = (min(X[:, 1]) - 2, max(X[:, 1]) + 2 )\n",
    "\n",
    "xg = np.linspace(xlim[0], xlim[1], 60)\n",
    "yg = np.linspace(ylim[0], ylim[1], 40)\n",
    "xx, yy = np.meshgrid(xg, yg)\n",
    "Xgrid = np.vstack([xx.ravel(), yy.ravel()]).T\n",
    "\n",
    "for label, color in enumerate(['red', 'blue']):\n",
    "    mask = (y == label)\n",
    "    mu, std = X[mask].mean(0), X[mask].std(0)\n",
    "    P = np.exp(-0.5 * (Xgrid - mu)**2 / std**2).prod(1)\n",
    "    Pm = np.ma.masked_array(P, P < 0.03)\n",
    "    ax.pcolorfast(xg, yg, Pm.reshape(xx.shape), alpha=0.5, cmap=color.title() + 's')\n",
    "    ax.contour(xx, yy, P.reshape(xx.shape), levels=[0.01, 0.1, 0.5, 0.9], colors = color, alpha=0.2)\n",
    "\n",
    "ax.set(xlim=xlim, ylim=ylim)\n",
    "\n",
    "plt.title('Gaussian distribution of data')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0],\n",
       "      dtype=int64)"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gaussian_nb.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       1.00      1.00      1.00         9\n",
      "           1       1.00      1.00      1.00        11\n",
      "\n",
      "    accuracy                           1.00        20\n",
      "   macro avg       1.00      1.00      1.00        20\n",
      "weighted avg       1.00      1.00      1.00        20\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import classification_report\n",
    "print(classification_report(y_test, gaussian_nb.predict(X_test)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[9.99999746e-01, 2.54140753e-07],\n",
       "       [7.63749214e-14, 1.00000000e+00],\n",
       "       [4.23038642e-03, 9.95769614e-01],\n",
       "       [9.99986614e-01, 1.33855473e-05],\n",
       "       [7.05769182e-06, 9.99992942e-01],\n",
       "       [9.99820566e-01, 1.79433743e-04],\n",
       "       [9.72541524e-01, 2.74584756e-02],\n",
       "       [9.99982043e-01, 1.79572091e-05],\n",
       "       [2.85910189e-05, 9.99971409e-01],\n",
       "       [1.01888837e-07, 9.99999898e-01],\n",
       "       [7.39129058e-01, 2.60870942e-01],\n",
       "       [9.99793438e-01, 2.06561658e-04],\n",
       "       [9.99999915e-01, 8.46737165e-08],\n",
       "       [2.03213294e-05, 9.99979679e-01],\n",
       "       [8.76198350e-09, 9.99999991e-01],\n",
       "       [6.51163513e-05, 9.99934884e-01],\n",
       "       [9.27638525e-05, 9.99907236e-01],\n",
       "       [7.58034673e-09, 9.99999992e-01],\n",
       "       [1.81773339e-03, 9.98182267e-01],\n",
       "       [9.99985544e-01, 1.44557945e-05]])"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gaussian_nb.predict_proba(X_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Multiclass classification"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "X, y = make_blobs(n_samples = 100,\n",
    "                    n_features =2,\n",
    "                    centers = [[5,5], [10,10], [20,20]],\n",
    "                    cluster_std = 1.5,\n",
    "                    random_state=3)\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=123)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean:  [[ 4.94844927  4.67947138]\n",
      " [ 9.62097704 10.49990402]\n",
      " [19.63832097 19.94706375]]\n",
      "Variance:  [[1.99332345 2.36976247]\n",
      " [1.68415535 2.25596351]\n",
      " [1.79203315 1.24939267]]\n",
      "Priors:  [0.3375 0.35   0.3125]\n"
     ]
    }
   ],
   "source": [
    "gaussian_nb_mc = GaussianNB()\n",
    "gaussian_nb_mc.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       1.00      1.00      1.00         7\n",
      "           1       1.00      1.00      1.00         5\n",
      "           2       1.00      1.00      1.00         8\n",
      "\n",
      "    accuracy                           1.00        20\n",
      "   macro avg       1.00      1.00      1.00        20\n",
      "weighted avg       1.00      1.00      1.00        20\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(classification_report(y_test, gaussian_nb_mc.predict(X_test)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.02996770e-47, 2.67740135e-24, 1.00000000e+00],\n",
       "       [5.00111567e-05, 9.99949989e-01, 6.51529293e-32],\n",
       "       [9.99999999e-01, 9.45325297e-10, 1.33290144e-78],\n",
       "       [1.00000000e+00, 6.49743430e-12, 7.70260328e-90],\n",
       "       [1.50617094e-52, 5.94123831e-27, 1.00000000e+00],\n",
       "       [3.77917160e-47, 9.99218112e-23, 1.00000000e+00],\n",
       "       [5.30598294e-33, 9.05195020e-13, 1.00000000e+00],\n",
       "       [6.63950534e-07, 9.99999336e-01, 1.42699786e-26],\n",
       "       [3.57244754e-61, 3.86494439e-34, 1.00000000e+00],\n",
       "       [9.70872284e-06, 9.99990291e-01, 5.02104511e-31],\n",
       "       [9.99982252e-01, 1.77477098e-05, 2.51366893e-63],\n",
       "       [3.93493321e-39, 5.51495730e-18, 1.00000000e+00],\n",
       "       [1.00000000e+00, 4.72574372e-11, 1.19906531e-79],\n",
       "       [1.19575291e-47, 3.45203067e-24, 1.00000000e+00],\n",
       "       [9.09245241e-01, 9.07547595e-02, 1.30885257e-46],\n",
       "       [9.99999997e-01, 2.64110663e-09, 3.37901343e-80],\n",
       "       [9.97572472e-01, 2.42752753e-03, 1.17514148e-55],\n",
       "       [1.12896485e-05, 9.99988710e-01, 3.59429638e-31],\n",
       "       [9.18841787e-06, 9.99990812e-01, 2.02077792e-29],\n",
       "       [4.87507189e-58, 6.38893442e-32, 1.00000000e+00]])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gaussian_nb_mc.predict_proba(X_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## MultinomialNB"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MultinomialNB(object):\n",
    "    def fit(self, X, y, alpha = 1.0):\n",
    "        n_samples, n_features = X.shape\n",
    "        self._classes = np.unique(y)\n",
    "        n_classes = len(self._classes)\n",
    "\n",
    "        self.w = np.zeros((n_classes, n_features), dtype=np.float64)\n",
    "        self.w_prior = np.zeros(n_classes, dtype=np.float64)\n",
    "\n",
    "        for idx, c in enumerate(n_classes):\n",
    "            X_c = X[y == c]\n",
    "\n",
    "            total_count = np.sum(X_c, axis=1)\n",
    "            self.w[idx, :] = (np.sum(X_c, axis=0) + alpha) / (total_count + alpha * n_features)\n",
    "\n",
    "            self.w_prior[idx] = (X_c.shape[0] + alpha) / float(n_samples + alpha * n_classes)\n",
    "\n",
    "    def log_likelihood_prior_prod(self, X):\n",
    "        return X @ (np.log(self.w).T) + np.log(self.w_prior) \n",
    "\n",
    "    def predict(self, X):\n",
    "        q = self.log_likelihood_prior_prod(X)\n",
    "        return np.argmax(q, axis = 1)\n",
    "\n",
    "    def predict_proba(self, X):\n",
    "        q = self.log_likelihood_prior_prod(X)\n",
    "        return np.exp(q) / np.expand_dims(np.sum(np.exp(q), axis = 1), axis = 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "369f2c481f4da34e4445cda3fffd2e751bd1c4d706f27375911949ba6bb62e1c"
  },
  "kernelspec": {
   "display_name": "Python 3.10.2 64-bit",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.2"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}