notebooks/model_selection_sklearn.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UWlV6OxwMKhU"
      },
      "source": [
        "# Model Selection\n",
        "\n",
        "The task of producing the most suitable predictive model from a dataset has many nuances. In particular, there are two aspects that need to be defined experimentally before starting to adjust a model:\n",
        "\n",
        "* At first, it may not be clear which learning algorithm is best suited to be used in a given situation.\n",
        "\n",
        "* In addition, each learning algorithm has its own set of *hyperparameters*, which are the parameters of the algorithm itself, to counter the concept of *parameter* of the ML model to be adjusted.\n",
        "\n",
        "Model selection is the process of selecting one of different learning algorithms (e.g., SVM, decision tree learning, logistic regression, etc.) or, once the learning algorithm is selected, choosing between different values ​​of hyperparameters (e.g., in polynomial regression, deciding which polynomial degree to use during training).\n",
        "\n",
        "For a given prediction task, the choice of the most appropriate learning algorithm (and its respective hyperparameter values) is made based on some *estimate* of the generalization error obtained on unused data during training. In other words, different candidate models are evaluated during model selection. The model that has the best predictive performance (according to some pre-established assessment measure) is selected as a result of the model selection process."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_HvrJRmzAqkh"
      },
      "source": [
        "# Two-way holdout method\n",
        "\n",
        "In classification or regression tasks, it is very common to split the available observations (original dataset ) in two datasets:\n",
        "\n",
        "* training dataset: used for training a model M\n",
        "* test dataset: used to estimate the *generalization error* of M\n",
        "\n",
        "This splitting method is commonly named *two-way holdout method*, or simply *holdout method*.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "p_Wx4vawBl9n"
      },
      "source": [
        "In Scikit-Learn, we can apply the holdout method by using the `train_test_split` function. This function receives as input a data matrix $X$ and the corresponding response vector $y$.\n",
        "\n",
        "The following image illustrates the effect of applying the function `train_test_split`. As a result, two data matrices and two response vectors are created.\n",
        "\n",
        "<p align=\"center\">\n",
        "<img src=\"https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1543836883/image_6_cfpjpr.png\">\n",
        "</p>\n",
        "\n",
        "Please notice that, each time `train_test_split` is called, it randomly selects which examples to put in the training and test datasets."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Vvv1GLjaNKI1"
      },
      "source": [
        "## Three-way holdout method\n",
        "\n",
        "The application of the two-way holdout method can lead to a misleading estimate of the generalization error if the test data is also used for model selection.\n",
        "\n",
        "Since the test dataset should ideally be used only to produce an estimate of the generalization error **after** training, it is common (at least for relatively large data sets) to further divide the training set into two subsets. The result of this is the production of three datasets, as described below.\n",
        "\n",
        "* Training set: used to adjust the parameters for several candidate models.\n",
        "\n",
        "* Validation set: used to adjust the hyperparameters of the ML algorithm. The predictive performance on this set is used for model selection. i.e., choose the best candidate model.  \n",
        "\n",
        "* Test set: used once to obtain an estimate of the generalization error for the chosen candidate model.\n",
        "\n",
        "The image below ([source](https://datascience.stackexchange.com/questions/52632/cross-validation-vs-train-validate-test)) summarizes the model selection process for a given learning algorithm using the three data sets described above. Initially, the original data set is divided into two subsets, training and testing. Then, the training set is again divided into two, which generates the training, validation and test sets. After that, for each desired combination of hyperparameter values, a model is adjusted on the training set, and its performance on the validation set is computed. In this way, for each of the $ q $ combinations of hyperparameter values, $ q $ performance estimates are obtained. The predictive model corresponding to the combination of hyperparameter values ​​that produces the best performance estimate is selected. Finally, the generalization error estimate for this selected model is produced using the test set.\n",
        "\n",
        "<p align=\"center\">\n",
        "<img src=\"https://i.stack.imgur.com/osBuF.png\">\n",
        "</p>\n",
        "\n",
        "The procedure illustrated in the figure above can be performed once for each of the different learning algorithms candidates in a supervised learning task."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9Vq5YxWvN5_F"
      },
      "source": [
        "### Split proportions\n",
        "\n",
        "Reserving  a test dataset to compute an estimate of the generalization error has the negative side effect of retaining potentially valuable information that the learning algorithm could benefit from. Therefore, choosing the size of the test set  involves a trade-off: allocating a very large test set can retain a lot of information that could be used to improve model fit during training. On the other hand, the smaller the test set, the more inaccurate the generalization error estimate is.\n",
        "\n",
        "In most practical cases, the most used divisions are 60:40,\n",
        "70:30 or 80:20, depending on the size of the initial data set.\n",
        "\n",
        "However, for large data sets, 90:10 or even 99: 1 may be appropriate, since 10% (or even 1%) of a very large sample can still be statistically significant.\n",
        "\n",
        "A common practice is to re-train the estimator on the entire data set (i.e., rejoining the training and test sets), in order to improve predictive performance of the resulting final model."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "piO8DLsf93Cv"
      },
      "source": [
        "## $k$-fold Cross-validation\n",
        "\n",
        "There are two disadvantages of the holdout method:\n",
        "\n",
        "* the performance estimate can be very sensitive to the way used to subdivide the training set into the training and validation sets: this estimate will vary for different data samples. Repeating the holdout validation on different subsets of the data would provide a better estimate of the algorithm's performance.\n",
        "\n",
        "* a significant part of the data is not used for training the model. For example, if the split ratio is 50%, half of the data set does not contribute to model training! This can cause problems, especially if the initial data set is small.\n",
        "\n",
        "A more robust technique for performing model selection is *k-fold cross-validation*. This technique corresponds to applying the holdout method $k$ times over $k$ different configurations of training and validation subsets.\n",
        "\n",
        "The following figure ([source](https://sebastianraschka.com/faq/docs/evaluate-a-model.html)) illustrates $k$-fold cross validation. This is an iterative technique. In the first iteration, the training set is subdivided into $k$ disjunct sets (in the figure, $k = 10$). Then, $k-1$ of these subsets are used to fit the predictive model. Once the model has been adjusted, its error is estimated in the examples of the subset that was not used during the adjustment, which produces the value $E_1$ in the figure. In the second iteration, another fold is selected to compute the estimate and again a model is adjusted, which allows to compute another estimate of the error, $E_2$. In all, $k$ iterations are performed, which results in $k$ performance estimates. Finally, a more robust (i.e., less biased) estimate of the model error is obtained by computing the average of the previously produced $k$ estimates.\n",
        "\n",
        "<p align=\"center\">\n",
        "<img src=\"https://sebastianraschka.com/images/faq/evaluate-a-model/k-fold.png\">\n",
        "</p>\n",
        "\n",
        "Keep in mind that, as k increases:\n",
        "* Bias in the estimation of the generalization error decreases;\n",
        "Computational cost also increases.\n",
        "* Empirical evidence shows that k=10 is a good value for datasets of moderate size.\n",
        "* For large sized datasets, k can be safely decreased.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Function cross_val_score"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "In the following example, the $k$-fold cross-validation technique is applied, with $k = 2$. The result is two performance estimates, which can be combined (for example, taking the average) to obtain a better measure of the model's generalization performance. This specific form of cross-validation is double cross-validation: we split the original data into two subsets and use each one as a validation set."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 30,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(0.92, 0.96)"
            ]
          },
          "execution_count": 30,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.datasets import load_iris\n",
        "from sklearn.neighbors import KNeighborsClassifier\n",
        "from sklearn.metrics import accuracy_score\n",
        "\n",
        "# Configures k-NN with 1 neighbor\n",
        "\n",
        "iris = load_iris()\n",
        "X = iris.data\n",
        "y = iris.target\n",
        "\n",
        "# divide the original dataset in 2 equal parts\n",
        "X1, X2, y1, y2 = train_test_split(X, y, train_size=0.5)\n",
        "\n",
        "# ajusta e avalia DOIS modelos\n",
        "model = KNeighborsClassifier(n_neighbors=3)\n",
        "model.fit(X1, y1)\n",
        "y1_pred = model.predict(X2)\n",
        "\n",
        "model = KNeighborsClassifier(n_neighbors=3)\n",
        "model.fit(X2, y2)\n",
        "y2_pred = model.predict(X1)\n",
        "\n",
        "accuracy_score(y2, y1_pred), accuracy_score(y1, y2_pred)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Implementing $k$-fold cross validation using the approach illustrated in the previous example can be time consuming for greater values of $k$. Scikit-Learn provides the function [`cross_val_score`](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.cross_val_score.html). This function makes it easier to apply $k$-fold cross validation."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LUXqo-lsHaPo"
      },
      "source": [
        "1. Input Parameters:\n",
        "\n",
        "   - `estimator`: This is the machine learning model to be evaluated (e.g., a Support Vector Machine classifier).\n",
        "   - `X`: This is the data matrix.\n",
        "   - `y`: These are the corresponding target labels for the data matrix.\n",
        "   - `cv` (optional): This defines the number of folds for cross-validation. By default, it's set to 5.\n",
        "   - `scoring` (optional): This specifies the metric used to evaluate the model's performance (e.g., accuracy, precision).\n",
        "\n",
        "2. Splitting the Data:\n",
        "   - `cross_val_score` splits the data (X, y) into the defined number of folds (`cv`).\n",
        "\n",
        "3. Looping Through Folds:\n",
        "   - One fold is used as the testing set (hold-out set).\n",
        "   - The remaining folds are combined to form the training set.\n",
        "   - The model (`estimator`) is trained on the training set.\n",
        "   - The trained model is used to make predictions on the testing set.\n",
        "   - The scoring metric is evaluated based on the predictions and true labels in the testing set.\n",
        "\n",
        "4. Repeating and Averaging:\n",
        "   - This process of training, predicting, and scoring is repeated for all cv folds.\n",
        "   - Finally, `cross_val_score` averages the scores obtained from each fold, providing an overall estimate of the model's performance across the entire dataset.\n",
        "\n",
        "5. Output:\n",
        "   - The function returns a NumPy array containing the scores for each fold of the cross-validation process. This allows you to analyze the variability of the scores across different folds. Notice that, for each fold, the training and tests sets will be different. Therefore, different score values for each fold will be produced. Also notice that we can compute the mean and standard deviation of the resulting scores.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jOlBbOMaGw1h"
      },
      "source": [
        "The following example illustrates the application of the function `cross_val_score` to the case $k = 2$."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tSLzxCB_YERc",
        "outputId": "3cd8638a-4933-4ff5-cd86-401b642731e2"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Scores in each fold: [0.96 0.92]\n",
            "Average score: 0.94\n",
            "Std deviation of scores: 0.019999999999999962\n"
          ]
        }
      ],
      "source": [
        "from sklearn.model_selection import cross_val_score\n",
        "scores = cross_val_score(model, X, y, cv=2, scoring = 'accuracy')\n",
        "print(f'Scores in each fold: {scores}')\n",
        "print(f'Average score: {scores.mean()}')\n",
        "print(f'Std deviation of scores: {scores.std()}')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mUefpkmoY4v2"
      },
      "source": [
        "Scikit-Learn implements several cross-validation schemes that are useful in particular situations; these are implemented through iterators in the cross_validation module. In practice, we have to define the iterator through the `cv` parameter.\n",
        "\n",
        "As an example, we might want to go to the extreme case where the number of subsets is equal to the number of examples contained in the training set. In this case, in each iteration, a model is fitted using all but one example, and accuracy is measured against the only example not used during training. This type of cross-validation is known as **leave-one-out cross-validation**.\n",
        "\n",
        "The example below illustrates the use of this particular case leave-one-out cross-validation. Since there are 150 samples, the leave-one-out cross-validation produces 150 estimates (1.0 indicates a successful forecast, and 0.0 indicates an unsuccessful one)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "paZ5oipGZIoJ",
        "outputId": "a75251c7-2bb0-4743-86d8-8b31ce0ad531"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n",
              "       1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n",
              "       1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n",
              "       1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n",
              "       1., 1., 0., 1., 0., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 0., 1.,\n",
              "       1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n",
              "       1., 1., 1., 1., 0., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n",
              "       0., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 0., 1., 1.,\n",
              "       1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.])"
            ]
          },
          "execution_count": 4,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "from sklearn.model_selection import LeaveOneOut\n",
        "\n",
        "scores = cross_val_score(model, X, y, cv=LeaveOneOut())\n",
        "scores"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "APSamO7pZZ2F"
      },
      "source": [
        "The average of these 150 values ​​corresponds to the estimated error rate of the model produced:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aXh4DFwqZgeG",
        "outputId": "2ae4ae99-0270-42d9-f53d-bcfa08c21461"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Average score:  0.96\n",
            "Std deviation of scores:  0.19595917942265423\n"
          ]
        }
      ],
      "source": [
        "print('Average score: ', scores.mean())\n",
        "print('Std deviation of scores: ', scores.std())"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yHk15WRYiziA"
      },
      "source": [
        "## Stratified k-fold cross-validation\n",
        "\n",
        "In the context of the classification task, an unbalanced dataset presents unequal proportions of examples for each class. See the image below ([source](https://www.researchgate.net/publication/306376881_Survey_of_resampling_techniques_for_improving_classification_performance_in_unbalanced_datasets)) for an example in the binary classification case.\n",
        "\n",
        "<p align=\"center\">\n",
        "<img src=\"https://miro.medium.com/max/698/1*cd6AorHoJYMFyj7IZd2nOg.png\">\n",
        "</p>\n",
        "\n",
        "For unbalanced datasets, if the vanilla version of $k$-fold cross-validation is used, it can be the case that one or more produced folds end up with zero examples of a particular class. In such situations, it is better to use *stratified $k$-fold cross-validation*. In stratified $k$ cross-validation, class proportions are preserved in each of the $k$ subsets, so that each one is representative of the class proportions in the training data set. The image below (source) illustrates how stratified $k$-fold crors-validation works.\n",
        "\n",
        "<p align=\"center\">\n",
        "<img src=\"https://miro.medium.com/max/562/0*QKJTHrcriSx2ZNYr.png\">\n",
        "</p>\n",
        "\n",
        "In Scikit-Learn, the `StratifiedKFold` class implements the stratified cross-validation method. See the following example, that applies stratified cross-validation to a toy dataset with two classes. Notice that the proportions os classes in each fold is approximately the same as the original dataset."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bB_y_3iml9Gs",
        "outputId": "fbc01526-af8e-451f-89c4-8648698c0894"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "StratifiedKFold(n_splits=2, random_state=None, shuffle=False)\n",
            "TRAIN: [ 3  4  5 12 13 14 15 16 17] TEST: [ 0  1  2  6  7  8  9 10 11]\n",
            "TRAIN: [ 0  1  2  6  7  8  9 10 11] TEST: [ 3  4  5 12 13 14 15 16 17]\n"
          ]
        }
      ],
      "source": [
        "import numpy as np\n",
        "from sklearn.model_selection import StratifiedKFold\n",
        "\n",
        "# data matrix\n",
        "X = np.array([[1, 2], [3, 4], [1, 2], [3, 4], [5, 6], [7, 8],\n",
        "              [9, 10], [9, 10], [11, 12], [11, 12],\n",
        "              [1, 2], [3, 4], [5, 6], [7, 8], [4, 5], [5, 6], [7, 8], [4, 5]])\n",
        "\n",
        "# response vector\n",
        "y = np.array([0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1])\n",
        "\n",
        "skf = StratifiedKFold(n_splits=2)\n",
        "skf.get_n_splits(X, y)\n",
        "\n",
        "print(skf)\n",
        "\n",
        "# print the indices of examples in each fold\n",
        "for train_index, test_index in skf.split(X, y):\n",
        "   print(\"TRAIN:\", train_index, \"TEST:\", test_index)\n",
        "   X_train, X_test = X[train_index], X[test_index]\n",
        "   y_train, y_test = y[train_index], y[test_index]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UJw6vFxDix6O"
      },
      "source": [
        "# Hyperparameter optimization\n",
        "\n",
        "In machine learning, a **hyperparameter** is a setting that controls the learning process of a model, but it's not directly learned from the data itself. Hyperparameters are essentially dials or knobs that must be adjusted before running the learning algorithm. They define the learning algorithm's overall behavior and influence the model's complexity and capacity. In contrast to the model **parameters** that are learned during training, the values ​​of the hyperparameters are set before the training of a model begins. \n",
        "\n",
        "Some examples of hyperparameters are given below.\n",
        "\n",
        "* the learning rate in logistic regression and in linear regression,\n",
        "* the height of trees in decision tree learning,\n",
        "* the value of $k$ in $k$-NN,\n",
        "* the value of $k$ in $k$-means,\n",
        "* the values of $\\epsilon$ and $\\operatorname{minPoints}$ in DBSCAN,\n",
        "* the regularization term in linear regression,\n",
        "* the polynomial degree in polynomial regression.\n",
        "\n",
        "\n",
        "Hyperparameters can be considered as configurations of a learning algorithm. In general, the ideal settings for the algorithm to generate a suitable model for one dataset may not be the same for another dataset.\n",
        "\n",
        "*Hyperparameter optimization* (aka *hyperparameter tuning*) is the procedure of defining appropriate values for the hyperparameters of a given learning algorithm. The general approach is to generate several combinations of hyperparameter values. Then, a model is trained for each combinatation. Finally, the best combination (according to some evaluation measure applied on the candidate models) is chosen.\n",
        "\n",
        "When the learning algorithm generates an estimator (either a classifier or a regressor), there are two main strategies to *automatically* tune its hyperparameters: *Grid Search* and *Random Search*. Both strategies generate several hyperparameter combinations. Then, for each combination, an estimator is trained a model (on the training set) and evaluateed (on the validation set). The difference between these two strategies is in the way the several combinations are generated, as described below."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iB4Yw9xzVy4j"
      },
      "source": [
        "**Grid search** first defines a grid of hyperparameter combinations. The amount of hyperparameters defines the number of dimensions in the grid. Then, each combination (a point in the grid) ​​is used to produce a model.\n",
        "\n",
        "The image below ([source](https://www.researchgate.net/publication/271771573_TuPAQ_An_Efficient_Planner_for_Large-scale_Predictive_Analytic_Queries/figures?lo=1)) illustrates the GS procedure for a learning algorithm with two hyperparameters. The star represents the combination of hyperparameters that gives the best model. as measured in the validation set. The red dot in picture on the left represents the first combination test by GS. The picture on the center represents the second combination. The picture on the right illustrates all the tested combinations in the 2-dimensional grid.\n",
        "\n",
        "<p align=\"center\">\n",
        "<img src=\"https://www.researchgate.net/profile/Michael_Jordan13/publication/271771573/figure/fig4/AS:668513593217027@1536397469229/Illustration-of-naive-grid-search-for-a-single-model-family-with-two-hyperparameters_W640.jpg\">\n",
        "</p>\n",
        "\n",
        "**Random search** selects random combinations of hyperparameter values ​​(within preconfigured ranges of values for each hyperparameter) to train and evaluate the candidate models. Instead of trying all possible combinations of values, RS performs a pre-defined number of iterations, testing a random combination of hyperparameters ​​in each iteration.\n",
        "\n",
        "Both GS and RS can be very computationally expensive. For example, searching for 20 different values ​​for each of 4 hyperparameters would require 160,000 k-fold cross-validation runs. If $k = 10$ then 1,600,000 model adjustments and 1,600,000 evaluations should be performed\n",
        "\n",
        "The image below ([source](https://community.alteryx.com/t5/Data-Science/Hyperparameter-Tuning-Black-Magic/ba-p/449289)) illustrates the difference between GS and RS. Think of a learning algorithm with just two hyperparameters. This way, each combination of its hyperparameters is a pair of numbers. Suppose one of these hyperparameters (x-axis) has more influence than the other (y-axis) on the predictive performance of the generated models. The plot on the left shows several of these pairs organized in a grid. In total, there are thirty combination in this grid. The picture on the right shows other combinations of pairs; this times these combinations where randomly selected. Notice that RS has the potential to explore more promising combinations than GS.\n",
        "\n",
        "<p align=\"center\">\n",
        "<img src=\"https://pvsmt99345.i.lithium.com/t5/image/serverpage/image-id/74545i97245FDAA10376E9/image-size/large?v=1.0&px=999\">\n",
        "</p>\n",
        "\n",
        "In Scikit-Learn, the classes [GridSearchCV](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.GridSearchCV.html) and [RandomizedSearchCV](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.RandomizedSearchCV.html) implement GS and RS, respectively."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hQg_3AcwaZjQ"
      },
      "source": [
        "### Class GridSearchCV"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "n59pZ0EI4I_d"
      },
      "source": [
        "Scikit-Learn provides the class `GridSearchCV` to perform grid search.\n",
        "\n",
        "The following code block presents an example of using the `GridSearchCV` class to find the ideal polynomial model for a data set. In this example, a three-dimensional grid of hyperparameters is explored:\n",
        "\n",
        "* the polynomial degree,\n",
        "* a boolean indicator that indicates whether the linear coefficient should be adjusted,\n",
        "* an indicator (boolean) indicating whether the data should be normalized."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 36,
      "metadata": {
        "id": "SAW_e44vz86E"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Best configuration of hyperparameters found: {'linearregression__fit_intercept': False, 'polynomialfeatures__degree': 4}\n"
          ]
        }
      ],
      "source": [
        "from sklearn.model_selection import GridSearchCV\n",
        "import numpy as np\n",
        "from sklearn.preprocessing import PolynomialFeatures\n",
        "from sklearn.linear_model import LinearRegression\n",
        "from sklearn.pipeline import make_pipeline\n",
        "\n",
        "def PolynomialRegression(degree=2, **kwargs):\n",
        "    return make_pipeline(PolynomialFeatures(degree),\n",
        "                         LinearRegression(**kwargs))\n",
        "\n",
        "param_grid = {'polynomialfeatures__degree': np.arange(21),\n",
        "              'linearregression__fit_intercept': [True, False]}\n",
        "\n",
        "def make_data(N, err=1.0, rseed=1):\n",
        "    # randomly sample the data\n",
        "    rng = np.random.RandomState(rseed)\n",
        "    X = rng.rand(N, 1) ** 2\n",
        "    y = 10 - 1. / (X.ravel() + 0.1)\n",
        "    if err > 0:\n",
        "        y += err * rng.randn(N)\n",
        "    return X, y\n",
        "\n",
        "X_train, y_train = make_data(40)\n",
        "grid = GridSearchCV(PolynomialRegression(), param_grid, cv=7)\n",
        "grid.fit(X_train, y_train)\n",
        "print(f'Best configuration of hyperparameters found: {grid.best_params_}')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 37,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 457
        },
        "id": "Uw8ZQ4025wje",
        "outputId": "19aeee88-7272-49b0-fb0a-6b0ba61deada"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "%matplotlib inline\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "X_test = np.linspace(-0.1, 1.1, 500)[:, None]\n",
        "\n",
        "plt.scatter(X.ravel(), y, color='black')\n",
        "axis = plt.axis()\n",
        "for degree in [1, 3, 4, 5]:\n",
        "    y_test = PolynomialRegression(degree).fit(X, y).predict(X_test)\n",
        "    plt.plot(X_test.ravel(), y_test, label='degree={0}'.format(degree))\n",
        "plt.xlim(-0.1, 1.0)\n",
        "plt.ylim(-2, 12)\n",
        "plt.legend()  # This will automatically use the labels you provided in the plot calls\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 434
        },
        "id": "7FXeoFiP5RTB",
        "outputId": "f03ad85f-868e-43e1-f143-41bb67b1b9a5"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "model = grid.best_estimator_\n",
        "\n",
        "plt.scatter(X.ravel(), y)\n",
        "lim = plt.axis()\n",
        "y_test = model.fit(X, y).predict(X_test)\n",
        "plt.plot(X_test.ravel(), y_test)\n",
        "plt.axis(lim)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jTlVoHTlY7EQ"
      },
      "source": [
        "### Class RandomizedSearchCV\n",
        "\n",
        "This allows you to explicitly control the number of parameter combinations that are attempted. The number of search iterations is defined based on time or resources. Scikit Learn offers the RandomizedSearchCV function for this process.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sNmXxgGsPhkZ",
        "outputId": "afbcf65a-6a42-4027-d181-b79d9f9756d8"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Fitting 3 folds for each of 100 candidates, totalling 300 fits\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "LinearSVC:\n",
            "Best cv accuracy: 0.975\n",
            "Test set score:   1.0\n",
            "Best parameters:  {'C': 54}\n",
            "\n",
            "time to run RandomizedSearchCV: 6.034947991982335\n",
            "########\n",
            "Fitting 3 folds for each of 1099 candidates, totalling 3297 fits\n",
            "LinearSVC:\n",
            "Best cv accuracy: 0.975\n",
            "Test set score:   1.0\n",
            "Best parameters:  {'C': 8}\n",
            "\n",
            "time to run GridSearchCV: 4.930534393992275\n"
          ]
        }
      ],
      "source": [
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.model_selection import StratifiedKFold\n",
        "from sklearn.model_selection import RandomizedSearchCV\n",
        "from sklearn.model_selection import GridSearchCV\n",
        "from timeit import default_timer as timer\n",
        "from sklearn.svm import LinearSVC\n",
        "\n",
        "def linear_SVC(x, y, param, kfold):\n",
        "    param_grid = {'C':param}\n",
        "    k = StratifiedKFold(n_splits=kfold)\n",
        "    grid = GridSearchCV(LinearSVC(dual=False), param_grid=param_grid, cv=k, n_jobs=4, verbose=1)\n",
        "\n",
        "    return grid.fit(x, y)\n",
        "\n",
        "def Linear_SVC_Rand(x, y, param, kfold, n):\n",
        "    param_grid = {'C':param}\n",
        "    k = StratifiedKFold(n_splits=kfold)\n",
        "    randsearch = RandomizedSearchCV(LinearSVC(dual=False), param_distributions=param_grid, cv=k, n_jobs=4,\n",
        "                                    verbose=1, n_iter=n)\n",
        "\n",
        "    return randsearch.fit(x, y)\n",
        "\n",
        "from sklearn.datasets import load_iris\n",
        "iris = load_iris()\n",
        "X = iris.data\n",
        "y = iris.target\n",
        "\n",
        "x_train, x_test, y_train, y_test = train_test_split(X, y, test_size=0.2)\n",
        "\n",
        "\n",
        "start = timer()\n",
        "param = [i/1000 for i in range(1,1000)]\n",
        "param1 = [i for i in range(1,101)]\n",
        "param.extend(param1)\n",
        "\n",
        "#progress = progressbar.bar.ProgressBar()\n",
        "clf = Linear_SVC_Rand(x=x_train, y=y_train, param=param, kfold=3, n=100)\n",
        "\n",
        "print('LinearSVC:')\n",
        "print('Best cv accuracy: {}' .format(clf.best_score_))\n",
        "print('Test set score:   {}' .format(clf.score(x_test, y_test)))\n",
        "print('Best parameters:  {}' .format(clf.best_params_))\n",
        "print()\n",
        "\n",
        "duration = timer() - start\n",
        "print('time to run RandomizedSearchCV: {}' .format(duration))\n",
        "\n",
        "\n",
        "print('########')\n",
        "\n",
        "#high C means more chance of overfitting\n",
        "\n",
        "start = timer()\n",
        "param = [i/1000 for i in range(1,1000)]\n",
        "param1 = [i for i in range(1,101)]\n",
        "param.extend(param1)\n",
        "\n",
        "clf = linear_SVC(x=x_train, y=y_train, param=param, kfold=3)\n",
        "\n",
        "print('LinearSVC:')\n",
        "print('Best cv accuracy: {}' .format(clf.best_score_))\n",
        "print('Test set score:   {}' .format(clf.score(x_test, y_test)))\n",
        "print('Best parameters:  {}' .format(clf.best_params_))\n",
        "print()\n",
        "\n",
        "duration = timer() - start\n",
        "print('time to run GridSearchCV: {}' .format(duration))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bPaJ9EBODzzR",
        "outputId": "94fc2a29-e772-4e25-b1a7-df883b573ba4"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "RandomizedSearchCV took 7.79 seconds for 20 candidates parameter settings.\n",
            "Model with rank: 1\n",
            "Mean validation score: 0.930 (std: 0.032)\n",
            "Parameters: {'bootstrap': False, 'criterion': 'gini', 'max_depth': None, 'max_features': 9, 'min_samples_split': 9}\n",
            "\n",
            "Model with rank: 2\n",
            "Mean validation score: 0.925 (std: 0.027)\n",
            "Parameters: {'bootstrap': True, 'criterion': 'gini', 'max_depth': None, 'max_features': 3, 'min_samples_split': 3}\n",
            "\n",
            "Model with rank: 3\n",
            "Mean validation score: 0.923 (std: 0.031)\n",
            "Parameters: {'bootstrap': True, 'criterion': 'gini', 'max_depth': None, 'max_features': 10, 'min_samples_split': 6}\n",
            "\n",
            "GridSearchCV took 31.68 seconds for 72 candidate parameter settings.\n",
            "Model with rank: 1\n",
            "Mean validation score: 0.934 (std: 0.020)\n",
            "Parameters: {'bootstrap': False, 'criterion': 'entropy', 'max_depth': None, 'max_features': 10, 'min_samples_split': 2}\n",
            "\n",
            "Model with rank: 2\n",
            "Mean validation score: 0.932 (std: 0.022)\n",
            "Parameters: {'bootstrap': False, 'criterion': 'gini', 'max_depth': None, 'max_features': 3, 'min_samples_split': 3}\n",
            "\n",
            "Model with rank: 3\n",
            "Mean validation score: 0.928 (std: 0.024)\n",
            "Parameters: {'bootstrap': True, 'criterion': 'entropy', 'max_depth': None, 'max_features': 10, 'min_samples_split': 2}\n",
            "\n"
          ]
        }
      ],
      "source": [
        "import numpy as np\n",
        "\n",
        "from time import time\n",
        "from scipy.stats import randint as sp_randint\n",
        "\n",
        "from sklearn.model_selection import GridSearchCV\n",
        "from sklearn.model_selection import RandomizedSearchCV\n",
        "from sklearn.datasets import load_digits\n",
        "from sklearn.ensemble import RandomForestClassifier\n",
        "\n",
        "# get some data\n",
        "digits = load_digits()\n",
        "X, y = digits.data, digits.target\n",
        "\n",
        "# build a classifier\n",
        "clf = RandomForestClassifier(n_estimators=20)\n",
        "\n",
        "# Utility function to report best scores\n",
        "def report(results, n_top=3):\n",
        "    for i in range(1, n_top + 1):\n",
        "        candidates = np.flatnonzero(results['rank_test_score'] == i)\n",
        "        for candidate in candidates:\n",
        "            print(\"Model with rank: {0}\".format(i))\n",
        "            print(\"Mean validation score: {0:.3f} (std: {1:.3f})\".format(\n",
        "                  results['mean_test_score'][candidate],\n",
        "                  results['std_test_score'][candidate]))\n",
        "            print(\"Parameters: {0}\".format(results['params'][candidate]))\n",
        "            print(\"\")\n",
        "\n",
        "\n",
        "# specify parameters and distributions to sample from\n",
        "param_dist = {\"max_depth\": [3, None],\n",
        "              \"max_features\": sp_randint(1, 11),\n",
        "              \"min_samples_split\": sp_randint(2, 11),\n",
        "              \"bootstrap\": [True, False],\n",
        "              \"criterion\": [\"gini\", \"entropy\"]}\n",
        "\n",
        "# run randomized search\n",
        "n_iter_search = 20\n",
        "random_search = RandomizedSearchCV(clf, param_distributions=param_dist,\n",
        "                                   n_iter=n_iter_search, cv=5)\n",
        "\n",
        "start = time()\n",
        "random_search.fit(X, y)\n",
        "print(\"RandomizedSearchCV took %.2f seconds for %d candidates\"\n",
        "      \" parameter settings.\" % ((time() - start), n_iter_search))\n",
        "report(random_search.cv_results_)\n",
        "\n",
        "# use a full grid over all parameters\n",
        "param_grid = {\"max_depth\": [3, None],\n",
        "              \"max_features\": [1, 3, 10],\n",
        "              \"min_samples_split\": [2, 3, 10],\n",
        "              \"bootstrap\": [True, False],\n",
        "              \"criterion\": [\"gini\", \"entropy\"]}\n",
        "\n",
        "# run grid search\n",
        "grid_search = GridSearchCV(clf, param_grid=param_grid, cv=5)\n",
        "start = time()\n",
        "grid_search.fit(X, y)\n",
        "\n",
        "print(\"GridSearchCV took %.2f seconds for %d candidate parameter settings.\"\n",
        "      % (time() - start, len(grid_search.cv_results_['params'])))\n",
        "report(grid_search.cv_results_)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EkB2DK0laaGr"
      },
      "source": [
        "# Model selection: practical tips\n",
        "\n",
        "* It is appropriate to start with a simple algorithm that can be used quickly.\n",
        "\n",
        "* Use learning curves to decide for more (or less) data, more (or less) attributes, etc.\n",
        "\n",
        "* Another technique used in model selection is *error analysis*, which corresponds to manually checking the examples (in the validation set) that the algorithm has erred. It is sometimes possible to detect a pattern of systematic error in these examples.\n",
        "\n",
        "* The motivation for using k-fold cross-validation is to be able to use a good amount of test or validation data, without significantly reducing the training data set. In situations where there is enough data to have a good-sized training data set, in addition to reasonable amounts of test and validation data, holdout cross validation can be used."
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "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.12.0"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}