06-algorithm-chains-and-pipelines.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hide_input": false
   },
   "outputs": [],
   "source": [
    "from preamble import *\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/l_/499_8k_5387b9tz3wp5g8lg00000gn/T/ipykernel_6279/2603895367.py:13: DeprecationWarning: `set_matplotlib_formats` is deprecated since IPython 7.23, directly use `matplotlib_inline.backend_inline.set_matplotlib_formats()`\n",
      "  set_matplotlib_formats('pdf', 'png')\n"
     ]
    }
   ],
   "source": [
    "#from preamble import *\n",
    "#%matplotlib inline\n",
    "#=================================\n",
    "from IPython.display import set_matplotlib_formats, display\n",
    "import pandas as pd\n",
    "%matplotlib inline\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import mglearn\n",
    "from cycler import cycler\n",
    "\n",
    "set_matplotlib_formats('pdf', 'png')\n",
    "plt.rcParams['savefig.dpi'] = 300\n",
    "plt.rcParams['image.cmap'] = \"viridis\"\n",
    "plt.rcParams['image.interpolation'] = \"none\"\n",
    "plt.rcParams['savefig.bbox'] = \"tight\"\n",
    "plt.rcParams['lines.linewidth'] = 2\n",
    "plt.rcParams['legend.numpoints'] = 1\n",
    "plt.rc('axes', prop_cycle=( cycler('color', mglearn.plot_helpers.cm_cycle.colors) +  cycler('linestyle', ['-', '-', \"--\", (0, (3, 3)), (0, (1.5, 1.5))])))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Algorithm Chains and Pipelines"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> There are standard workflows in applied machine learning. Standard because they overcome common problems like data leakage in your test harnes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- For many machine learning algorithms, the particular representation of the data that you provide is very important. This starts with scaling the data and combining features by hand and goes all the way to learning features using unsupervised machine learning. <br><br>\n",
    "- Consequently, most machine learning applications require not only the application of a single algorithm, but the chaining together of many different processing steps and machine learning models. <br><br>\n",
    "- In this chapter, we will cover how to use the **Pipeline** class to simplify the process of building chains of transformations and models. <br><br>\n",
    "- In particular, we will see how we can combine Pipeline and GridSearchCV to search over parameters for all processing steps at once."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Example: -  As an example of the importance of chaining models, we noticed that we can greatly improve the performance of a kernel SVM on the cancer dataset by using the Min MaxScaler for preprocessing. Here’s code for splitting the data, computing the minimum and maximum, scaling the data, and training the SVM:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.svm import SVC\n",
    "from sklearn.datasets import load_breast_cancer\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "\n",
    "# load and split the data\n",
    "cancer = load_breast_cancer()\n",
    "X_train, X_test, y_train, y_test = train_test_split(\n",
    "    cancer.data, cancer.target, random_state=0)\n",
    "\n",
    "# compute minimum and maximum on the training data\n",
    "scaler = MinMaxScaler().fit(X_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test score: 0.97\n"
     ]
    }
   ],
   "source": [
    "# rescale the training data\n",
    "X_train_scaled = scaler.transform(X_train)\n",
    "\n",
    "svm = SVC()\n",
    "# learn an SVM on the scaled training data\n",
    "svm.fit(X_train_scaled, y_train)\n",
    "# scale the test data and score the scaled data\n",
    "X_test_scaled = scaler.transform(X_test)\n",
    "print(\"Test score: {:.2f}\".format(svm.score(X_test_scaled, y_test)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Parameter Selection with Preprocessing "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Now let’s say we want to find better parameters for SVC using GridSearchCV\n",
    "\n",
    "- A naive approach might look like this:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best cross-validation accuracy: 0.98\n",
      "Best parameters:  {'C': 1, 'gamma': 1}\n",
      "Test set accuracy: 0.97\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import GridSearchCV\n",
    "# for illustration purposes only, don't use this code!\n",
    "param_grid = {'C': [0.001, 0.01, 0.1, 1, 10, 100],\n",
    "              'gamma': [0.001, 0.01, 0.1, 1, 10, 100]}\n",
    "grid = GridSearchCV(SVC(), param_grid=param_grid, cv=5)\n",
    "grid.fit(X_train_scaled, y_train)\n",
    "print(\"Best cross-validation accuracy: {:.2f}\".format(grid.best_score_))\n",
    "print(\"Best parameters: \", grid.best_params_)\n",
    "print(\"Test set accuracy: {:.2f}\".format(grid.score(X_test_scaled, y_test)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Probelm \n",
    "\n",
    "\n",
    "-  When scaling the data, we used all the data in the training set to find out how to train it. <br><br> \n",
    "-   We then use the scaled training data to run our grid search using cross-validation. <br><br> \n",
    "-   For each split in the cross-validation, some part of the original training set will be declared the training part of the split, and some the test part of the split.  <br><br> \n",
    "-   The test part is used to measure what new data will look like to a model trained on the training part.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> So, the splits in the cross-validation no longer correctly mirror how new data will look to the modeling process. We already leaked information from these parts of the data into our modeling process. This will lead to overly optimistic results during cross-validation, and possibly the selection of suboptimal parameters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> To get around this problem, the splitting of the dataset during cross-validation should be done before doing any preprocessing. Any process that extracts knowledge from the dataset should only ever be applied to the training portion of the dataset, so any cross-validation should be the “outermost loop” in your processing\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Data leakage blog : https://towardsdatascience.com/how-to-avoid-data-leakage-while-evaluating-the-performance-of-a-machine-learning-model-ac30f2bb8586"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "hide_input": false
   },
   "outputs": [
    {
     "data": {
      "application/pdf": "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\n",
      "image/png": "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",
      "text/plain": [
       "<Figure size 1080x720 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "mglearn.plots.plot_improper_processing()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### What is the solution to Data Leakage?\n",
    "\n",
    "- Sklearn pipeline  <br><br>\n",
    "- Pipeline for k-fold cross-validation prevents data leakage and provides a better estimate of the model’s performance on unseen data. <br><br>\n",
    "- The Pipeline class itself has fit, predict, and score methods and behaves just like any other model in scikit-learn.  <br><br>\n",
    "- The most common use case of the Pipeline class is in chaining preprocessing steps (like scaling of the data) together with a supervised model like a classifier."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Building Pipelines"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-  The Pipeline class is a class that allows “gluing” together multiple processing steps into a single scikit-learn estimator <br><br>\n",
    "-  Let’s look at how we can use the Pipeline class to express the workflow for training an SVM after scaling the data with MinMaxScaler (for now without the grid search). <br><br>\n",
    "-  First, we build a pipeline object by providing it with a list of steps. Each step is a tuple containing a name (any string of your choosing1) and an instance of an estimator\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test score: 0.97\n"
     ]
    }
   ],
   "source": [
    "#od approach\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.datasets import load_breast_cancer\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "\n",
    "# load and split the data\n",
    "cancer = load_breast_cancer()\n",
    "X_train, X_test, y_train, y_test = train_test_split(\n",
    "    cancer.data, cancer.target, random_state=0)\n",
    "\n",
    "# compute minimum and maximum on the training data\n",
    "scaler = MinMaxScaler().fit(X_train)\n",
    "\n",
    "# rescale the training data\n",
    "X_train_scaled = scaler.transform(X_train)\n",
    "\n",
    "svm = SVC()\n",
    "# learn an SVM on the scaled training data\n",
    "svm.fit(X_train_scaled, y_train)\n",
    "# scale the test data and score the scaled data\n",
    "X_test_scaled = scaler.transform(X_test)\n",
    "print(\"Test score: {:.2f}\".format(svm.score(X_test_scaled, y_test)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **pipeline:** Sequentially apply a list of transforms and a final estimator. Intermediate steps of the pipeline must be ‘transforms’, that is, they must implement fit and transform methods. The final estimator only needs to implement fit. See more from SKlearn [Pipeline](https://scikit-learn.org/stable/modules/generated/sklearn.pipeline.Pipeline.html)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test score: 0.97\n"
     ]
    }
   ],
   "source": [
    "# import the necessary modules\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.datasets import load_breast_cancer\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "\n",
    "\n",
    "# load and split the data\n",
    "cancer = load_breast_cancer()\n",
    "X_train, X_test, y_train, y_test = train_test_split(\n",
    "    cancer.data, cancer.target, random_state=0)\n",
    "\n",
    "# import pipeline from sklearn.pipeline  \n",
    "from sklearn.pipeline import Pipeline\n",
    "\n",
    "\n",
    "#Each step is a tuple containing a name (any string of your choosing1) and an instance of an estimator\n",
    "pipe = Pipeline([(\"scaler\", MinMaxScaler()), (\"svm\", SVC())])\n",
    "\n",
    "#we created two steps: the first, called \"scaler\", is an instance of MinMaxScaler, and the second, called \"svm\", is an instance of SVC. Now, we can fit the pipeline, like any other scikit-learn estimator:\n",
    "    \n",
    "#pipe.fit first calls fit on the first step (the scaler), then transforms the training data using the scaler, and finally fits the SVM with the scaled data. To evaluate on the test data, we simply call pipe.score:\n",
    "\n",
    "pipe.fit(X_train, y_train)\n",
    "\n",
    "# score the pipeline on the test data\n",
    "print(\"Test score: {:.2f}\".format(pipe.score(X_test, y_test)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Calling the score method on the pipeline first **transforms** the test data using the scaler, and then **calls the score method** on the SVM using the scaled test data. As you can see, the result is identical to the one we got above, when doing the transformations by hand. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using the pipeline, we reduced the code needed for our “preprocessing + classification” process. The main benefit of using the pipeline, however, is that we can now use this single estimator in cross_val_score or GridSearchCV"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using Pipelines in Grid-searches"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Using a pipeline in a grid search works the same way as using any other estimator. We define a parameter grid to search over, and construct a GridSearchCV from the pipeline and the parameter grid \n",
    "- When specifying the parameter grid, there is a slight change, though. We need to specify for each parameter which step of the pipeline it belongs to. \n",
    "- Both parameters that we want to adjust, C and gamma, are parameters of SVC, the second step. We gave this step the name \"svm\". \n",
    "- The syntax to define a parameter grid for a pipeline is to specify for each parameter the step name, followed by __ (a double underscore), followed by the parameter name. To search over the C parameter of SVC we therefore have to use \"svm__C\" as the key in the parameter grid dictionary, and similarly for gamma:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best cross-validation accuracy: 0.98\n",
      "Test set score: 0.97\n",
      "Best parameters: {'svm__C': 1, 'svm__gamma': 1}\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import GridSearchCV\n",
    "\n",
    "pipe = Pipeline([(\"scaler\", MinMaxScaler()), (\"svm\", SVC())])\n",
    "\n",
    "\n",
    "param_grid = {'svm__C': [0.001, 0.01, 0.1, 1, 10, 100],\n",
    "              'svm__gamma': [0.001, 0.01, 0.1, 1, 10, 100]}\n",
    "\n",
    "grid = GridSearchCV(pipe, param_grid=param_grid, cv=5)\n",
    "grid.fit(X_train, y_train)\n",
    "print(\"Best cross-validation accuracy: {:.2f}\".format(grid.best_score_))\n",
    "print(\"Test set score: {:.2f}\".format(grid.score(X_test, y_test)))\n",
    "print(\"Best parameters: {}\".format(grid.best_params_))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> In contrast to the grid search we did before, now for each split in the cross-validation, the MinMaxScaler is refit with only the training splits and no information is leaked from the test split into the parameter search.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "hide_input": false
   },
   "outputs": [
    {
     "data": {
      "application/pdf": "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\n",
      "image/png": "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",
      "text/plain": [
       "<Figure size 1080x576 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "mglearn.plots.plot_proper_processing()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Illustrating Information Leakage\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Let’s consider a synthetic regression task with 100 samples and 1,000 features that are sampled independently from a Gaussian distribution. We also sample the response from a Gaussian distribution:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "rnd = np.random.RandomState(seed=0)\n",
    "X = rnd.normal(size=(100, 10000)) #features\n",
    "y = rnd.normal(size=(100,)) #target"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Given the way we created the dataset, there is no relation between the data, X, and the target, y (they are independent), so it should not be possible to learn anything from this dataset. <br><br>\n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will select the most informative of the features using SelectPercentile feature selection, and then we evaluate a Ridge regressor using cross-validation:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X_selected.shape: (100, 500)\n"
     ]
    }
   ],
   "source": [
    "from sklearn.feature_selection import SelectPercentile, f_regression\n",
    "\n",
    "select = SelectPercentile(score_func=f_regression, percentile=5).fit(X, y)\n",
    "X_selected = select.transform(X)\n",
    "print(\"X_selected.shape: {}\".format(X_selected.shape))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cross-validation accuracy (cv only on ridge): 0.91\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import cross_val_score\n",
    "from sklearn.linear_model import Ridge\n",
    "print(\"Cross-validation accuracy (cv only on ridge): {:.2f}\".format(\n",
    "      np.mean(cross_val_score(Ridge(), X_selected, y, cv=5))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> The mean Rsquared computed by cross-validation is 0.91, indicating a very good model. This clearly cannot be right, as our data is entirely random. What happened here is that our feature selection picked out some features among the 10,000 random features that are (by chance) very well correlated with the target. Because we fit the feature selection outside of the cross-validation, it could find features that are correlated both on the training and the test folds. The information we leaked from the test folds was very informative, leading to highly unrealistic results."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " Let’s compare this to a proper cross-validation using a pipeline:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cross-validation accuracy (pipeline): -0.25\n"
     ]
    }
   ],
   "source": [
    "pipe = Pipeline([(\"select\", SelectPercentile(score_func=f_regression,\n",
    "                                             percentile=5)),\n",
    "                 (\"ridge\", Ridge())])\n",
    "print(\"Cross-validation accuracy (pipeline): {:.2f}\".format(\n",
    "      np.mean(cross_val_score(pipe, X, y, cv=5))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> This time, we get a negative Rsquared score, indicating a very poor model.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The General Pipeline Interface"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> The Pipeline class is not restricted to preprocessing, it can join any number of estimators together.  <br><br>\n",
    "> For example, you could build a pipeline containing feature extraction, feature selection, scaling, and classification, for a total of four steps. Similarly, the last step could be regression or clustering instead of classification\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- The only requirement for estimators in a pipeline is that all but the last step need to have a transform method, so they can produce a new representation of the data that can be used in the next step <br><br>\n",
    "\n",
    "- Pipeline.fit, the pipeline calls fit and then transform on each step in turn,2 with the input given by the output of the transform method of the previous step.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fit(self, X, y):\n",
    "    X_transformed = X\n",
    "    for name, estimator in self.steps[:-1]:\n",
    "        # iterate over all but the final step\n",
    "        # fit and transform the data\n",
    "        X_transformed = estimator.fit_transform(X_transformed, y)\n",
    "    # fit the last step\n",
    "    self.steps[-1][1].fit(X_transformed, y)\n",
    "    return self"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict(self, X):\n",
    "    X_transformed = X\n",
    "    for step in self.steps[:-1]:\n",
    "        # iterate over all but the final step\n",
    "        # transform the data\n",
    "        X_transformed = step[1].transform(X_transformed)\n",
    "    # predict using the last step\n",
    "    return self.steps[-1][1].predict(X_transformed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![pipeline_illustration](images/pipeline.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Convenient Pipeline creation with ``make_pipeline``"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Creating a pipeline using the syntax described earlier is sometimes a bit cumbersome, and we often don’t need user-specified names for each step. <br><br>\n",
    "- There is a convenience function, make_pipeline, that will create a pipeline for us and automatically name each step based on its class. The syntax for make_pipeline is as follows:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.pipeline import make_pipeline\n",
    "# standard syntax\n",
    "pipe_long = Pipeline([(\"scaler\", MinMaxScaler()), (\"svm\", SVC(C=100))])\n",
    "# abbreviated syntax\n",
    "pipe_short = make_pipeline(MinMaxScaler(), SVC(C=100))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> The pipeline objects pipe_long and pipe_short do exactly the same thing, but pipe_short has steps that were automatically named. We can see the names of the steps by looking at the steps attribute\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pipeline steps:\n",
      "[('minmaxscaler', MinMaxScaler()), ('svc', SVC(C=100))]\n"
     ]
    }
   ],
   "source": [
    "print(\"Pipeline steps:\\n{}\".format(pipe_short.steps))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> The steps are named minmaxscaler and svc. In general, the step names are just lowercase versions of the class names. If multiple steps have the same class, a number is appended:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pipeline steps:\n",
      "[('standardscaler-1', StandardScaler()), ('pca', PCA(n_components=2)), ('standardscaler-2', StandardScaler())]\n"
     ]
    }
   ],
   "source": [
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.decomposition import PCA\n",
    "\n",
    "pipe = make_pipeline(StandardScaler(), PCA(n_components=2), StandardScaler())\n",
    "print(\"Pipeline steps:\\n{}\".format(pipe.steps))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> As you can see, the first StandardScaler step was named standardscaler-1 and the second standardscaler-2. However, in such settings it might be better to use the Pipeline construction with explicit names, to give more semantic names to each step\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Accessing step attributes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Often you will want to inspect attributes of one of the steps of the pipeline—say, the coefficients of a linear model or the components extracted by PCA. The easiest way to access the steps in a pipeline is via the named_steps attribute, which is a dictionary from the step names to the estimators:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "components.shape: (2, 30)\n"
     ]
    }
   ],
   "source": [
    "# fit the pipeline defined before to the cancer dataset\n",
    "pipe.fit(cancer.data)\n",
    "# extract the first two principal components from the \"pca\" step\n",
    "components = pipe.named_steps[\"pca\"].components_\n",
    "print(\"components.shape: {}\".format(components.shape))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Accessing Attributes in a Pipeline inside GridSearchCV"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- One of the main reasons to use pipelines is for doing grid searches. <br><br>\n",
    "- A common task is to access some of the steps of a pipeline inside a grid search. <br><br>\n",
    "-  Let’s grid search a LogisticRegression classifier on the cancer dataset  <br><br>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.linear_model import LogisticRegression\n",
    "pipe = make_pipeline(StandardScaler(), LogisticRegression(max_iter=1000))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Lets us create a parameter grid. Regularization parameter to tune for LogisticRegression is the parameter C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Because we used the make_pipeline function, the name of the LogisticRegression step in the pipeline is the lowercased class name, logisticregression. To tune the parameter C, we therefore have to specify a parameter grid for logisticregression__C:\n",
    "\n",
    "param_grid = {'logisticregression__C': [0.01, 0.1, 1, 10, 100]}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As usual, we split the cancer dataset into training and test sets, and fit a grid search:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "GridSearchCV(cv=5,\n",
       "             estimator=Pipeline(steps=[('standardscaler', StandardScaler()),\n",
       "                                       ('logisticregression',\n",
       "                                        LogisticRegression(max_iter=1000))]),\n",
       "             param_grid={'logisticregression__C': [0.01, 0.1, 1, 10, 100]})"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train, X_test, y_train, y_test = train_test_split(\n",
    "    cancer.data, cancer.target, random_state=4)\n",
    "grid = GridSearchCV(pipe, param_grid, cv=5)\n",
    "grid.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So how do we access the coefficients of the best LogisticRegression model that was found by GridSearchCV?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best estimator:\n",
      "Pipeline(steps=[('standardscaler', StandardScaler()),\n",
      "                ('logisticregression', LogisticRegression(C=1, max_iter=1000))])\n"
     ]
    }
   ],
   "source": [
    "#best model found by GridSearchCV, trained on all the training data, is stored in grid.best_estimator_:\n",
    "\n",
    "print(\"Best estimator:\\n{}\".format(grid.best_estimator_))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This best_estimator_ in our case is a pipeline with two steps, standardscaler and logisticregression. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To access the logisticregression step, we can use the named_steps attribute of the pipeline, as explained earlier:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Logistic regression step:\n",
      "LogisticRegression(C=1, max_iter=1000)\n"
     ]
    }
   ],
   "source": [
    "print(\"Logistic regression step:\\n{}\".format(\n",
    "      grid.best_estimator_.named_steps[\"logisticregression\"]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "we can also access the coefficients (weights) associated with each input feature\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Logistic regression coefficients:\n",
      "[[-0.43570655 -0.34266946 -0.40809443 -0.5344574  -0.14971847  0.61034122\n",
      "  -0.72634347 -0.78538827  0.03886087  0.27497198 -1.29780109  0.04926005\n",
      "  -0.67336941 -0.93447426 -0.13939555  0.45032641 -0.13009864 -0.10144273\n",
      "   0.43432027  0.71596578 -1.09068862 -1.09463976 -0.85183755 -1.06406198\n",
      "  -0.74316099  0.07252425 -0.82323903 -0.65321239 -0.64379499 -0.42026013]]\n"
     ]
    }
   ],
   "source": [
    "print(\"Logistic regression coefficients:\\n{}\".format(\n",
    "      grid.best_estimator_.named_steps[\"logisticregression\"].coef_))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Grid-searching preprocessing steps and model parameters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Using pipelines, we can encapsulate all the processing steps in our machine learning workflow in a single scikit-learn estimaton <br><br>\n",
    "\n",
    "- nother benefit of doing this is that we can now adjust the parameters of the preprocessing using the outcome of a supervised task like regression or classification. <br><br>\n",
    " \n",
    "\n",
    "- In previous chapters, we used polynomial features on the boston dataset before applying the ridge regressor.  <br><br>\n",
    "- Let’s model that using a pipeline instead. The pipeline contains three steps—scaling the data, computing polynomial features, and ridge regression:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.datasets import load_boston\n",
    "boston = load_boston()\n",
    "X_train, X_test, y_train, y_test = train_test_split(boston.data, boston.target,\n",
    "                                                    random_state=0)\n",
    "\n",
    "from sklearn.preprocessing import PolynomialFeatures\n",
    "pipe = make_pipeline(\n",
    "    StandardScaler(),\n",
    "    PolynomialFeatures(),\n",
    "    Ridge())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> How do we know which degrees of polynomials to choose, or whether to choose any polynomials or interactions at all? Ideally we want to select the degree parameter based on the outcome of the classification. Using our pipeline, we can search over the degree parameter together with the parameter alpha of Ridge. To do this, we define a param_grid that contains both, appropriately prefixed by the step names:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "param_grid = {'polynomialfeatures__degree': [1, 2, 3],\n",
    "              'ridge__alpha': [0.001, 0.01, 0.1, 1, 10, 100]}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "GridSearchCV(cv=5,\n",
       "             estimator=Pipeline(steps=[('standardscaler', StandardScaler()),\n",
       "                                       ('polynomialfeatures',\n",
       "                                        PolynomialFeatures()),\n",
       "                                       ('ridge', Ridge())]),\n",
       "             n_jobs=-1,\n",
       "             param_grid={'polynomialfeatures__degree': [1, 2, 3],\n",
       "                         'ridge__alpha': [0.001, 0.01, 0.1, 1, 10, 100]})"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grid = GridSearchCV(pipe, param_grid=param_grid, cv=5, n_jobs=-1)\n",
    "grid.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can visualize the outcome of the cross-validation using a heat map \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PolyCollection at 0x141d9edc0>"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "application/pdf": "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\n",
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "mglearn.tools.heatmap(grid.cv_results_['mean_test_score'].reshape(3, -1),\n",
    "                      xlabel=\"ridge__alpha\", ylabel=\"polynomialfeatures__degree\",\n",
    "                      xticklabels=param_grid['ridge__alpha'],\n",
    "                      yticklabels=param_grid['polynomialfeatures__degree'], vmin=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Looking at the results produced by the cross-validation, we can see that using polynomials of degree two helps, but that degree-three polynomials are much worse than either degree one or two. This is reflected in the best parameters that were found:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best parameters: {'polynomialfeatures__degree': 2, 'ridge__alpha': 10}\n"
     ]
    }
   ],
   "source": [
    "print(\"Best parameters: {}\".format(grid.best_params_))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test-set score: 0.77\n"
     ]
    }
   ],
   "source": [
    "print(\"Test-set score: {:.2f}\".format(grid.score(X_test, y_test)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let’s run a grid search without polynomial features for comparison:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Score without poly features: 0.63\n"
     ]
    }
   ],
   "source": [
    "param_grid = {'ridge__alpha': [0.001, 0.01, 0.1, 1, 10, 100]}\n",
    "pipe = make_pipeline(StandardScaler(), Ridge())\n",
    "grid = GridSearchCV(pipe, param_grid, cv=5)\n",
    "grid.fit(X_train, y_train)\n",
    "print(\"Score without poly features: {:.2f}\".format(grid.score(X_test, y_test)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Grid-Searching Which Model To Use\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- We can search over the actual steps being performed in the pipeline (say whether to use StandardScaler or MinMaxScaler). This leads to an even bigger search space and should be considered carefully <br><br>\n",
    "\n",
    "- However, here is an example comparing a RandomForest Classifier and an SVC on the iris dataset. <br><br>\n",
    "- We know that the SVC might need the data to be scaled, so we also search over whether to use StandardScaler or no preprocessing. <br><br>\n",
    "- For the RandomForestClassifier, we know that no preprocessing is necessary. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- We start by defining the pipeline. Here, we explicitly name the steps. We want two steps, one for the preprocessing and then a classifier. We can instantiate this using SVC and StandardScaler\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "pipe = Pipeline([('preprocessing', StandardScaler()), ('classifier', SVC())])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Now we can define the parameter_grid to search over. We want the classifier to be either RandomForestClassifier or SVC. \n",
    "- Because they have different parameters to tune, and need different preprocessing, we can make use of the list of search grids we discussed in “Search over spaces that are not grids” on page 271. \n",
    "- To assign an estimator to a step, we use the name of the step as the parameter name. When we wanted to skip a step in the pipeline (for example, because we don’t need preprocessing for the RandomForest, we can set that step to None:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.ensemble import RandomForestClassifier\n",
    "\n",
    "param_grid = [\n",
    "    {'classifier': [SVC()], 'preprocessing': [StandardScaler(), None],\n",
    "     'classifier__gamma': [0.001, 0.01, 0.1, 1, 10, 100],\n",
    "     'classifier__C': [0.001, 0.01, 0.1, 1, 10, 100]},\n",
    "    {'classifier': [RandomForestClassifier(n_estimators=100)],\n",
    "     'preprocessing': [None], 'classifier__max_features': [1, 2, 3]}]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can instantiate and run the grid search as usual, here on the cancer dataset:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best params:\n",
      "{'classifier': SVC(C=10, gamma=0.01), 'classifier__C': 10, 'classifier__gamma': 0.01, 'preprocessing': StandardScaler()}\n",
      "\n",
      "Best cross-validation score: 0.99\n",
      "Test-set score: 0.98\n"
     ]
    }
   ],
   "source": [
    "X_train, X_test, y_train, y_test = train_test_split(\n",
    "    cancer.data, cancer.target, random_state=0)\n",
    "\n",
    "grid = GridSearchCV(pipe, param_grid, cv=5)\n",
    "grid.fit(X_train, y_train)\n",
    "\n",
    "print(\"Best params:\\n{}\\n\".format(grid.best_params_))\n",
    "print(\"Best cross-validation score: {:.2f}\".format(grid.best_score_))\n",
    "print(\"Test-set score: {:.2f}\".format(grid.score(X_test, y_test)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> The outcome of the grid search is that SVC with StandardScaler preprocessing, C=10, and gamma=0.01 gave the best result.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Avoiding Redundant Computation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The transformers in the pipeline can be cached using memory argument. Caching the transformers is advantageous when fitting is time consuming."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "pipe = Pipeline([('preprocessing', StandardScaler()), ('classifier', SVC())],\n",
    "                memory=\"cache_folder\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Summary and Outlook"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- we introduced the Pipeline class, a general-purpose tool to chain together multiple processing steps in a machine learning workflow <br><br>\n",
    "\n",
    "- Using pipelines allows us to encapsulate multiple steps into a single Python object that adheres to the familiar scikit-learn interface of fit, predict, and transform. <br><br>\n",
    "\n",
    "- The Pipeline class also allows writing more succinct code, and reduces the likelihood of mistakes that can happen when building processing chains without the pipeline class (like forgetting to apply all transformers on the test set, or not applying them in the right order). <br><br>\n",
    "\n",
    "- Choosing the right combination of feature extraction, preprocessing, and models is somewhat of an art, and often requires some trial and error. However, using pipelines, this “trying out” of many different processing steps is quite simple. <br><br>\n",
    "\n",
    "- You now possess all the required skills and know the necessary mechanisms to apply machine learning in practice. In the next chapter, we will dive in more detail into one particular type of data that is commonly seen in practice, and that requires some special expertise to handle correctly: text data. <br><br>\n"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}