Ch_07_EnsembleLearning_.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "186ff6e4-d3d2-4e0e-8457-9f6de42fb2d5",
   "metadata": {},
   "source": [
    "***Reference:***\n",
    "\n",
    "***Raschka, Sebastian; Liu, Yuxi (Hayden); Mirjalili, Vahid. Machine Learning with PyTorch and Scikit-Learn: Develop machine learning and deep learning models with Python. Packt Publishing.*** "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3e7bbc95-dc31-442d-97de-b95ef2f046fd",
   "metadata": {},
   "source": [
    "# ***<u>Chapter 7</u> - Combining Different Models for Ensemble Learning***"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5aaa9f88-19a5-48d8-98df-7711ca487fd6",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true,
    "tags": []
   },
   "source": [
    "## Learning with ensembles"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3004f548-08f0-4068-8162-bfe946214b7d",
   "metadata": {},
   "source": [
    "- The goal of **ensemble methods** is to combine different classifiers into a meta-classifier that has better generalization performance than each individual classifier alone. Ensembles are typically recognized for yielding a good generalization performance. \n",
    "\n",
    "- **Majority Voting Principle:** Majority voting simply means that we select the class label that has been predicted by the majority of classifiers, that is, received more than 50 percent of the votes. Strictly speaking, the term “majority vote” refers to binary class settings only. However, it is easy to generalize the majority voting principle to multiclass settings, which is known as **plurality voting**.\n",
    "\n",
    "<div>\n",
    "<img src=\"Images/voting.png\" width=\"400px\"/>\n",
    "</div>\n",
    "\n",
    "- Using the training dataset, we start by training m different classifiers $(C_1, \\cdots, C_m)$. Depending on the technique, the ensemble can be built from different classification algorithms, for example, decision trees, support vector machines, logistic regression classifiers, and so on. \n",
    "\n",
    "- Alternatively, we can also use the same base classification algorithm, fitting different subsets of the training dataset. One prominent example of this approach is the random forest algorithm combining different decision tree classifiers.\n",
    "\n",
    "<div>\n",
    "<img src=\"Images/ensemble.png\" width=\"340px\"/>\n",
    "</div>\n",
    "\n",
    "- To predict a class label via majority or plurality voting, we combine the predicted class labels of each individual classifiers, $C_j$, and select the class label, $\\hat{y}$, that received the most votes:\n",
    "\n",
    "$$\\hat{y} = \\text{mode}\\{C_1(x), C_2(x), \\cdots, C_m(x)\\}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "45bf79c8-bea0-41d8-8aab-b04abff5a603",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true,
    "tags": []
   },
   "source": [
    "## Implementing a simple majority vote classifier"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "04984751-b235-4628-8b60-965f01dd652d",
   "metadata": {},
   "source": [
    "Our goal is to build a stronger meta-classifier that balances out the individual classifiers’ weaknesses on a particular dataset. \n",
    "In mathematical terms, we can write the weighted majority vote as follows:\n",
    "\n",
    "$$\\hat{y} = \\arg \\max_{i}\\sum_{j=1}^{m}w_j\\chi_{A}(C_l(x) = i)$$\n",
    "\n",
    "Here, \n",
    "   - $w_j$ is a weight associated with a base classifier, $C_j$;  \n",
    "   - $\\hat{y}$ is the predicted class label of the ensemble; \n",
    "   - $A$ is the set of unique class labels;  \n",
    "   - $\\chi_{A}$ is the characteristic function or indicator function, which returns 1 if the predicted class of the *jth* classifier matches ***i*** $(C_j(x) = i)$. \n",
    "   \n",
    "For equal weights, we can simplify this equation and write it as follows:\n",
    "\n",
    "$$\\hat{y} = \\text{mode}\\{C_1(x), C_2(x), \\cdots, C_m(x)\\}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f18d24bc-a5de-4f2e-9352-eface8cc3df8",
   "metadata": {},
   "source": [
    "Let's assume we have 3 base classifiers, $C_j (j \\in \\{1,2,3\\})$ and want to predict the class label, $C_j(x) \\in {0,1}$, for a given example, $x$. There prediction are as $$C_1(x) \\rightarrow 0, C_2(x) \\rightarrow 0, C_3(x) \\rightarrow 1$$ \n",
    "\n",
    "In case of equal weigths for the classifier, the prediction is $$\\hat{y} = \\text{mode}\\{0,0,1\\} = 0$$\n",
    "\n",
    "Now, let's assign weights of $0.6$ to $C_3$, and $0.2$ to $C_1$ & $C_2$:\n",
    "\n",
    "$$\\hat{y} = \\arg \\max_{i}\\sum_{j=1}^{m}w_j\\chi_{A}(C_l(x) = i)\\\\\n",
    "          = \\arg \\max_{i}[0.2 \\times i_0 + 0.2 \\times i_0, 0.6 \\times i_1] = 1$$\n",
    "          \n",
    "More simply the prediction made by $C_3$ has $3$ times more weight that taht of $C_1$ or $C_2$, which can be written as:\n",
    "\n",
    "$$\\hat{y} = \\text{mode}\\{0,0,1,1,1\\} = 1$$\n",
    "\n",
    "Below is the code for it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "8a6c7faa-e079-4508-aa8d-f7c08c60891b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "np.argmax(np.bincount([0, 0, 1], \n",
    "                      weights=[0.2, 0.2, 0.6]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a8d16e82-9e0e-4e51-9897-2e444aabbded",
   "metadata": {},
   "source": [
    "Using the predicted class probabilities instead of the class labels for majority voting can be useful if the classifiers in our ensemble are well calibrated. The modified version of the majority vote for predicting class labels from probabilities can be written as follows:\n",
    "\n",
    "$$\\hat{y} = \\arg \\max_i \\sum_{j=1}^{m}w_jp_{ij}$$\n",
    "\n",
    "***Here, $\\textbf{p}_{ij}$ is the predicted prob. of the $jth$ classifier for class label $i$.***\n",
    "\n",
    "\n",
    "Continuing the previous example, let classifier $C_j$ return following class probabilities for class labels $i \\in \\{0,1\\}$ for a particular example, $x$:\n",
    "\n",
    "$$C_1(x) \\rightarrow [0.9,0.1], C_2(x) \\rightarrow [0.8,0.2], C_3(x) \\rightarrow [0.4,0.6]$$\n",
    "\n",
    "Using the same weights as previously $(0.2, 0.2, and 0.6)$, the individual class probabilities  are as follows:\n",
    "\n",
    "$$p(i_0|\\textbf{x}) = 0.2 \\times [0.9 + 0.8] + 0.6 \\times 0.4 = 0.58$$\n",
    "$$p(i_1|\\textbf{x}) = 0.2 \\times [0.1 + 0.2] + 0.6 \\times 0.6 = 0.42$$\n",
    "$$\\hat{y} = \\arg \\max_i[p(i_0|\\textbf{x}), p(i_1|\\textbf{x})] = 0$$\n",
    "\n",
    "Below is the code for that:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "feba3d8d-f6fc-469a-ba28-7bd30e12a63c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.58 0.42]\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "ex = np.array([[0.9, 0.1],\n",
    "               [0.8, 0.2],\n",
    "               [0.4, 0.6]])\n",
    "\n",
    "p = np.average(ex, \n",
    "               axis=0, \n",
    "               weights=[0.2, 0.2, 0.6])\n",
    "\n",
    "print(p)\n",
    "print(np.argmax(p))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c30e0e57-0a00-4278-800a-100ce6287082",
   "metadata": {},
   "source": [
    "### Implementing ```MajorityVoteClassifier```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "ca70de7d-9110-4b69-8ce7-95cd48603f4a",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.base import BaseEstimator\n",
    "from sklearn.base import ClassifierMixin\n",
    "from sklearn.preprocessing import LabelEncoder\n",
    "from sklearn.base import clone\n",
    "from sklearn.pipeline import _name_estimators\n",
    "import numpy as np\n",
    "import operator\n",
    "\n",
    "\n",
    "class MajorityVoteClassifier(BaseEstimator, \n",
    "                             ClassifierMixin):\n",
    "    \"\"\" A majority vote ensemble classifier\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    classifiers : array-like, shape = [n_classifiers]\n",
    "      Different classifiers for the ensemble\n",
    "\n",
    "    vote : str, {'classlabel', 'probability'} (default='classlabel')\n",
    "      If 'classlabel' the prediction is based on the argmax of\n",
    "        class labels. Else if 'probability', the argmax of\n",
    "        the sum of probabilities is used to predict the class label\n",
    "        (recommended for calibrated classifiers).\n",
    "\n",
    "    weights : array-like, shape = [n_classifiers], optional (default=None)\n",
    "      If a list of `int` or `float` values are provided, the classifiers\n",
    "      are weighted by importance; Uses uniform weights if `weights=None`.\n",
    "\n",
    "    \"\"\"\n",
    "    def __init__(self, classifiers, vote='classlabel', weights=None):\n",
    "\n",
    "        self.classifiers = classifiers\n",
    "        self.named_classifiers = {key: value for key, value\n",
    "                                  in _name_estimators(classifiers)}\n",
    "        self.vote = vote\n",
    "        self.weights = weights\n",
    "\n",
    "    def fit(self, X, y):\n",
    "        \"\"\" Fit classifiers.\n",
    "\n",
    "        Parameters\n",
    "        ----------\n",
    "        X : {array-like, sparse matrix}, shape = [n_examples, n_features]\n",
    "            Matrix of training examples.\n",
    "\n",
    "        y : array-like, shape = [n_examples]\n",
    "            Vector of target class labels.\n",
    "\n",
    "        Returns\n",
    "        -------\n",
    "        self : object\n",
    "\n",
    "        \"\"\"\n",
    "        if self.vote not in ('probability', 'classlabel'):\n",
    "            raise ValueError(f\"vote must be 'probability' or 'classlabel'\"\n",
    "                             f\"; got (vote={self.vote})\")\n",
    "\n",
    "        if self.weights and len(self.weights) != len(self.classifiers):\n",
    "            raise ValueError(f'Number of classifiers and weights must be equal'\n",
    "                             f'; got {len(self.weights)} weights,'\n",
    "                             f' {len(self.classifiers)} classifiers')\n",
    "\n",
    "        # Use LabelEncoder to ensure class labels start with 0, which\n",
    "        # is important for np.argmax call in self.predict\n",
    "        self.lablenc_ = LabelEncoder()\n",
    "        self.lablenc_.fit(y)\n",
    "        self.classes_ = self.lablenc_.classes_\n",
    "        self.classifiers_ = []\n",
    "        for clf in self.classifiers:\n",
    "            fitted_clf = clone(clf).fit(X, self.lablenc_.transform(y))\n",
    "            self.classifiers_.append(fitted_clf)\n",
    "        return self\n",
    "\n",
    "    def predict(self, X):\n",
    "        \"\"\" Predict class labels for X.\n",
    "\n",
    "        Parameters\n",
    "        ----------\n",
    "        X : {array-like, sparse matrix}, shape = [n_examples, n_features]\n",
    "            Matrix of training examples.\n",
    "\n",
    "        Returns\n",
    "        ----------\n",
    "        maj_vote : array-like, shape = [n_examples]\n",
    "            Predicted class labels.\n",
    "            \n",
    "        \"\"\"\n",
    "        if self.vote == 'probability':\n",
    "            maj_vote = np.argmax(self.predict_proba(X), axis=1)\n",
    "        else:  # 'classlabel' vote\n",
    "\n",
    "            #  Collect results from clf.predict calls\n",
    "            predictions = np.asarray([clf.predict(X)\n",
    "                                      for clf in self.classifiers_]).T\n",
    "\n",
    "            maj_vote = np.apply_along_axis(\n",
    "                                      lambda x:\n",
    "                                      np.argmax(np.bincount(x,\n",
    "                                                weights=self.weights)),\n",
    "                                      axis=1,\n",
    "                                      arr=predictions)\n",
    "        maj_vote = self.lablenc_.inverse_transform(maj_vote)\n",
    "        return maj_vote\n",
    "\n",
    "    def predict_proba(self, X):\n",
    "        \"\"\" Predict class probabilities for X.\n",
    "\n",
    "        Parameters\n",
    "        ----------\n",
    "        X : {array-like, sparse matrix}, shape = [n_examples, n_features]\n",
    "            Training vectors, where n_examples is the number of examples and\n",
    "            n_features is the number of features.\n",
    "\n",
    "        Returns\n",
    "        ----------\n",
    "        avg_proba : array-like, shape = [n_examples, n_classes]\n",
    "            Weighted average probability for each class per example.\n",
    "\n",
    "        \"\"\"\n",
    "        probas = np.asarray([clf.predict_proba(X)\n",
    "                             for clf in self.classifiers_])\n",
    "        avg_proba = np.average(probas, axis=0, weights=self.weights)\n",
    "        return avg_proba\n",
    "\n",
    "    def get_params(self, deep=True):\n",
    "        \"\"\" Get classifier parameter names for GridSearch\"\"\"\n",
    "        if not deep:\n",
    "            return super().get_params(deep=False)\n",
    "        else:\n",
    "            out = self.named_classifiers.copy()\n",
    "            for name, step in self.named_classifiers.items():\n",
    "                for key, value in step.get_params(deep=True).items():\n",
    "                    out[f'{name}__{key}'] = value\n",
    "            return out"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9159edd9-5bda-4dac-a70b-a017cd9f3794",
   "metadata": {},
   "source": [
    "We used the ```BaseEstimator``` and ```ClassifierMixin``` parent classes to get some base functionality for free, including the ```get_params``` and ```set_params``` methods to set and return the classifier’s parameters, as well as the score method to calculate the prediction accuracy. \n",
    "\n",
    "\n",
    "Next, we will add the ```predict``` method to predict the class label via a majority vote based on the class labels if we initialize a new ```MajorityVoteClassifier``` object with ```vote='classlabel'```. Alternatively, we will be able to initialize the ensemble classifier with ```vote='probability'``` to predict the class label based on the class membership probabilities. Furthermore, we will also add a ```predict_proba``` method to return the averaged probabilities, which is useful when computing the **receiver operating characteristic area under the curve (ROC AUC).**\n",
    "\n",
    "\n",
    "Also, note that we defined our own modified version of the ```get_params``` method to use the ```_name_estimators``` function to access the parameters of individual classifiers in the ensemble."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fb9eb8a6-aade-44f4-a998-b4860cdb4984",
   "metadata": {},
   "source": [
    "### Using the majority voting principle to make predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "fe570a35-d418-43a6-980e-f55e5d847198",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn import datasets\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.preprocessing import LabelEncoder\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "\n",
    "iris = datasets.load_iris()\n",
    "X, y = iris.data[50:, [1, 2]], iris.target[50:]\n",
    "le = LabelEncoder()\n",
    "y = le.fit_transform(y)\n",
    "\n",
    "X_train, X_test, y_train, y_test =\\\n",
    "       train_test_split(X, y, \n",
    "                        test_size=0.5, \n",
    "                        random_state=1,\n",
    "                        stratify=y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "9da522b9-107d-44d3-bdf6-4e482cfa3b17",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10-fold cross validation:\n",
      "\n",
      "ROC AUC: 0.92 (+/- 0.15) [Logistic regression]\n",
      "ROC AUC: 0.87 (+/- 0.18) [Decision tree]\n",
      "ROC AUC: 0.85 (+/- 0.13) [KNN]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.neighbors import KNeighborsClassifier \n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.model_selection import cross_val_score\n",
    "\n",
    "\n",
    "clf1 = LogisticRegression(penalty='l2', \n",
    "                          C=0.001,\n",
    "                          solver='lbfgs',\n",
    "                          random_state=1)\n",
    "\n",
    "clf2 = DecisionTreeClassifier(max_depth=1,\n",
    "                              criterion='entropy',\n",
    "                              random_state=0)\n",
    "\n",
    "clf3 = KNeighborsClassifier(n_neighbors=1,\n",
    "                            p=2,\n",
    "                            metric='minkowski')\n",
    "\n",
    "pipe1 = Pipeline([['sc', StandardScaler()],\n",
    "                  ['clf', clf1]])\n",
    "\n",
    "pipe3 = Pipeline([['sc', StandardScaler()],\n",
    "                  ['clf', clf3]])\n",
    "\n",
    "clf_labels = ['Logistic regression', 'Decision tree', 'KNN']\n",
    "\n",
    "print('10-fold cross validation:\\n')\n",
    "\n",
    "for clf, label in zip([pipe1, clf2, pipe3], clf_labels):\n",
    "    scores = cross_val_score(estimator=clf,\n",
    "                             X=X_train,\n",
    "                             y=y_train,\n",
    "                             cv=10,\n",
    "                             scoring='roc_auc')\n",
    "    \n",
    "    print(f'ROC AUC: {scores.mean():.2f} '\n",
    "          f'(+/- {scores.std():.2f}) [{label}]')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "bbf17f6a-d4e7-4f9d-b30f-7b6053001da2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ROC AUC: 0.92 (+/- 0.15) [Logistic regression]\n",
      "ROC AUC: 0.87 (+/- 0.18) [Decision tree]\n",
      "ROC AUC: 0.85 (+/- 0.13) [KNN]\n",
      "ROC AUC: 0.98 (+/- 0.05) [Majority voting]\n"
     ]
    }
   ],
   "source": [
    "# Majority Rule (hard) Voting\n",
    "\n",
    "mv_clf = MajorityVoteClassifier(classifiers=[pipe1, clf2, pipe3])\n",
    "\n",
    "clf_labels += ['Majority voting']\n",
    "all_clf = [pipe1, clf2, pipe3, mv_clf]\n",
    "\n",
    "for clf, label in zip(all_clf, clf_labels):\n",
    "    scores = cross_val_score(estimator=clf,\n",
    "                             X=X_train,\n",
    "                             y=y_train,\n",
    "                             cv=10,\n",
    "                             scoring='roc_auc')\n",
    "    print(f'ROC AUC: {scores.mean():.2f} '\n",
    "          f'(+/- {scores.std():.2f}) [{label}]')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d2eb6db6-53cd-4fdf-bdd9-c2f3c5bae0fc",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Evaluating and tuning the ensemble classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "8604f29f-fc8f-47d6-8333-69477fb5b923",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from sklearn.metrics import roc_curve\n",
    "from sklearn.metrics import auc\n",
    "\n",
    "\n",
    "colors = ['black', 'orange', 'blue', 'green']\n",
    "linestyles = [':', '--', '-.', '-']\n",
    "for clf, label, clr, ls \\\n",
    "        in zip(all_clf,\n",
    "               clf_labels, colors, linestyles):\n",
    "\n",
    "    # assuming the label of the positive class is 1\n",
    "    y_pred = clf.fit(X_train,\n",
    "                     y_train).predict_proba(X_test)[:, 1]\n",
    "    fpr, tpr, thresholds = roc_curve(y_true=y_test,\n",
    "                                     y_score=y_pred)\n",
    "    roc_auc = auc(x=fpr, y=tpr)\n",
    "    plt.plot(fpr, tpr,\n",
    "             color=clr,\n",
    "             linestyle=ls,\n",
    "             label=f'{label} (auc = {roc_auc:.2f})')\n",
    "\n",
    "plt.legend(loc='lower right')\n",
    "plt.plot([0, 1], [0, 1],\n",
    "         linestyle='--',\n",
    "         color='gray',\n",
    "         linewidth=2)\n",
    "\n",
    "plt.xlim([-0.1, 1.1])\n",
    "plt.ylim([-0.1, 1.1])\n",
    "plt.grid(alpha=0.5)\n",
    "plt.xlabel('False positive rate (FPR)')\n",
    "plt.ylabel('True positive rate (TPR)')\n",
    "\n",
    "\n",
    "plt.show();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eecf2286-52fe-4241-94e4-7b617760ecfc",
   "metadata": {},
   "source": [
    "In the resulting ROC, the ensemble classifier also performs well on the test dataset (ROC AUC = 0.95). However, the logistic regression classifier performs similarly well on the same dataset, which is probably due to the high variance (in this case, the sensitivity of how we split the dataset) given the small size of the dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "cb4e63b5-35ec-4299-a1a1-4df54867b3e0",
   "metadata": {},
   "outputs": [],
   "source": [
    "sc = StandardScaler()\n",
    "X_train_std = sc.fit_transform(X_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "1cf2f7e3-46d4-402d-b2b8-b8404b4ef941",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 700x500 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from itertools import product\n",
    "\n",
    "\n",
    "all_clf = [pipe1, clf2, pipe3, mv_clf]\n",
    "\n",
    "x_min = X_train_std[:, 0].min() - 1\n",
    "x_max = X_train_std[:, 0].max() + 1\n",
    "y_min = X_train_std[:, 1].min() - 1\n",
    "y_max = X_train_std[:, 1].max() + 1\n",
    "\n",
    "xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.1),\n",
    "                     np.arange(y_min, y_max, 0.1))\n",
    "\n",
    "f, axarr = plt.subplots(nrows=2, ncols=2, \n",
    "                        sharex='col', \n",
    "                        sharey='row', \n",
    "                        figsize=(7, 5))\n",
    "\n",
    "for idx, clf, tt in zip(product([0, 1], [0, 1]),\n",
    "                        all_clf, clf_labels):\n",
    "    clf.fit(X_train_std, y_train)\n",
    "    \n",
    "    Z = clf.predict(np.c_[xx.ravel(), yy.ravel()])\n",
    "    Z = Z.reshape(xx.shape)\n",
    "\n",
    "    axarr[idx[0], idx[1]].contourf(xx, yy, Z, alpha=0.3)\n",
    "    \n",
    "    axarr[idx[0], idx[1]].scatter(X_train_std[y_train==0, 0], \n",
    "                                  X_train_std[y_train==0, 1], \n",
    "                                  c='blue', \n",
    "                                  marker='^',\n",
    "                                  s=50)\n",
    "    \n",
    "    axarr[idx[0], idx[1]].scatter(X_train_std[y_train==1, 0], \n",
    "                                  X_train_std[y_train==1, 1], \n",
    "                                  c='green', \n",
    "                                  marker='o',\n",
    "                                  s=50)\n",
    "    \n",
    "    axarr[idx[0], idx[1]].set_title(tt)\n",
    "\n",
    "plt.text(-3.5, -5., \n",
    "         s='Sepal width [standardized]', \n",
    "         ha='center', va='center', fontsize=12)\n",
    "plt.text(-12.5, 4.5, \n",
    "         s='Petal length [standardized]', \n",
    "         ha='center', va='center', \n",
    "         fontsize=12, rotation=90)\n",
    "\n",
    "plt.show();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "16479d45-87dd-4278-8719-62f31d983d7b",
   "metadata": {},
   "source": [
    "The decision regions of the ensemble classifier seem to be a hybrid of the decision regions from the individual classifiers. At first glance, the majority vote decision boundary looks a lot like the decision of the decision tree stump, which is orthogonal to the y axis for sepal width ≥ 1. However, the nonlinearity from the k-nearest neighbor classifier is also mixed in."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "102af697-6907-485e-93cb-db0b39269011",
   "metadata": {
    "scrolled": true,
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'pipeline-1': Pipeline(steps=[('sc', StandardScaler()),\n",
       "                 ['clf', LogisticRegression(C=0.001, random_state=1)]]),\n",
       " 'decisiontreeclassifier': DecisionTreeClassifier(criterion='entropy', max_depth=1, random_state=0),\n",
       " 'pipeline-2': Pipeline(steps=[('sc', StandardScaler()),\n",
       "                 ['clf', KNeighborsClassifier(n_neighbors=1)]]),\n",
       " 'pipeline-1__memory': None,\n",
       " 'pipeline-1__steps': [('sc', StandardScaler()),\n",
       "  ['clf', LogisticRegression(C=0.001, random_state=1)]],\n",
       " 'pipeline-1__verbose': False,\n",
       " 'pipeline-1__sc': StandardScaler(),\n",
       " 'pipeline-1__clf': LogisticRegression(C=0.001, random_state=1),\n",
       " 'pipeline-1__sc__copy': True,\n",
       " 'pipeline-1__sc__with_mean': True,\n",
       " 'pipeline-1__sc__with_std': True,\n",
       " 'pipeline-1__clf__C': 0.001,\n",
       " 'pipeline-1__clf__class_weight': None,\n",
       " 'pipeline-1__clf__dual': False,\n",
       " 'pipeline-1__clf__fit_intercept': True,\n",
       " 'pipeline-1__clf__intercept_scaling': 1,\n",
       " 'pipeline-1__clf__l1_ratio': None,\n",
       " 'pipeline-1__clf__max_iter': 100,\n",
       " 'pipeline-1__clf__multi_class': 'auto',\n",
       " 'pipeline-1__clf__n_jobs': None,\n",
       " 'pipeline-1__clf__penalty': 'l2',\n",
       " 'pipeline-1__clf__random_state': 1,\n",
       " 'pipeline-1__clf__solver': 'lbfgs',\n",
       " 'pipeline-1__clf__tol': 0.0001,\n",
       " 'pipeline-1__clf__verbose': 0,\n",
       " 'pipeline-1__clf__warm_start': False,\n",
       " 'decisiontreeclassifier__ccp_alpha': 0.0,\n",
       " 'decisiontreeclassifier__class_weight': None,\n",
       " 'decisiontreeclassifier__criterion': 'entropy',\n",
       " 'decisiontreeclassifier__max_depth': 1,\n",
       " 'decisiontreeclassifier__max_features': None,\n",
       " 'decisiontreeclassifier__max_leaf_nodes': None,\n",
       " 'decisiontreeclassifier__min_impurity_decrease': 0.0,\n",
       " 'decisiontreeclassifier__min_samples_leaf': 1,\n",
       " 'decisiontreeclassifier__min_samples_split': 2,\n",
       " 'decisiontreeclassifier__min_weight_fraction_leaf': 0.0,\n",
       " 'decisiontreeclassifier__random_state': 0,\n",
       " 'decisiontreeclassifier__splitter': 'best',\n",
       " 'pipeline-2__memory': None,\n",
       " 'pipeline-2__steps': [('sc', StandardScaler()),\n",
       "  ['clf', KNeighborsClassifier(n_neighbors=1)]],\n",
       " 'pipeline-2__verbose': False,\n",
       " 'pipeline-2__sc': StandardScaler(),\n",
       " 'pipeline-2__clf': KNeighborsClassifier(n_neighbors=1),\n",
       " 'pipeline-2__sc__copy': True,\n",
       " 'pipeline-2__sc__with_mean': True,\n",
       " 'pipeline-2__sc__with_std': True,\n",
       " 'pipeline-2__clf__algorithm': 'auto',\n",
       " 'pipeline-2__clf__leaf_size': 30,\n",
       " 'pipeline-2__clf__metric': 'minkowski',\n",
       " 'pipeline-2__clf__metric_params': None,\n",
       " 'pipeline-2__clf__n_jobs': None,\n",
       " 'pipeline-2__clf__n_neighbors': 1,\n",
       " 'pipeline-2__clf__p': 2,\n",
       " 'pipeline-2__clf__weights': 'uniform'}"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mv_clf.get_params()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e1dae66-5b2d-4b24-979a-7d60c256eda1",
   "metadata": {},
   "source": [
    "Tuning the inverse regularization parameter, ```C```, of the logistic regression classifier and the decision tree depth via grid search."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "a9f40e98-3e5f-46ee-9c75-3a59502dcef8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.983 +/- 0.05 {'decisiontreeclassifier__max_depth': 1, 'pipeline-1__clf__C': 0.001}\n",
      "0.983 +/- 0.05 {'decisiontreeclassifier__max_depth': 1, 'pipeline-1__clf__C': 0.1}\n",
      "0.967 +/- 0.10 {'decisiontreeclassifier__max_depth': 1, 'pipeline-1__clf__C': 100.0}\n",
      "0.983 +/- 0.05 {'decisiontreeclassifier__max_depth': 2, 'pipeline-1__clf__C': 0.001}\n",
      "0.983 +/- 0.05 {'decisiontreeclassifier__max_depth': 2, 'pipeline-1__clf__C': 0.1}\n",
      "0.967 +/- 0.10 {'decisiontreeclassifier__max_depth': 2, 'pipeline-1__clf__C': 100.0}\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import GridSearchCV\n",
    "\n",
    "\n",
    "params = {'decisiontreeclassifier__max_depth': [1, 2],\n",
    "          'pipeline-1__clf__C': [0.001, 0.1, 100.0]}\n",
    "\n",
    "grid = GridSearchCV(estimator=mv_clf,\n",
    "                    param_grid=params,\n",
    "                    cv=10,\n",
    "                    scoring='roc_auc')\n",
    "grid.fit(X_train, y_train)\n",
    "\n",
    "for r, _ in enumerate(grid.cv_results_['mean_test_score']):\n",
    "    mean_score = grid.cv_results_['mean_test_score'][r]\n",
    "    std_dev = grid.cv_results_['std_test_score'][r]\n",
    "    params = grid.cv_results_['params'][r]\n",
    "    print(f'{mean_score:.3f} +/- {std_dev:.2f} {params}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "b08154b9-41ad-40d0-b5ab-83b62abbbbee",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best parameters: {'decisiontreeclassifier__max_depth': 1, 'pipeline-1__clf__C': 0.001}\n",
      "ROC AUC: 0.98\n"
     ]
    }
   ],
   "source": [
    "print(f'Best parameters: {grid.best_params_}')\n",
    "print(f'ROC AUC: {grid.best_score_:.2f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "8af7586b-24e2-45d3-a57f-d64782a38a56",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Pipeline(steps=[('sc', StandardScaler()),\n",
       "                 ['clf', LogisticRegression(C=0.001, random_state=1)]]),\n",
       " DecisionTreeClassifier(criterion='entropy', max_depth=1, random_state=0),\n",
       " Pipeline(steps=[('sc', StandardScaler()),\n",
       "                 ['clf', KNeighborsClassifier(n_neighbors=1)]])]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grid.best_estimator_.classifiers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "21111bdc-8381-476d-94fc-78679cdf449a",
   "metadata": {},
   "outputs": [],
   "source": [
    "mv_clf = grid.best_estimator_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "5aa00632-6f4b-43ea-9b75-4103ffd402e9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>#sk-container-id-1 {color: black;background-color: white;}#sk-container-id-1 pre{padding: 0;}#sk-container-id-1 div.sk-toggleable {background-color: white;}#sk-container-id-1 label.sk-toggleable__label {cursor: pointer;display: block;width: 100%;margin-bottom: 0;padding: 0.3em;box-sizing: border-box;text-align: center;}#sk-container-id-1 label.sk-toggleable__label-arrow:before {content: \"▸\";float: left;margin-right: 0.25em;color: #696969;}#sk-container-id-1 label.sk-toggleable__label-arrow:hover:before {color: black;}#sk-container-id-1 div.sk-estimator:hover label.sk-toggleable__label-arrow:before {color: black;}#sk-container-id-1 div.sk-toggleable__content {max-height: 0;max-width: 0;overflow: hidden;text-align: left;background-color: #f0f8ff;}#sk-container-id-1 div.sk-toggleable__content pre {margin: 0.2em;color: black;border-radius: 0.25em;background-color: #f0f8ff;}#sk-container-id-1 input.sk-toggleable__control:checked~div.sk-toggleable__content {max-height: 200px;max-width: 100%;overflow: auto;}#sk-container-id-1 input.sk-toggleable__control:checked~label.sk-toggleable__label-arrow:before {content: \"▾\";}#sk-container-id-1 div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 input.sk-hidden--visually {border: 0;clip: rect(1px 1px 1px 1px);clip: rect(1px, 1px, 1px, 1px);height: 1px;margin: -1px;overflow: hidden;padding: 0;position: absolute;width: 1px;}#sk-container-id-1 div.sk-estimator {font-family: monospace;background-color: #f0f8ff;border: 1px dotted black;border-radius: 0.25em;box-sizing: border-box;margin-bottom: 0.5em;}#sk-container-id-1 div.sk-estimator:hover {background-color: #d4ebff;}#sk-container-id-1 div.sk-parallel-item::after {content: \"\";width: 100%;border-bottom: 1px solid gray;flex-grow: 1;}#sk-container-id-1 div.sk-label:hover label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 div.sk-serial::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: 0;}#sk-container-id-1 div.sk-serial {display: flex;flex-direction: column;align-items: center;background-color: white;padding-right: 0.2em;padding-left: 0.2em;position: relative;}#sk-container-id-1 div.sk-item {position: relative;z-index: 1;}#sk-container-id-1 div.sk-parallel {display: flex;align-items: stretch;justify-content: center;background-color: white;position: relative;}#sk-container-id-1 div.sk-item::before, #sk-container-id-1 div.sk-parallel-item::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: -1;}#sk-container-id-1 div.sk-parallel-item {display: flex;flex-direction: column;z-index: 1;position: relative;background-color: white;}#sk-container-id-1 div.sk-parallel-item:first-child::after {align-self: flex-end;width: 50%;}#sk-container-id-1 div.sk-parallel-item:last-child::after {align-self: flex-start;width: 50%;}#sk-container-id-1 div.sk-parallel-item:only-child::after {width: 0;}#sk-container-id-1 div.sk-dashed-wrapped {border: 1px dashed gray;margin: 0 0.4em 0.5em 0.4em;box-sizing: border-box;padding-bottom: 0.4em;background-color: white;}#sk-container-id-1 div.sk-label label {font-family: monospace;font-weight: bold;display: inline-block;line-height: 1.2em;}#sk-container-id-1 div.sk-label-container {text-align: center;}#sk-container-id-1 div.sk-container {/* jupyter's `normalize.less` sets `[hidden] { display: none; }` but bootstrap.min.css set `[hidden] { display: none !important; }` so we also need the `!important` here to be able to override the default hidden behavior on the sphinx rendered scikit-learn.org. See: https://github.com/scikit-learn/scikit-learn/issues/21755 */display: inline-block !important;position: relative;}#sk-container-id-1 div.sk-text-repr-fallback {display: none;}</style><div id=\"sk-container-id-1\" class=\"sk-top-container\"><div class=\"sk-text-repr-fallback\"><pre>MajorityVoteClassifier(classifiers=[Pipeline(steps=[(&#x27;sc&#x27;, StandardScaler()),\n",
       "                                                    (&#x27;clf&#x27;,\n",
       "                                                     LogisticRegression(C=0.001,\n",
       "                                                                        random_state=1))]),\n",
       "                                    DecisionTreeClassifier(criterion=&#x27;entropy&#x27;,\n",
       "                                                           max_depth=1,\n",
       "                                                           random_state=0),\n",
       "                                    Pipeline(steps=[(&#x27;sc&#x27;, StandardScaler()),\n",
       "                                                    (&#x27;clf&#x27;,\n",
       "                                                     KNeighborsClassifier(n_neighbors=1))])])</pre><b>In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. <br />On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.</b></div><div class=\"sk-container\" hidden><div class=\"sk-item\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-1\" type=\"checkbox\" checked><label for=\"sk-estimator-id-1\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">MajorityVoteClassifier</label><div class=\"sk-toggleable__content\"><pre>MajorityVoteClassifier(classifiers=[Pipeline(steps=[(&#x27;sc&#x27;, StandardScaler()),\n",
       "                                                    (&#x27;clf&#x27;,\n",
       "                                                     LogisticRegression(C=0.001,\n",
       "                                                                        random_state=1))]),\n",
       "                                    DecisionTreeClassifier(criterion=&#x27;entropy&#x27;,\n",
       "                                                           max_depth=1,\n",
       "                                                           random_state=0),\n",
       "                                    Pipeline(steps=[(&#x27;sc&#x27;, StandardScaler()),\n",
       "                                                    (&#x27;clf&#x27;,\n",
       "                                                     KNeighborsClassifier(n_neighbors=1))])])</pre></div></div></div></div></div>"
      ],
      "text/plain": [
       "MajorityVoteClassifier(classifiers=[Pipeline(steps=[('sc', StandardScaler()),\n",
       "                                                    ('clf',\n",
       "                                                     LogisticRegression(C=0.001,\n",
       "                                                                        random_state=1))]),\n",
       "                                    DecisionTreeClassifier(criterion='entropy',\n",
       "                                                           max_depth=1,\n",
       "                                                           random_state=0),\n",
       "                                    Pipeline(steps=[('sc', StandardScaler()),\n",
       "                                                    ('clf',\n",
       "                                                     KNeighborsClassifier(n_neighbors=1))])])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mv_clf.set_params(**grid.best_estimator_.get_params())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "43090662-aac3-4430-8ed8-ca65fc2d30cc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>#sk-container-id-2 {color: black;background-color: white;}#sk-container-id-2 pre{padding: 0;}#sk-container-id-2 div.sk-toggleable {background-color: white;}#sk-container-id-2 label.sk-toggleable__label {cursor: pointer;display: block;width: 100%;margin-bottom: 0;padding: 0.3em;box-sizing: border-box;text-align: center;}#sk-container-id-2 label.sk-toggleable__label-arrow:before {content: \"▸\";float: left;margin-right: 0.25em;color: #696969;}#sk-container-id-2 label.sk-toggleable__label-arrow:hover:before {color: black;}#sk-container-id-2 div.sk-estimator:hover label.sk-toggleable__label-arrow:before {color: black;}#sk-container-id-2 div.sk-toggleable__content {max-height: 0;max-width: 0;overflow: hidden;text-align: left;background-color: #f0f8ff;}#sk-container-id-2 div.sk-toggleable__content pre {margin: 0.2em;color: black;border-radius: 0.25em;background-color: #f0f8ff;}#sk-container-id-2 input.sk-toggleable__control:checked~div.sk-toggleable__content {max-height: 200px;max-width: 100%;overflow: auto;}#sk-container-id-2 input.sk-toggleable__control:checked~label.sk-toggleable__label-arrow:before {content: \"▾\";}#sk-container-id-2 div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-2 div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-2 input.sk-hidden--visually {border: 0;clip: rect(1px 1px 1px 1px);clip: rect(1px, 1px, 1px, 1px);height: 1px;margin: -1px;overflow: hidden;padding: 0;position: absolute;width: 1px;}#sk-container-id-2 div.sk-estimator {font-family: monospace;background-color: #f0f8ff;border: 1px dotted black;border-radius: 0.25em;box-sizing: border-box;margin-bottom: 0.5em;}#sk-container-id-2 div.sk-estimator:hover {background-color: #d4ebff;}#sk-container-id-2 div.sk-parallel-item::after {content: \"\";width: 100%;border-bottom: 1px solid gray;flex-grow: 1;}#sk-container-id-2 div.sk-label:hover label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-2 div.sk-serial::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: 0;}#sk-container-id-2 div.sk-serial {display: flex;flex-direction: column;align-items: center;background-color: white;padding-right: 0.2em;padding-left: 0.2em;position: relative;}#sk-container-id-2 div.sk-item {position: relative;z-index: 1;}#sk-container-id-2 div.sk-parallel {display: flex;align-items: stretch;justify-content: center;background-color: white;position: relative;}#sk-container-id-2 div.sk-item::before, #sk-container-id-2 div.sk-parallel-item::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: -1;}#sk-container-id-2 div.sk-parallel-item {display: flex;flex-direction: column;z-index: 1;position: relative;background-color: white;}#sk-container-id-2 div.sk-parallel-item:first-child::after {align-self: flex-end;width: 50%;}#sk-container-id-2 div.sk-parallel-item:last-child::after {align-self: flex-start;width: 50%;}#sk-container-id-2 div.sk-parallel-item:only-child::after {width: 0;}#sk-container-id-2 div.sk-dashed-wrapped {border: 1px dashed gray;margin: 0 0.4em 0.5em 0.4em;box-sizing: border-box;padding-bottom: 0.4em;background-color: white;}#sk-container-id-2 div.sk-label label {font-family: monospace;font-weight: bold;display: inline-block;line-height: 1.2em;}#sk-container-id-2 div.sk-label-container {text-align: center;}#sk-container-id-2 div.sk-container {/* jupyter's `normalize.less` sets `[hidden] { display: none; }` but bootstrap.min.css set `[hidden] { display: none !important; }` so we also need the `!important` here to be able to override the default hidden behavior on the sphinx rendered scikit-learn.org. See: https://github.com/scikit-learn/scikit-learn/issues/21755 */display: inline-block !important;position: relative;}#sk-container-id-2 div.sk-text-repr-fallback {display: none;}</style><div id=\"sk-container-id-2\" class=\"sk-top-container\"><div class=\"sk-text-repr-fallback\"><pre>MajorityVoteClassifier(classifiers=[Pipeline(steps=[(&#x27;sc&#x27;, StandardScaler()),\n",
       "                                                    (&#x27;clf&#x27;,\n",
       "                                                     LogisticRegression(C=0.001,\n",
       "                                                                        random_state=1))]),\n",
       "                                    DecisionTreeClassifier(criterion=&#x27;entropy&#x27;,\n",
       "                                                           max_depth=1,\n",
       "                                                           random_state=0),\n",
       "                                    Pipeline(steps=[(&#x27;sc&#x27;, StandardScaler()),\n",
       "                                                    (&#x27;clf&#x27;,\n",
       "                                                     KNeighborsClassifier(n_neighbors=1))])])</pre><b>In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. <br />On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.</b></div><div class=\"sk-container\" hidden><div class=\"sk-item\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-2\" type=\"checkbox\" checked><label for=\"sk-estimator-id-2\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">MajorityVoteClassifier</label><div class=\"sk-toggleable__content\"><pre>MajorityVoteClassifier(classifiers=[Pipeline(steps=[(&#x27;sc&#x27;, StandardScaler()),\n",
       "                                                    (&#x27;clf&#x27;,\n",
       "                                                     LogisticRegression(C=0.001,\n",
       "                                                                        random_state=1))]),\n",
       "                                    DecisionTreeClassifier(criterion=&#x27;entropy&#x27;,\n",
       "                                                           max_depth=1,\n",
       "                                                           random_state=0),\n",
       "                                    Pipeline(steps=[(&#x27;sc&#x27;, StandardScaler()),\n",
       "                                                    (&#x27;clf&#x27;,\n",
       "                                                     KNeighborsClassifier(n_neighbors=1))])])</pre></div></div></div></div></div>"
      ],
      "text/plain": [
       "MajorityVoteClassifier(classifiers=[Pipeline(steps=[('sc', StandardScaler()),\n",
       "                                                    ('clf',\n",
       "                                                     LogisticRegression(C=0.001,\n",
       "                                                                        random_state=1))]),\n",
       "                                    DecisionTreeClassifier(criterion='entropy',\n",
       "                                                           max_depth=1,\n",
       "                                                           random_state=0),\n",
       "                                    Pipeline(steps=[('sc', StandardScaler()),\n",
       "                                                    ('clf',\n",
       "                                                     KNeighborsClassifier(n_neighbors=1))])])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mv_clf"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "02d950a4-6b95-4f3c-92dc-a7ef3f29e861",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true,
    "tags": []
   },
   "source": [
    "## Bagging - *Building an ensemble of classifiers from bootstrap samples*"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3b967131-6cbc-44bb-9a73-b0125499027c",
   "metadata": {},
   "source": [
    "- ***Bagging is an ensemble learning technique that is closely related to the ```MajorityVoteClassifier```. However, instead of using the same training dataset to fit the individual classifiers in the ensemble, we draw bootstrap samples (random samples with replacement) from the initial training dataset, which is why bagging is also known as bootstrap aggregating.***\n",
    "\n",
    "<div>\n",
    "<img src=\"Images/bagging.png\" width=\"400px\"/>\n",
    "</div>\n",
    "\n",
    "\n",
    "- **Bagging Example:**\n",
    "<div>\n",
    "<img src=\"Images/bagging_ex.png\" width=\"600px\"/>\n",
    "</div>\n",
    "\n",
    "- ***Random Forests are a special case of bagging where we use random feature subsets when fitting individual decision trees.***"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b4f5ac94-f752-4e46-8618-49a773af17e8",
   "metadata": {},
   "source": [
    "### Applying bagging to classify examples in the Wine dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "b30a2574-24fe-4fbc-a8a6-6a5b5b47de15",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "\n",
    "\n",
    "df_wine = pd.read_csv('https://archive.ics.uci.edu/ml/'\n",
    "                      'machine-learning-databases/wine/wine.data',\n",
    "                      header=None)\n",
    "\n",
    "df_wine.columns = ['Class label', 'Alcohol', 'Malic acid', 'Ash',\n",
    "                   'Alcalinity of ash', 'Magnesium', 'Total phenols',\n",
    "                   'Flavanoids', 'Nonflavanoid phenols', 'Proanthocyanins',\n",
    "                   'Color intensity', 'Hue', 'OD280/OD315 of diluted wines',\n",
    "                   'Proline']\n",
    "\n",
    "# drop 1 class\n",
    "df_wine = df_wine[df_wine['Class label'] != 1]\n",
    "\n",
    "y = df_wine['Class label'].values\n",
    "X = df_wine[['Alcohol', 'OD280/OD315 of diluted wines']].values\\\n",
    "\n",
    "# Here we are using only tow features & two class labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "4569fb2f-58b4-41ab-8ed8-245b9bef7182",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Encoding class labels into binary format & train test split\n",
    "\n",
    "from sklearn.preprocessing import LabelEncoder\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "le = LabelEncoder()\n",
    "y = le.fit_transform(y)\n",
    "\n",
    "X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.2,\n",
    "                                                stratify=y, random_state=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "b0aa8ea6-f0c0-4593-918e-4e6ea20d3e13",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Here, using a unpruned Decision tree as a base classifier and creating \n",
    "# an ensemble of 500 decision trees fit on diff. bootstrap samples of \n",
    "# training data\n",
    "\n",
    "from sklearn.ensemble import BaggingClassifier\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "\n",
    "tree = DecisionTreeClassifier(criterion='entropy', random_state=1,\n",
    "                              max_depth=None)\n",
    "\n",
    "bag = BaggingClassifier(base_estimator=tree,\n",
    "                        n_estimators=500,max_samples=1.0,\n",
    "                        max_features=1.0,bootstrap=True,\n",
    "                        bootstrap_features=False,\n",
    "                        n_jobs=1, random_state=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "ae234691-8301-4889-a9fd-dee54cddec10",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Decision tree train/test accuracies 1.000/0.833\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "tree = tree.fit(X_train,y_train)\n",
    "\n",
    "y_train_pred = tree.predict(X_train)\n",
    "y_test_pred = tree.predict(X_test)\n",
    "\n",
    "tree_train = accuracy_score(y_train, y_train_pred)\n",
    "tree_test = accuracy_score(y_test, y_test_pred)\n",
    "\n",
    "print(f'Decision tree train/test accuracies '\n",
    "      f'{tree_train:.3f}/{tree_test:.3f}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b3e5186-795b-4e37-8a29-43d4c5785c4b",
   "metadata": {},
   "source": [
    "Based on the accuracy values above, the unpruned decision tree predicts all the class labels of the training examples correctly; **however, the substantially lower test accuracy indicates high variance (overfitting) of the model.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "c5f8d8db-8a5f-4d46-91a8-37a0e58c9cf8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bagging train/test accuracies 1.000/0.917\n"
     ]
    }
   ],
   "source": [
    "bag = bag.fit(X_train, y_train)\n",
    "y_train_pred = bag.predict(X_train)\n",
    "y_test_pred = bag.predict(X_test)\n",
    "\n",
    "bag_train = accuracy_score(y_train, y_train_pred) \n",
    "bag_test = accuracy_score(y_test, y_test_pred) \n",
    "print(f'Bagging train/test accuracies '\n",
    "      f'{bag_train:.3f}/{bag_test:.3f}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "721a6c50-8f3a-467f-9863-cc08581eaa05",
   "metadata": {},
   "source": [
    "Although the training accuracies of the decision tree and bagging classifier are similar on the training dataset (both 100%), we can see that the bagging classifier has a slightly better generalization performance, as estimated on the test dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "47fb9ffe-6317-490c-8b4e-8f713cb20259",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 800x300 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "\n",
    "x_min = X_train[:, 0].min() - 1\n",
    "x_max = X_train[:, 0].max() + 1\n",
    "y_min = X_train[:, 1].min() - 1\n",
    "y_max = X_train[:, 1].max() + 1\n",
    "\n",
    "xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.1),\n",
    "                     np.arange(y_min, y_max, 0.1))\n",
    "\n",
    "f, axarr = plt.subplots(nrows=1, ncols=2, \n",
    "                        sharex='col', \n",
    "                        sharey='row', \n",
    "                        figsize=(8, 3))\n",
    "\n",
    "\n",
    "for idx, clf, tt in zip([0, 1],\n",
    "                        [tree, bag],\n",
    "                        ['Decision tree', 'Bagging']):\n",
    "    clf.fit(X_train, y_train)\n",
    "\n",
    "    Z = clf.predict(np.c_[xx.ravel(), yy.ravel()])\n",
    "    Z = Z.reshape(xx.shape)\n",
    "\n",
    "    axarr[idx].contourf(xx, yy, Z, alpha=0.3)\n",
    "    axarr[idx].scatter(X_train[y_train == 0, 0],\n",
    "                       X_train[y_train == 0, 1],\n",
    "                       c='blue', marker='^')\n",
    "\n",
    "    axarr[idx].scatter(X_train[y_train == 1, 0],\n",
    "                       X_train[y_train == 1, 1],\n",
    "                       c='green', marker='o')\n",
    "\n",
    "    axarr[idx].set_title(tt)\n",
    "\n",
    "axarr[0].set_ylabel('OD280/OD315 of diluted wines', fontsize=12)\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.text(0, -0.2,\n",
    "         s='Alcohol',\n",
    "         ha='center',\n",
    "         va='center',\n",
    "         fontsize=12,\n",
    "         transform=axarr[1].transAxes)\n",
    "\n",
    "\n",
    "plt.show();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a7092f60-a05f-47eb-9f6a-b284d54105e7",
   "metadata": {},
   "source": [
    "As we can see in the above plot, the piece-wise linear decision boundary of the three-node deep decision tree looks smoother in the bagging ensemble."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5bc88852-aea2-4ed8-8741-5e3627a1e12d",
   "metadata": {},
   "source": [
    "### Imp. points on Bagging\n",
    "\n",
    "- *In practice, more complex classification tasks and a dataset’s high dimensionality can easily lead to overfitting in single decision trees, and this is where the bagging algorithm can really play to its strengths.* \n",
    "\n",
    "- ***Finally, we must note that the bagging algorithm can be an effective approach to reducing the variance of a model.*** \n",
    "\n",
    "- ***However, bagging is ineffective in reducing model bias, i.e., models that are too simple to capture the trends in the data well. This is why we want to <u>perform bagging on an ensemble of classifiers with low bias, for example, unpruned decision trees.</u>***"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b7790eb3-3046-4c11-92da-6538d411bec2",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Leveraging weak learners via *adaptive boosting(AdaBoost)*"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e1c98796-5f52-42b8-b398-45835fcf1396",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Boosting\n",
    "\n",
    "- In boosting, the ensemble consists of very simple base classifiers, also often referred to as **weak learners**, which often only have a slight performance advantage over random guessing—***a typical example of a weak learner is a decision tree stump***. \n",
    "\n",
    "- **The key concept behind boosting is to focus on training examples that are hard to classify, i.e., to let the weak learners subsequently learn from misclassified training examples to improve the performance of the ensemble.**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f755922-213b-40a1-b02b-63edabf4dda3",
   "metadata": {},
   "source": [
    "### How adaptive boosting works\n",
    "\n",
    "- **In contrast to bagging, the initial formulation of the boosting algorithm uses random subsets of training examples drawn from the training dataset without replacement.**\n",
    "\n",
    "- *The original boosting procedure is:*\n",
    "\n",
    "   1. Draw a random subset(sample) of training subset, $d_1$, without replacement from the training dataset, $D$, to train a weak learner, $C_1$.\n",
    "   \n",
    "   2. Draw a second random training subset, $d_2$, without replacement from the training dataset and add 50% of the examples that were previously misclassified to train a weak learner, $C_2$.\n",
    "   \n",
    "   3. Find the training examples, $d_3$, in the training dataset, $D$, which $C_1$ and $C_2$ disagree upon, to train a third weak learner, $C_3$.\n",
    "   \n",
    "   4. Combine the weak learners $C_1$, $C_2$, $C_3$ via majority voting.\n",
    "   \n",
    "\n",
    "- **Boosting can lead to a decrease in bias as well as variance compared to bagging models.** \n",
    "\n",
    "- **In practice, however, boosting algorithms such as AdaBoost are also known for their high variance, i.e., the tendency to overfit the training data.**\n",
    "\n",
    "------------------------------------------------------------"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d0c1deed-4730-4116-bb27-2388782e2170",
   "metadata": {},
   "source": [
    "### AdaBoost illustration step by step\n",
    "\n",
    "**In contrast to the original boosting procedure described, AdaBoost uses the complete training dataset to train the weak learners, where the training examples are reweighted in each iteration to build a strong classifier that learns from the mistakes of the previous weak learners in the ensemble.**\n",
    "\n",
    "\n",
    "<div>\n",
    "<img src=\"Images/adaBoost.png\" width=\"400px\"/>\n",
    "</div>\n",
    "\n",
    "\n",
    "We will start with subfigure 1, which represents a training dataset for binary classification where all training examples are assigned equal weights. Based on this training dataset, we train a decision stump (shown as a dashed line) that tries to classify the examples of the two classes (triangles and circles), as well as possibly minimizing the loss function (or the impurity score in the special case of decision tree ensembles). \n",
    "\n",
    "\n",
    "For the next round (subfigure 2), we assign a larger weight to the two previously misclassified examples (circles). Furthermore, we lower the weight of the correctly classified examples. The next decision stump will now be more focused on the training examples that have the largest weights—the training examples that are supposedly hard to classify. \n",
    "\n",
    "The weak learner shown in subfigure 2 misclassifies three different examples from the circle class, which are then assigned a larger weight, as shown in subfigure 3. \n",
    "\n",
    "\n",
    "Assuming that our AdaBoost ensemble only consists of three rounds of boosting, we then combine the three weak learners trained on different reweighted training subsets by a weighted majority vote, as shown in subfigure 4."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af1fe0cb-3b07-4db6-aff0-dfaff9180208",
   "metadata": {},
   "source": [
    "### AdaBoost Pseudo Code\n",
    "\n",
    "For clarity, we will denote element-wise multiplication by the cross symbol (×) and the dot-product between two vectors by a dot symbol (⋅):\n",
    "\n",
    "\n",
    "1. Set the weight vector, **w**, to uniform weights, where $\\sum_iw_i = 1$.\n",
    "   \n",
    "2. For $j$ in $m$ boosting rounds,:\n",
    "\n",
    "   a. Train a weighted weak learner: $C_j = train(\\textbf{X, y, w})$.\n",
    "     \n",
    "   b. Predict the class labels: $\\hat{y} = predict(C_j, X)$.\n",
    "   \n",
    "   c. Compute the weighted error rate: $\\epsilon = \\textbf{w} \\cdot (\\hat{y} \\neq y)$.\n",
    "   \n",
    "   d. Compute the coefficient: $\\alpha_j = 0.5\\frac{1 - \\epsilon}{\\epsilon}$.\n",
    "   \n",
    "   e. Update the weights: $w := w \\times exp(-\\alpha_j \\times \\hat{y} \\times y)$.\n",
    "   \n",
    "   f. Normalize the weights to sum to 1: $w := \\frac{w}{\\sum_iw_i}$.\n",
    "   \n",
    "3. Compute the final prediction: $\\hat{y} = \\left(\\sum_{j=1}^{m}\\left(\\alpha_j \\times predict(C_j, X)\\right) > 0\\right)$.\n",
    "\n",
    "\n",
    "***Note that the expression $(\\hat{y}\\neq y)$ in step 2c refers to a binary vector consisting of $1s$ and $0s$, where a $1$ is assigned if the prediction is incorrect and $0$ is assigned otherwise.***\n",
    "\n",
    "\n",
    "\n",
    "<div>\n",
    "<img src=\"Images/adaBoost_ex.png\" width=\"400px\"/>\n",
    "</div>\n",
    "\n",
    "A simple adaboost example based on above pseudo code for a 1D-dataset assuming splitting criterion $x \\leq 3.0$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "280fa548-3c13-44c4-b8b4-c1bf2dff32ed",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1]\n",
      "0.3\n"
     ]
    }
   ],
   "source": [
    "y = np.array([1, 1, 1, -1, -1, -1,  1,  1,  1, -1])\n",
    "yhat = np.array([1, 1, 1, -1, -1, -1, -1, -1, -1, -1])\n",
    "correct = (y == yhat)\n",
    "weights = np.full(10, 0.1)\n",
    "print(weights)\n",
    "\n",
    "epsilon = np.mean(~correct)\n",
    "print(epsilon)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "9122b027-ac2f-4af7-b6f8-d0f2b7cfe0e0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.42364893019360184\n"
     ]
    }
   ],
   "source": [
    "alpha_j = 0.5 * np.log((1-epsilon) / epsilon)\n",
    "print(alpha_j)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "5ba3ac30-b876-4cb0-a045-799a9bfe8390",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.06546536707079771\n"
     ]
    }
   ],
   "source": [
    "update_if_correct = 0.1 * np.exp(-alpha_j * 1 * 1)\n",
    "print(update_if_correct)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "7ce26a50-c774-4585-b153-63a70d680e09",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.1527525231651947\n"
     ]
    }
   ],
   "source": [
    "update_if_wrong_1 = 0.1 * np.exp(-alpha_j * 1 * -1)\n",
    "print(update_if_wrong_1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "b3eaccdc-30e9-444c-9b8c-3ce3f2223ad9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.1527525231651947\n"
     ]
    }
   ],
   "source": [
    "update_if_wrong_2 = 0.1 * np.exp(-alpha_j * -1 * 1)\n",
    "print(update_if_wrong_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "3de30ca1-a6a4-4936-9e00-73b438e6493e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.06546537 0.06546537 0.06546537 0.06546537 0.06546537 0.06546537\n",
      " 0.15275252 0.15275252 0.15275252 0.06546537]\n"
     ]
    }
   ],
   "source": [
    "weights = np.where(correct == 1, update_if_correct, update_if_wrong_1)\n",
    "print(weights)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "7f1e4f20-d2fb-4ca9-884e-6c0135b40a90",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.07142857 0.07142857 0.07142857 0.07142857 0.07142857 0.07142857\n",
      " 0.16666667 0.16666667 0.16666667 0.07142857]\n"
     ]
    }
   ],
   "source": [
    "normalized_weights = weights / np.sum(weights)\n",
    "print(normalized_weights)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f7a202d8-399a-4fd5-8e61-a161b9ce6fa0",
   "metadata": {},
   "source": [
    "### AdaBoost in scikit-learn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "366098e4-18c5-4cd4-8fae-0bcc9fddd5aa",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.ensemble import AdaBoostClassifier\n",
    "\n",
    "tree = DecisionTreeClassifier(criterion='entropy', max_depth=1,\n",
    "                             random_state=1)\n",
    "\n",
    "ada = AdaBoostClassifier(base_estimator=tree, n_estimators=500,\n",
    "                         learning_rate=0.1, random_state=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "136f3064-ef07-4963-92f3-fdf857922fcc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Decision tree train/test accuracies 0.916/0.875\n",
      "AdaBoost train/test accuracies 1.000/0.917\n"
     ]
    }
   ],
   "source": [
    "tree = tree.fit(X_train, y_train)\n",
    "\n",
    "y_train_pred = tree.predict(X_train)\n",
    "y_test_pred = tree.predict(X_test)\n",
    "\n",
    "tree_train = accuracy_score(y_train, y_train_pred)\n",
    "tree_test = accuracy_score(y_test, y_test_pred)\n",
    "\n",
    "print(f'Decision tree train/test accuracies '\n",
    "      f'{tree_train:.3f}/{tree_test:.3f}')\n",
    "\n",
    "\n",
    "ada = ada.fit(X_train, y_train)\n",
    "\n",
    "y_train_pred = ada.predict(X_train)\n",
    "y_test_pred = ada.predict(X_test)\n",
    "\n",
    "ada_train = accuracy_score(y_train, y_train_pred) \n",
    "ada_test = accuracy_score(y_test, y_test_pred) \n",
    "\n",
    "print(f'AdaBoost train/test accuracies '\n",
    "      f'{ada_train:.3f}/{ada_test:.3f}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7b0b45c1-043f-43be-8f55-3070691c0f4d",
   "metadata": {},
   "source": [
    "As you can see, the decision tree stump seems to underfit the training data in contrast to the unpruned decision tree that we saw in the previous section.\n",
    "\n",
    "\n",
    "Here, you can see that the AdaBoost model predicts all class labels of the training dataset correctly and also shows a slightly improved test dataset performance compared to the decision tree stump. ***However, you can also see that we introduced additional variance with our attempt to reduce the model bias—a greater gap between training and test performance.***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "f96b6942-13ef-49a1-82a7-749308ecc046",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 800x300 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "x_min, x_max = X_train[:, 0].min() - 1, X_train[:, 0].max() + 1\n",
    "y_min, y_max = X_train[:, 1].min() - 1, X_train[:, 1].max() + 1\n",
    "xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.1),\n",
    "                     np.arange(y_min, y_max, 0.1))\n",
    "\n",
    "f, axarr = plt.subplots(1, 2, sharex='col', sharey='row', figsize=(8, 3))\n",
    "\n",
    "\n",
    "for idx, clf, tt in zip([0, 1],\n",
    "                        [tree, ada],\n",
    "                        ['Decision tree', 'AdaBoost']):\n",
    "    clf.fit(X_train, y_train)\n",
    "\n",
    "    Z = clf.predict(np.c_[xx.ravel(), yy.ravel()])\n",
    "    Z = Z.reshape(xx.shape)\n",
    "\n",
    "    axarr[idx].contourf(xx, yy, Z, alpha=0.3)\n",
    "    axarr[idx].scatter(X_train[y_train == 0, 0],\n",
    "                       X_train[y_train == 0, 1],\n",
    "                       c='blue', marker='^')\n",
    "    axarr[idx].scatter(X_train[y_train == 1, 0],\n",
    "                       X_train[y_train == 1, 1],\n",
    "                       c='green', marker='o')\n",
    "    axarr[idx].set_title(tt)\n",
    "\n",
    "axarr[0].set_ylabel('OD280/OD315 of diluted wines', fontsize=12)\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.text(0, -0.2,\n",
    "         s='Alcohol',\n",
    "         ha='center',\n",
    "         va='center',\n",
    "         fontsize=12,\n",
    "         transform=axarr[1].transAxes)\n",
    "\n",
    "\n",
    "plt.show();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d94ae2ee-c002-4946-bf6e-eff677a41c53",
   "metadata": {},
   "source": [
    "By looking at the decision regions, you can see that the decision boundary of the AdaBoost model is substantially more complex than the decision boundary of the decision stump. In addition, note that the AdaBoost model separates the feature space very similarly to the bagging classifier that we trained in the previous section.\n",
    "\n",
    "\n",
    "*As concluding remarks about ensemble techniques, it is worth noting that ensemble learning increases the computational complexity compared to individual classifiers. In practice, we need to think carefully about whether we want to pay the price of increased computational costs for an often relatively modest improvement in predictive performance.*"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2f7df371-1907-4533-ae37-3d4291743f70",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true,
    "tags": []
   },
   "source": [
    "## *Gradient boosting* - training an ensemble based on loss gradients"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "13ed2f6c-e39d-4f23-9f5e-4c2f90897bb3",
   "metadata": {},
   "source": [
    "### Comparing AdaBoost with gradient boosting\n",
    "\n",
    "- Fundamentally, gradient boosting is very similar to AdaBoost. \n",
    "\n",
    "\n",
    "- AdaBoost trains decision tree stumps based on errors of the previous decision tree stump. In particular, the errors are used to compute sample weights in each round as well as for computing a classifier weight for each decision tree stump when combining the individual stumps into an ensemble. We stop training once a maximum number of iterations (decision tree stumps) is reached. \n",
    "\n",
    "\n",
    "- Like AdaBoost, gradient boosting fits decision trees in an iterative fashion using prediction errors. However, gradient boosting trees are usually deeper than decision tree stumps and have typically a maximum depth of 3 to 6 (or a maximum number of 8 to 64 leaf nodes). \n",
    "\n",
    "-  Also, in contrast to AdaBoost, gradient boosting does not use the prediction errors for assigning sample weights; they are used directly to form the target variable for fitting the next tree. \n",
    "\n",
    "- Moreover, instead of having an individual weighting term for each tree, like in AdaBoost, gradient boosting uses a **global learning rate** that is the same for each tree."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6b62c06b-e465-4417-b297-c0e58547812a",
   "metadata": {},
   "source": [
    "### Outlining the general gradient boosting algorithm\n",
    "\n",
    "***In essence, gradient boosting builds a series of trees, where each tree is fit on the error—the difference between the label and the predicted value—of the previous tree. In each round, the tree ensemble improves as we are nudging each tree more in the right direction via small updates. These updates are based on a loss gradient, which is how gradient boosting got its name.***\n",
    "\n",
    "\n",
    "The general algo. behind gradient boosting:\n",
    "\n",
    "1. **Initialize a model to return a constant prediction value.** For this, we use a decision tree root node; that is, a decision tree with a single leaf node. Denote the value returned by the tree as $\\hat{y}$, and calculate below, by minimizing a differentiable **loss function** $L$:\n",
    "$$F_0(x) = \\arg \\min_{\\hat{y}} \\sum_{i=1}^{n}L(y_i, \\hat{y})$$ $n$ = # of training examples.\n",
    "\n",
    "2. For each tree $m = 1, \\cdots, M$, where $M$ is total num. of user-specified trees:\n",
    "    \n",
    "    **a.)** Compute the diff. b/w a predicted value $F(x_i) = \\hat{y}_i$ and the class label $y_i$. This value is sometimes called the ***pseudo-response*** or ***pseudo-residual***, which is negative gradient of the loss function w.r.to the predicted values: \n",
    "    \n",
    "    $$r_{im} = -\\left[\\frac{\\partial L(y_i, F(x_i))}{\\partial F(x_i)}\\right]_{F(x) = F_{m-1}(x)} \\text{for } i = 1, \\cdots, n$$\n",
    "    \n",
    "    Note that, $F(x)$ is the prediction of the previous tree. $F_{m-1}(x)$. So, in the first round this refers to the constant value from the tree(single leaf node) from step 1.\n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    **b.)** Fit the tree to the pseudo-residual $r_{mi}$. We use the notation $R_{jm}$ to denote the $j = 1 \\cdots J_m$ leaf nodes of the resulting tree in iteration $m$.\n",
    "    \n",
    "    \n",
    "    **c.)** For each leaf node $R_{jm}$, compute\n",
    "    \n",
    "    $$\\gamma_{jm} = \\arg \\min_{\\gamma} \\sum_{x_i \\in R_{jm}} L(y_i, F_{m-1}(x_i) + \\gamma)$$ \n",
    "    \n",
    "    $\\gamma_{jm}$ is computed by minimizing the loss function. At this point, we can already note that leaf nodes $R_{jm}$ may contain more than one training example, hence the summation.\n",
    "    \n",
    "    \n",
    "    **d.)** Update the model by adding the o/p values $\\gamma_m$ to the previous tree:\n",
    "    \n",
    "    $$F_m(x) = F_{m-1}(x) + \\eta\\gamma_{m}$$\n",
    "    \n",
    "    We scale predicted value, $\\gamma_m$ using the learning rate $\\eta$, which is a small value b/w $[0.01,1]$ instead of directly adding the full predicted value. In other words, we update the model incrementally by taking small steps, which helps avoid overfitting."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "038838e0-2bb3-494d-8443-668d262f4725",
   "metadata": {},
   "source": [
    "### Explaining the gradient boosting algorithm for classification\n",
    "\n",
    "Logistic loss function: \n",
    "\n",
    "$$L_i = -y_i \\log p_i + (1-y_i)\\log (1-p_i)$$\n",
    "\n",
    "\n",
    "Log odds: \n",
    "\n",
    "$$\\hat{y} = \\log (odds) = \\log \\frac{p}{1-p}$$\n",
    "\n",
    "\n",
    "Re-writing the logistic function w.r.t log(odds): \n",
    "\n",
    "$$L_i = \\log (1 + e^{\\hat{y}_i}) - y_i\\hat{y}_i$$\n",
    "\n",
    "\n",
    "Partial derivative of loss function w.r.t logg(odds), $\\hat{y}$:\n",
    "\n",
    "$$\\frac{\\partial L_i}{\\partial \\hat{y}_i} = \\frac{e^{\\hat{y}_i}}{1 + e^{\\hat{y}_i}} - y_i = p_i - y_i$$\n",
    "\n",
    "\n",
    "---------------------------------------------------------------------------\n",
    "\n",
    "\n",
    "Now, applying gradient boosting steps:\n",
    "\n",
    "\n",
    "1. Create a root node that minimizes the logistic loss. It turns out that the loss is minimized if the root node returns the log(odds), $\\hat{y}$.\n",
    "\n",
    "\n",
    "2. For each tree $m = 1, \\cdots, M$, where $M$ is total num. of user-specified trees:\n",
    "\n",
    "    **a.)** We convert the log(odds) into a probability as: $$p = \\frac{1}{1 + e^{-\\hat{y}}}$$ Then, compute pseudo-residual which is the negative partial derivative of the loss with respect to the log(odds), which turns out to be the difference between the class label and the predicted probability: $$-\\frac{\\partial L_i}{\\partial \\hat{y}_i} = y_i - p_i$$\n",
    "    \n",
    "    \n",
    "    **b.)** Fit a new tree to the pseudo-residual.\n",
    "    \n",
    "    \n",
    "    **c.)** For each leaf node $R_{jm}$, compute a value that minimizes the logistic loss function. This includes a summarization step for dealing with leaf nodes that contain multiple training examples:\n",
    "    \n",
    "    $$\\gamma_{jm} = \\arg \\min_{\\gamma} \\sum_{x_i \\in R_{jm}} L(y_i, F_{m-1}(x_i) + \\gamma)\\\\\n",
    "    \\\\\n",
    "    \\\\\n",
    "    = \\log\\left(1 + e^{\\hat{y}_i + \\gamma}\\right) - y_i(\\hat{y}_i + \\gamma)$$ \n",
    "    \n",
    "    Skipping over intermediate mathematical details, this results in the following:\n",
    "    \n",
    "    $$\\gamma_{jm} = \\frac{\\sum_i y_i - p_i}{\\sum_i p_i(i - p_i)}$$\n",
    "    \n",
    "    Note that the summation here is only over the examples at the node corresponding to the leaf node $R_{jm}$ and not the complete training set.\n",
    "    \n",
    "    \n",
    "    **d.)** Update the model by adding the gamma value from step-2c with learning rate $\\eta$: \n",
    "    \n",
    "    $$F_m(x) = F_{m-1}(x) + \\eta\\gamma_m$$\n",
    "    \n",
    "    \n",
    "----------------------------------------------------------------\n",
    "\n",
    "#### Outputting log(odds) vs probabilities \n",
    "\n",
    "Why do the trees return log(odds) values and not probabilities? This is because we cannot just add up probability values and arrive at a meaningful result. (So, technically speaking, gradient boosting for classification uses regression trees.)\n",
    "\n",
    "---------------------------------------------------------------------\n",
    "\n",
    "In this section, we adopted the general gradient boosting algorithm and specified it for binary classification, for instance, by replacing the generic loss function with the logistic loss and the predicted values with the log(odds).\n",
    "\n",
    "-----------------------------------------------------------------------------"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "363b1102-cee0-446e-935b-729b423cc5a9",
   "metadata": {},
   "source": [
    "### Illustrating gradient boosting for classification\n",
    "\n",
    "- Toy Dataset\n",
    "<div>\n",
    "<img src=\"Images/gb_1.png\" width=\"300px\"/>\n",
    "</div>\n",
    "\n",
    "\n",
    "- Start with **step 1**, constructing the root node and computing the log(odds), and **step 2a**, converting the log(odds) into class-membership probabilities and computing the pseudo-residuals.<br>the odds can be computed as the # of successes divided by the # of failures. Here, we regard label 1 as success and label 0 as failure, so the odds are computed as: odds = 2/1:\n",
    "<div>\n",
    "<img src=\"Images/gb_2.png\"/>\n",
    "</div>\n",
    "\n",
    "\n",
    "- Next, in **step 2b**, we fit a new tree on the pseudo-residuals $r$. Then, in **step 2c**, we compute the output values, $\\gamma$, for this tree:\n",
    "<div>\n",
    "<img src=\"Images/gb_3.png\" width=\"500px\"/>\n",
    "</div>\n",
    "(Note that we artificially limit the tree to have only two leaf nodes, which helps illustrate what happens if a leaf node contains more than one example.)\n",
    "\n",
    "\n",
    "- Then, in the final **step 2d**, we update the previous model and the current model. Assuming a learning rate of $\\eta = 0.1$, the resulting prediction for the first training example:\n",
    "<div>\n",
    "<img src=\"Images/gb_4.png\" width=\"500px\"/>\n",
    "</div>\n",
    "\n",
    "\n",
    "- Now that we have completed **steps 2a to 2d** of the first round, m = 1, we can proceed to execute **steps 2a to 2d** for the second round, m = 2. In the second round, we use the log(odds) returned by the updated model, for example, $F_1(x_1) = 0.839$, as input to **step 2A**. The new values we obtain in the second round are:\n",
    "<div>\n",
    "<img src=\"Images/gb_5.png\" width=\"500px\"/>\n",
    "</div>\n",
    "\n",
    "We can already see that the predicted probabilities are higher for the positive class and lower for the negative class. Consequently, the residuals are getting smaller, too. Note that the process of steps 2a to 2d is repeated until we have fit M trees or the residuals are smaller than a user-specified threshold value. Then, once the gradient boosting algorithm has completed, we can use it to predict the class labels by thresholding the probability values of the final model, FM(x) at 0.5, like logistic regression in Chapter 3. However, in contrast to logistic regression, gradient boosting consists of multiple trees and produces nonlinear decision boundaries."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6a547190-7282-4e57-b539-44f43f17d0af",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true,
    "tags": []
   },
   "source": [
    "## Using XG Boost\n",
    "\n",
    "Algorithms using Gradient Boosting\n",
    "- ```XGBoost``` $\\rightarrow \\text{Extreme Gradient Boosting}$\n",
    "- ```LightGBM```\n",
    "- ```CatBoost```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "efe5a388-45e8-460e-b2a8-535f76360d49",
   "metadata": {},
   "outputs": [],
   "source": [
    "# !pip install xgboost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "1dfc81a7-70d6-4fd4-b2b5-26be10fdd683",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "XGboost train/test accuracies 0.968/0.917\n"
     ]
    }
   ],
   "source": [
    "import xgboost as xgb\n",
    "\n",
    "model = xgb.XGBClassifier(n_estimators=1000, learning_rate=0.01,\n",
    "                          max_depth=4, random_state=1,\n",
    "                          use_label_encoder=False)\n",
    "\n",
    "gbm = model.fit(X_train, y_train)\n",
    "\n",
    "y_train_pred = gbm.predict(X_train)\n",
    "y_test_pred = gbm.predict(X_test)\n",
    "\n",
    "gbm_train = accuracy_score(y_train, y_train_pred) \n",
    "gbm_test = accuracy_score(y_test, y_test_pred) \n",
    "\n",
    "print(f'XGboost train/test accuracies '\n",
    "      f'{gbm_train:.3f}/{gbm_test:.3f}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6cb57e39-af94-41b0-bc76-fac40abc1e0f",
   "metadata": {},
   "source": [
    "Here, we fit the gradient boosting classifier with 1,000 trees (rounds) and a learning rate of 0.01. Typically, a learning rate between 0.01 and 0.1 is recommended. However, remember that the learning rate is used for scaling the predictions from the individual rounds. So, intuitively, the lower the learning rate, the more estimators are required to achieve accurate predictions.\n",
    "\n",
    "\n",
    "Next, we have the ```max_depth``` for the individual decision trees, which we set to 4. Since we are still boosting weak learners, a value between 2 and 6 is reasonable, but larger values may also work well depending on the dataset. \n",
    "\n",
    "\n",
    "Finally, ```use_label_encoder=False``` disables a warning message which informs users that XGBoost is not converting labels by default anymore, and it expects users to provide labels in an integer format starting with label 0."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c8b7a4bb-9f97-4113-a60d-2d9ed0fae474",
   "metadata": {},
   "source": [
    "## Summary\n",
    "\n",
    "\n",
    "- Ensemble methods combine different classification models to cancel out their individual weaknesses, which often results in stable and well-performing models.\n",
    "\n",
    "- At the beginning of this chapter, we implemented ```MajorityVoteClassifier``` in Python, which allows us to combine different algorithms for classification. \n",
    "\n",
    "- **We then looked at bagging, a useful technique for reducing the variance of a model by drawing random bootstrap samples from the training dataset and combining the individually trained classifiers via majority vote.**\n",
    "\n",
    "- **Lastly, we learned about boosting in the form of AdaBoost and gradient boosting, which are algorithms based on training weak learners that subsequently learn from mistakes.**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6e17967d-8e19-41a7-98dc-f0808ffa1efd",
   "metadata": {},
   "source": [
    "***Reference:***\n",
    "\n",
    "***Raschka, Sebastian; Liu, Yuxi (Hayden); Mirjalili, Vahid. Machine Learning with PyTorch and Scikit-Learn: Develop machine learning and deep learning models with Python. Packt Publishing.*** "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.16"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {},
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}