Lab5.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Overfitting\n",
    "\n",
    "Measuring the performance on the same dataset on which a model is fitted can be misleading, especially in the presence of noise. Most models can learn the training instances very well, leading to a training performance that will be very high, but may fail to generalise, so the \"true\" performance, when trying to predict a new dataset, will be significantly lower. This phenomenon is called _overfitting_.\n",
    "\n",
    "For instance, on this dataset:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>X</th>\n",
       "      <th>Y</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2.0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3.0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4.0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>6.0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>7.0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>8.0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>8.5</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>9.0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>10.0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      X  Y\n",
       "0   1.0  0\n",
       "1   2.0  0\n",
       "2   3.0  0\n",
       "3   4.0  0\n",
       "4   6.0  1\n",
       "5   7.0  1\n",
       "6   8.0  1\n",
       "7   8.5  0\n",
       "8   9.0  1\n",
       "9  10.0  1"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "d = pd.DataFrame({'X': [1, 2, 3, 4, 6, 7, 8, 8.5, 9, 10],\n",
    "                  'Y': [0, 0, 0, 0, 1, 1, 1, 0, 1, 1]})\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "the training performance for a decision tree is:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn import tree\n",
    "X = d[['X']]\n",
    "y = d['Y']\n",
    "dt = tree.DecisionTreeClassifier(criterion='entropy').fit(X,y)\n",
    "dt.score(X, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So it can correctly predict every instance seen in the training dataset.\n",
    "\n",
    "But what if $X=9$ and $X=1$ were not available in the training dataset, what would be the accuracy on the original dataset (that does include them)?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d1 = d.drop([1, 8])\n",
    "X1 = d1[['X']]\n",
    "y1 = d1['Y']\n",
    "dt = tree.DecisionTreeClassifier(criterion='entropy').fit(X1,y1)\n",
    "dt.score(X, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So one of the points was still predicted correctly, but one was not, even if the training accuracy is 100%. \n",
    "\n",
    "_Overfitting_ is particularly important for algorithms like decision trees, which will always have perfect accuracy on a consistent dataset, but that doesn't mean that they will predict 100% accurately any new data points."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Testing accuracy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One way to counter this measurement problem is to train on only a part of the dataset and measure performance on the remaining portion, called a _test set_. Common ratios between the training set and the test set are 3:1 or 4:1.\n",
    "\n",
    "We can do this in Python using the `train_test_split()` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training accuracy: 1.0\n",
      "Testing accuracy: 0.6666666666666666\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=0)\n",
    "dt = tree.DecisionTreeClassifier(criterion='entropy').fit(X_train,y_train)\n",
    "print(\"Training accuracy:\", dt.score(X_train, y_train))\n",
    "print(\"Testing accuracy:\", dt.score(X_test, y_test))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Training accuracy is still 100%, while testing accuracy is significantly lower, but it does gives a better indication on how this model performs on unseen data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "**Give it a try!**\n",
    "\n",
    "For the iris dataset, calculate the training and testing accuracies using `train_test_split()` with parameters:\n",
    "\n",
    "* `test_size=0.3` and `random_state=0`;\n",
    "* `test_size=0.3` and `random_state=1`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.datasets import load_iris\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "iris = load_iris()\n",
    "d1 = pd.DataFrame(\n",
    "    data = np.c_[iris['data'], pd.Categorical.from_codes(iris.target, iris.target_names)],\n",
    "    columns= iris['feature_names'] + ['class'])\n",
    "\n",
    "dt = tree.DecisionTreeClassifier(criterion='entropy', random_state=1)\n",
    "# Your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Expected results:\n",
    "\n",
    "* for `random_state=0`: training acc: 1, testing acc: 0.9777777777777777\n",
    "* for `random_state=1`: training acc: 1, testing acc: 0.9555555555555556"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cross-validation\n",
    "\n",
    "However, by partitioning the available data into multiple sets, we drastically reduce the number of samples which can be used for learning the model, and the results can depend on a particular random choice for the pair of (train, validation) sets.\n",
    "\n",
    "An even more advanced strategy is to repeat the entire procedure multiple times and, in turn, use each part of the dataset as the test set. This is called _cross validation_ (_CV_).\n",
    "\n",
    "* Partition the available data D into k disjoint subsets of equal size\n",
    "* Remove, in turn, each subset from D and train the algorithm on the remaining instances\n",
    "* Apply the trained algorithm on the saved subset and count the errors\n",
    "* The total error for cross-validation is the sum of errors at each step\n",
    "\n",
    "![Cross Validation](img/cross_validation.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using `cross_val_predict()` or just `cross_val_score()` we can get the accuracy score for each of the 5 splits, which we can then average for a final CV mean score:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CV scores: [1.  1.  0.5 0.5 0.5]\n",
      "Mean CV score:  0.7\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import cross_val_score\n",
    "from statistics import mean\n",
    "classifier = tree.DecisionTreeClassifier(criterion='entropy')\n",
    "scores = cross_val_score(classifier, X, y, cv=5)\n",
    "print(\"CV scores:\", scores)\n",
    "print(\"Mean CV score: \", mean(scores))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A variation of this is to use very many folds, up to just using one fold for each instance, which is usually called _CV leave-one-out_ (_CVLOO_).\n",
    "\n",
    "This is available as `LeaveOneOut()`, while a more general `LeavePOut()` function is also available, so we can do a CVLOO with:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CVLOO scores: [1. 1. 1. 1. 1. 1. 0. 0. 0. 1.]\n",
      "Mean CVLOO score:  0.7\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import LeaveOneOut\n",
    "loo = LeaveOneOut()\n",
    "scores = cross_val_score(classifier, X, y, cv=loo)\n",
    "print(\"CVLOO scores:\", scores)\n",
    "print(\"Mean CVLOO score: \", mean(scores))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Average accuracy for CLOO and 5-fold CV are usually close and using one over the other depends on the size of the dataset, since CVLOO running time scales with the size of the dataset, while 5-fold CV always does exactly 5 train-predict runs.\n",
    "\n",
    "For more details see https://scikit-learn.org/stable/modules/cross_validation.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "**Give it a try!**\n",
    "\n",
    "For the iris dataset, calculate the cross-validation accuracy using `cross_val_score()` with:\n",
    "\n",
    "* `cv=KFold(n_splits=5, shuffle=True, random_state=0)` \n",
    "* `cv=KFold(n_splits=5, shuffle=True, random_state=1)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.datasets import load_iris\n",
    "from sklearn.model_selection import KFold\n",
    "\n",
    "iris = load_iris()\n",
    "d1 = pd.DataFrame(\n",
    "    data = np.c_[iris['data'], pd.Categorical.from_codes(iris.target, iris.target_names)],\n",
    "    columns= iris['feature_names'] + ['class'])\n",
    "\n",
    "classifier = tree.DecisionTreeClassifier(criterion='entropy', random_state=3)\n",
    "# Your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Expected results:\n",
    "\n",
    "* for `random_state=0`, accuracy: 0.9533333333333334\n",
    "* for `random_state=1`, accuracy: 0.9400000000000001"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pruning decision trees\n",
    "\n",
    "Since cross-validation provides a better measurement in the context of overfitting, the models themselves could be improved by focusing on increasing the cross-validation performance instead of the training performance.\n",
    "\n",
    "For decision trees, a common technique is to actually reduce the size of the learned tree, which allows the models to generalise better. This effectively trades training performance for CV performance.\n",
    "\n",
    "Let's look again at the example above. The full learned tree is this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 700x800 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training accuracy: 1.0\n",
      "Mean CVLOO accuracy:  0.7\n"
     ]
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "X = d[['X']]\n",
    "y = d['Y']\n",
    "classifier = tree.DecisionTreeClassifier(criterion='entropy')\n",
    "# Fit and score on the entire dataset\n",
    "dt = classifier.fit(X, y)\n",
    "fig, ax = plt.subplots(figsize=(7, 8))\n",
    "f = tree.plot_tree(dt, ax=ax, fontsize=10, feature_names=X.columns)\n",
    "plt.show()\n",
    "print(\"Training accuracy:\", dt.score(X, y))\n",
    "# Fit multiple times and average the scores from the 10 CVLOO runs\n",
    "loo = LeaveOneOut()\n",
    "print(\"Mean CVLOO accuracy: \", mean(cross_val_score(classifier, X, y, cv=loo)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can try to stop the tree from growing once it reaches a certain depth using the `max_depth` parameter:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 700x800 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training accuracy: 0.9\n",
      "Mean CVLOO accuracy:  0.9\n"
     ]
    }
   ],
   "source": [
    "classifier = tree.DecisionTreeClassifier(criterion='entropy', max_depth=1).fit(X,y)\n",
    "# Fit and score on the entire dataset\n",
    "dt = classifier.fit(X, y)\n",
    "fig, ax = plt.subplots(figsize=(7, 8))\n",
    "f = tree.plot_tree(dt, ax=ax, fontsize=10, feature_names=X.columns)\n",
    "plt.show()\n",
    "print(\"Training accuracy:\", dt.score(X, y))\n",
    "# Fit multiple times and average the scores from the 10 CVLOO runs\n",
    "loo = LeaveOneOut()\n",
    "print(\"Mean CVLOO accuracy: \", mean(cross_val_score(classifier, X, y, cv=loo)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see how the CVLOO accuracy has increased as the trees are now much simpler and the training accuracy has decreased slightly, to match the CVLOO accuracy.\n",
    "\n",
    "The correct value of `max_depth` in each case should be determined by simply trying different values in what is called _parameter tuning_ or the _metaoptimisation_ phase of a ML algorithm."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Decision surface\n",
    "\n",
    "To get an intuitive feel for how the ID3 classifier works, we could use a 2D dataset with only 2 output classes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "d = pd.DataFrame({\n",
    "    'X1': [-1, 0, 0, 1, 1, 1, 2, 2],\n",
    "    'X2': [1, 1, 2, -1, 0, 2, 2, 3],\n",
    "    'y': [0, 1, 0, 0, 1, 1, 0, 1]\n",
    "})\n",
    "X, y = d[['X1', 'X2']], d['y']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "which we can plot using [`matplotlib`](https://matplotlib.org/):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 500x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "c= ['green' if l == 0 else 'red' for l in y]\n",
    "fig, ax = plt.subplots(figsize=(5, 5))\n",
    "plt.scatter(X['X1'], X['X2'], color=c)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "where green represents class '0' and red represents class '1'.\n",
    "\n",
    "If we then train a decision tree classifier on this dataset, we can visualise the decision surface with:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 600x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from tools.plots import plot_decision_surface\n",
    "\n",
    "classifier = tree.DecisionTreeClassifier(criterion='entropy').fit(X, y)\n",
    "plot_decision_surface(classifier, X, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The green area represents all instances which this decision tree would classify as '0' and likewise any point in the red area will be classified as '1'.\n",
    "\n",
    "Note how the edge of the decision surface is always parallel to the axes. This is because decision trees can only learn binary splits at different points along the input variables; they cannot learn linear functions (such as a diagonal line). On the lower left side for example, a diagonal line would better separate the two outer green points, but the decision tree approximates that using a vertical and a horizontal line.\n",
    "\n",
    "Even with this limitation they can perform very well in practice because a sufficiently deep tree can approximate any curved line with enough precision."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Naive Bayes\n",
    "\n",
    "Bayesian classifiers and in particular the naive Bayes classifier are a family of probabilistic classification algorithms particularly suited to problems like text classification.\n",
    "\n",
    "When to use it:\n",
    "\n",
    "* The target function $f$ takes value from a finite set $V=\\{v_1,...,v_k\\}$\n",
    "* Moderate or large training data set is available\n",
    "* The attributes $<a_1,...,a_n>$ that describes instances are conditionally independent with respect to the given classification:\n",
    "\n",
    "$$P(a_1,a_2,...,a_n|v_j)=\\prod_i P(a_i|v_j)$$\n",
    "\n",
    "The most probable value of $f(x)$ is:\n",
    "\n",
    "\\begin{align}\n",
    "v_{MAP} &= \\mbox{argmax}_{v_j \\in V}P(v_j|a_1,a_2,...,a_n) \\\\\n",
    "      &= \\mbox{argmax}_{v_j \\in V}\\frac{P(a_1,a_2,...,a_n|v_j)P(v_j)}{P(a_1,a_2,...,a_n)}\\\\\n",
    "      &= \\mbox{argmax}_{v_j \\in V} P(a_1,a_2,...,a_n|v_j)P(v_j)\\\\\n",
    "      &= \\mbox{argmax}_{v_j \\in V} \\prod_i P(a_i|v_j)P(v_j)\n",
    "\\end{align}\n",
    "\n",
    "where MAP stands for [_maximum a posteriori probability_](https://en.wikipedia.org/wiki/Maximum_a_posteriori_estimation).\n",
    "\n",
    "As an example, let's consider a simplified dataset of only 12 messages, 8 of which are spam. For each message, only consider the words \"study\", \"free\" and \"money\":"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>study</th>\n",
       "      <th>free</th>\n",
       "      <th>money</th>\n",
       "      <th>is_spam</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    study  free  money  is_spam\n",
       "0       1     0      0        0\n",
       "1       0     0      1        0\n",
       "2       1     0      0        0\n",
       "3       1     1      0        0\n",
       "4       0     1      0        1\n",
       "5       0     1      0        1\n",
       "6       0     1      0        1\n",
       "7       0     1      0        1\n",
       "8       0     1      1        1\n",
       "9       0     1      1        1\n",
       "10      0     1      1        1\n",
       "11      0     1      1        1"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "features = ['study', 'free', 'money']\n",
    "target = 'is_spam'\n",
    "messages = pd.DataFrame(\n",
    "  [(1, 0, 0, 0),\n",
    "  (0, 0, 1, 0),\n",
    "  (1, 0, 0, 0),\n",
    "  (1, 1, 0, 0)] +\n",
    "  [(0, 1, 0, 1)] * 4 +\n",
    "  [(0, 1, 1, 1)] * 4,\n",
    "columns=features+[target])\n",
    "messages"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Given this labelled dataset, a common requirement is to classify a new message, for which the label is unknown. For example, the message \"money for psychology study\", can be encoded as:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>study</th>\n",
       "      <th>free</th>\n",
       "      <th>money</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   study  free  money\n",
       "0      1     0      1"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new_messages = pd.DataFrame(\n",
    "  [(1, 0, 1)],\n",
    "columns = features)\n",
    "new_messages"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using the [`BernoulliNB`](https://scikit-learn.org/stable/modules/generated/sklearn.naive_bayes.BernoulliNB.html) learner from `sklearn`, we can train a regular Naive Bayes classifier with:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.naive_bayes import BernoulliNB\n",
    "X = messages[features]\n",
    "y = messages[target]\n",
    "cl = BernoulliNB().fit(X, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and then predict the class of the new message with:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cl.predict(new_messages)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The prediction is 0, so this message is not considered to be spam.\n",
    "\n",
    "In order to see the probabilities of each class, not just the most probable class, we can do:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.93676815, 0.06323185]])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cl.predict_proba(new_messages)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To see the classes corresponding to these probabilieis, we can look at the `classes_` attribute:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cl.classes_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "which means the first probability is for class '0', while the second probability is for class '1'."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some of the most useful attributes provided by this learner are:\n",
    "\n",
    "* `classes_` Class labels known to the classifier;\n",
    "* `class_count_` Number of samples encountered for each class during fitting;\n",
    "* `class_log_prior_` Natural logarithm of the probability of each class (smoothed);\n",
    "* `feature_count_` Number of samples encountered for each (class, feature) during fitting;\n",
    "* `feature_log_prob_` Empirical log probability of features given a class, $P(a_i|v_j)$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "**Give it a try!**\n",
    "\n",
    "The datasets `X_art` and `y_art` below describe 6 news articles. `X_art` holds the frequency of words while `y_art` holds the topic of the article. `X_new_art` is meant to represent a new article, for which we don't know the topic. What is the probability that this article is about weather?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "rng = np.random.RandomState(1)\n",
    "cols = [f'word_{i}' for i in range(100)]\n",
    "\n",
    "X_art = pd.DataFrame(rng.randint(5, size=(6, 100)), columns=cols)\n",
    "y_art = pd.Series(np.array(['politics', 'economy', 'weather', 'sports', 'sports', 'culture']))\n",
    "X_new_art = pd.DataFrame(X_art[2:3])\n",
    "\n",
    "# Your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Expected result: 0.99999998.\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Prior probabilities"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By default, the probabilities of the two classes (spam and non-spam) are determined from the dataset. In the results above, the prior probability of 'spam' is considered to be $8/12$, so approximately 0.67. If, however, we want to tweak the prediction to be more conservative and label less messages as spam, then we can directly specify the probability of spam to a lower value such as 0.1:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.99626401, 0.00373599]])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cl = BernoulliNB(class_prior=[0.9,0.1]).fit(X, y)\n",
    "cl.predict_proba(new_messages)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As expected, the computed probability that the message is spam has decreased, from around 0.06 to 0.0037."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}