jupyter-book/tuning/tuning_questions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "c3fde4b0",
   "metadata": {},
   "source": [
    "# 🏁 Wrap-up quiz\n",
    "\n",
    "**This quiz requires some programming to be answered.**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3278ab91",
   "metadata": {},
   "source": [
    "Load the dataset file named `penguins.csv` with the following command:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "60e5ebd6",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-01T07:13:48.272690Z",
     "start_time": "2021-06-01T07:13:48.075789Z"
    }
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "\n",
    "\n",
    "penguins = pd.read_csv(\"../datasets/penguins.csv\")\n",
    "\n",
    "columns = [\"Body Mass (g)\", \"Flipper Length (mm)\", \"Culmen Length (mm)\"]\n",
    "target_name = \"Species\"\n",
    "\n",
    "# Remove lines with missing values for the columns of interestes\n",
    "penguins_non_missing = penguins[columns + [target_name]].dropna()\n",
    "\n",
    "data = penguins_non_missing[columns]\n",
    "target = penguins_non_missing[target_name]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "93256e37",
   "metadata": {},
   "source": [
    "`penguins` is a pandas dataframe. The column \"Species\" contains the target\n",
    "variable. We extract through numerical columns that quantify various attributes\n",
    "of animals and our goal is try to predict the species of the animal based on\n",
    "those attributes stored in the dataframe named `data`.\n",
    "\n",
    "Inspect the loaded data to select the correct assertions:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "70bb6818",
   "metadata": {},
   "source": [
    "# Question 1\n",
    "Select the correct assertions from the following proposals.\n",
    "\n",
    "- a) The problem to be solved is a regression problem\n",
    "- b) The problem to be solved is a binary classification problem\n",
    "  (exactly 2 possible classes)\n",
    "- c) The problem to be solved is a multiclass classification problem\n",
    "  (more than 2 possible classes)\n",
    "- d) The proportions of the class counts are balanced: there are approximately\n",
    "  the same number of rows for each class\n",
    "- e) The proportions of the class counts are imbalanced: some classes have more\n",
    "  than twice as many rows than others)\n",
    "- f) The input features have similar dynamic ranges (or scales)\n",
    "\n",
    "_Select several answers_\n",
    "\n",
    "Hint: `data.describe()`, and `target.value_counts()` are methods\n",
    "that are helpful to answer to this question."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "8d2adc64",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-01T07:15:17.723547Z",
     "start_time": "2021-06-01T07:15:17.701137Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Body Mass (g)</th>\n",
       "      <th>Flipper Length (mm)</th>\n",
       "      <th>Culmen Length (mm)</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>count</th>\n",
       "      <td>342.000000</td>\n",
       "      <td>342.000000</td>\n",
       "      <td>342.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>mean</th>\n",
       "      <td>4201.754386</td>\n",
       "      <td>200.915205</td>\n",
       "      <td>43.921930</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>std</th>\n",
       "      <td>801.954536</td>\n",
       "      <td>14.061714</td>\n",
       "      <td>5.459584</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>min</th>\n",
       "      <td>2700.000000</td>\n",
       "      <td>172.000000</td>\n",
       "      <td>32.100000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25%</th>\n",
       "      <td>3550.000000</td>\n",
       "      <td>190.000000</td>\n",
       "      <td>39.225000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50%</th>\n",
       "      <td>4050.000000</td>\n",
       "      <td>197.000000</td>\n",
       "      <td>44.450000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>75%</th>\n",
       "      <td>4750.000000</td>\n",
       "      <td>213.000000</td>\n",
       "      <td>48.500000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>max</th>\n",
       "      <td>6300.000000</td>\n",
       "      <td>231.000000</td>\n",
       "      <td>59.600000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       Body Mass (g)  Flipper Length (mm)  Culmen Length (mm)\n",
       "count     342.000000           342.000000          342.000000\n",
       "mean     4201.754386           200.915205           43.921930\n",
       "std       801.954536            14.061714            5.459584\n",
       "min      2700.000000           172.000000           32.100000\n",
       "25%      3550.000000           190.000000           39.225000\n",
       "50%      4050.000000           197.000000           44.450000\n",
       "75%      4750.000000           213.000000           48.500000\n",
       "max      6300.000000           231.000000           59.600000"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "09e82539",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-01T07:15:33.498279Z",
     "start_time": "2021-06-01T07:15:33.491298Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Adelie Penguin (Pygoscelis adeliae)          151\n",
       "Gentoo penguin (Pygoscelis papua)            123\n",
       "Chinstrap penguin (Pygoscelis antarctica)     68\n",
       "Name: Species, dtype: int64"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "target.value_counts()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7e8144e5",
   "metadata": {},
   "source": [
    "\n",
    "+++\n",
    "\n",
    "Let's now consider the following pipeline:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "0f81170e",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-01T07:34:55.419642Z",
     "start_time": "2021-06-01T07:34:55.417149Z"
    }
   },
   "outputs": [],
   "source": [
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.pipeline import Pipeline\n",
    "\n",
    "\n",
    "model = Pipeline(steps=[\n",
    "    (\"preprocessor\", StandardScaler()),\n",
    "    (\"classifier\", KNeighborsClassifier(n_neighbors=5)),\n",
    "])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a36f0c50",
   "metadata": {},
   "source": [
    "# Question 2\n",
    "\n",
    "Evaluate the pipeline using 10-fold cross-validation using the\n",
    "`balanced-accuracy` scoring metric to choose the correct statements.\n",
    "Use `sklearn.model_selection.cross_validate` with\n",
    "`scoring=\"balanced_accuracy\"`.\n",
    "Use `model.get_params()` to list the parameters of the pipeline and use\n",
    "`model.set_params(param_name=param_value)` to update them.\n",
    "\n",
    "- a) The average cross-validated test `balanced_accuracy` of the above pipeline is between 0.9 and 1.0\n",
    "- b) The average cross-validated test `balanced_accuracy` of the above pipeline is between 0.8 and 0.9\n",
    "- c) The average cross-validated test `balanced_accuracy` of the above pipeline is between 0.5 and 0.8\n",
    "- d) Using `n_neighbors=5` is much better than `n_neighbors=51`\n",
    "- e) Preprocessing with `StandardScaler` is much better than using the\n",
    "     raw features (with `n_neighbors=5`)\n",
    "\n",
    "_Select several answers_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "7cee53e6",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-01T07:34:37.996269Z",
     "start_time": "2021-06-01T07:34:37.595124Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "model {'memory': None, 'steps': [('preprocessor', StandardScaler()), ('classifier', KNeighborsClassifier())], 'verbose': False, 'preprocessor': StandardScaler(), 'classifier': KNeighborsClassifier(), 'preprocessor__copy': True, 'preprocessor__with_mean': True, 'preprocessor__with_std': True, 'classifier__algorithm': 'auto', 'classifier__leaf_size': 30, 'classifier__metric': 'minkowski', 'classifier__metric_params': None, 'classifier__n_jobs': None, 'classifier__n_neighbors': 5, 'classifier__p': 2, 'classifier__weights': 'uniform'}\n",
      "fit_time       0.002935\n",
      "score_time     0.002327\n",
      "test_score     0.954629\n",
      "train_score    0.972513\n",
      "dtype: float64\n",
      "\n",
      "model {'memory': None, 'steps': [('preprocessor', StandardScaler()), ('classifier', KNeighborsClassifier(n_neighbors=51))], 'verbose': False, 'preprocessor': StandardScaler(), 'classifier': KNeighborsClassifier(n_neighbors=51), 'preprocessor__copy': True, 'preprocessor__with_mean': True, 'preprocessor__with_std': True, 'classifier__algorithm': 'auto', 'classifier__leaf_size': 30, 'classifier__metric': 'minkowski', 'classifier__metric_params': None, 'classifier__n_jobs': None, 'classifier__n_neighbors': 51, 'classifier__p': 2, 'classifier__weights': 'uniform'}\n",
      "fit_time       0.002560\n",
      "score_time     0.002285\n",
      "test_score     0.947831\n",
      "train_score    0.942975\n",
      "dtype: float64\n",
      "\n",
      "model {'memory': None, 'steps': [('preprocessor', StandardScaler(with_mean=False, with_std=False)), ('classifier', KNeighborsClassifier())], 'verbose': False, 'preprocessor': StandardScaler(with_mean=False, with_std=False), 'classifier': KNeighborsClassifier(), 'preprocessor__copy': True, 'preprocessor__with_mean': False, 'preprocessor__with_std': False, 'classifier__algorithm': 'auto', 'classifier__leaf_size': 30, 'classifier__metric': 'minkowski', 'classifier__metric_params': None, 'classifier__n_jobs': None, 'classifier__n_neighbors': 5, 'classifier__p': 2, 'classifier__weights': 'uniform'}\n",
      "fit_time       0.002451\n",
      "score_time     0.002265\n",
      "test_score     0.725164\n",
      "train_score    0.792004\n",
      "dtype: float64\n",
      "\n",
      "model {'memory': None, 'steps': [('preprocessor', True), ('classifier', KNeighborsClassifier())], 'verbose': False, 'preprocessor': True, 'classifier': KNeighborsClassifier(), 'classifier__algorithm': 'auto', 'classifier__leaf_size': 30, 'classifier__metric': 'minkowski', 'classifier__metric_params': None, 'classifier__n_jobs': None, 'classifier__n_neighbors': 5, 'classifier__p': 2, 'classifier__weights': 'uniform'}\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import cross_validate, ShuffleSplit\n",
    "\n",
    "model.set_params(classifier__n_neighbors=5)\n",
    "cv = ShuffleSplit(random_state=0)\n",
    "cv_results = cross_validate(model, data, target, return_train_score=True,\n",
    "                            cv=cv, scoring='balanced_accuracy')\n",
    "cv_results = pd.DataFrame(cv_results)\n",
    "print(f'model {model.get_params()}')\n",
    "print(f\"{cv_results.mean()}\\n\")\n",
    "\n",
    "model.set_params(classifier__n_neighbors=51)\n",
    "cv_results = cross_validate(model, data, target, return_train_score=True,\n",
    "                            cv=cv, scoring='balanced_accuracy')\n",
    "cv_results = pd.DataFrame(cv_results)\n",
    "print(f'model {model.get_params()}')\n",
    "print(f\"{cv_results.mean()}\\n\")\n",
    "\n",
    "model.set_params(classifier__n_neighbors=5)\n",
    "model.set_params(preprocessor__with_mean=False, preprocessor__with_std=False)\n",
    "cv_results = cross_validate(model, data, target, return_train_score=True,\n",
    "                            cv=cv, scoring='balanced_accuracy')\n",
    "cv_results = pd.DataFrame(cv_results)\n",
    "print(f'model {model.get_params()}')\n",
    "print(f\"{cv_results.mean()}\\n\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c4cd2bf",
   "metadata": {},
   "source": [
    "+++\n",
    "\n",
    "We will now study the impact of different preprocessors defined in the list below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "ee858c5b",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-01T07:35:05.309343Z",
     "start_time": "2021-06-01T07:35:05.303879Z"
    }
   },
   "outputs": [],
   "source": [
    "from sklearn.preprocessing import MinMaxScaler\n",
    "from sklearn.preprocessing import QuantileTransformer\n",
    "from sklearn.preprocessing import PowerTransformer\n",
    "\n",
    "\n",
    "all_preprocessors = [\n",
    "    None,\n",
    "    StandardScaler(),\n",
    "    MinMaxScaler(),\n",
    "    QuantileTransformer(n_quantiles=100),\n",
    "    PowerTransformer(method=\"box-cox\"),\n",
    "]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f46de7b7",
   "metadata": {},
   "source": [
    "The [Box-Cox\n",
    "method](https://en.wikipedia.org/wiki/Power_transform#Box%E2%80%93Cox_transformation)\n",
    "is common preprocessing strategy for positive values. The other preprocessors\n",
    "work both for any kind of numerical features. If you are curious to read the\n",
    "details about those method, please feel free to read them up in the\n",
    "[preprocessing\n",
    "chapter](https://scikit-learn.org/stable/modules/preprocessing.html) of the\n",
    "scikit-learn user guide but this is not required to answer the quiz questions."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d6ca7ce2",
   "metadata": {},
   "source": [
    "# Question 3\n",
    "\n",
    "Use `sklearn.model_selection.GridSearchCV` to study the impact of the choice of\n",
    "the preprocessor and the number of neighbors on the 10-fold cross-validated\n",
    "`balanced_accuracy` metric. We want to study the `n_neighbors` in the range\n",
    "`[5, 51, 101]` and `preprocessor` in the range `all_preprocessors`.\n",
    "\n",
    "Let us consider that a model is significantly better than another if the its\n",
    "mean test score is better than the mean test score of the alternative by more\n",
    "than the standard deviation of its test score.\n",
    "\n",
    "Which of the following statements hold:\n",
    "\n",
    "- a) The best model with `StandardScaler` is significantly better than using any other processor\n",
    "- b) Using any of the preprocessors is always better than using no processor, irrespective of the value `of n_neighbors`\n",
    "- c) The model with `n_neighbors=5` and `StandardScaler` is significantly better than the model with `n_neighbors=51` and `StandardScaler`.\n",
    "- d) The model with `n_neighbors=51` and `StandardScaler` is significantly better than the model with `n_neighbors=101` and `StandardScaler`.\n",
    "\n",
    "Hint: pass `{\"preprocessor\": all_preprocessors, \"classifier__n_neighbors\": [5, 51, 101]}` for the `param_grid` argument to the `GridSearchCV` class.\n",
    "\n",
    "_Select several answers_\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "0b11c5f1",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-01T07:48:34.441638Z",
     "start_time": "2021-06-01T07:48:33.612743Z"
    }
   },
   "outputs": [],
   "source": [
    "from sklearn.model_selection import cross_validate\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "\n",
    "param_grid = {\"preprocessor\": all_preprocessors, \"classifier__n_neighbors\": [5, 51, 101]}\n",
    "model_grid_search = GridSearchCV(model, param_grid=param_grid,\n",
    "                                 n_jobs=-1, cv=10, scoring='balanced_accuracy')\n",
    "\n",
    "model_grid_search.fit(data, target)\n",
    "cv_results = pd.DataFrame(model_grid_search.cv_results_).sort_values(\n",
    "    \"mean_test_score\", ascending=False)\n",
    "cv_results.head()\n",
    "column_results = [f\"param_{name}\" for name in param_grid.keys()]\n",
    "column_results += [\n",
    "    \"mean_test_score\", \"std_test_score\", \"rank_test_score\"]\n",
    "cv_results = cv_results[column_results]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "4a14e295",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-01T07:48:36.243931Z",
     "start_time": "2021-06-01T07:48:36.235219Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>param_preprocessor</th>\n",
       "      <th>param_classifier__n_neighbors</th>\n",
       "      <th>mean_test_score</th>\n",
       "      <th>std_test_score</th>\n",
       "      <th>rank_test_score</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>StandardScaler()</td>\n",
       "      <td>5</td>\n",
       "      <td>0.952198</td>\n",
       "      <td>0.039902</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>MinMaxScaler()</td>\n",
       "      <td>5</td>\n",
       "      <td>0.947778</td>\n",
       "      <td>0.034268</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>QuantileTransformer(n_quantiles=100)</td>\n",
       "      <td>5</td>\n",
       "      <td>0.947094</td>\n",
       "      <td>0.033797</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>PowerTransformer(method='box-cox')</td>\n",
       "      <td>5</td>\n",
       "      <td>0.946960</td>\n",
       "      <td>0.047387</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>StandardScaler()</td>\n",
       "      <td>51</td>\n",
       "      <td>0.941880</td>\n",
       "      <td>0.038905</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>QuantileTransformer(n_quantiles=100)</td>\n",
       "      <td>51</td>\n",
       "      <td>0.927277</td>\n",
       "      <td>0.043759</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>PowerTransformer(method='box-cox')</td>\n",
       "      <td>51</td>\n",
       "      <td>0.922833</td>\n",
       "      <td>0.047883</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>MinMaxScaler()</td>\n",
       "      <td>51</td>\n",
       "      <td>0.920293</td>\n",
       "      <td>0.045516</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>StandardScaler()</td>\n",
       "      <td>101</td>\n",
       "      <td>0.876642</td>\n",
       "      <td>0.041618</td>\n",
       "      <td>9</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>MinMaxScaler()</td>\n",
       "      <td>101</td>\n",
       "      <td>0.862357</td>\n",
       "      <td>0.046244</td>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>PowerTransformer(method='box-cox')</td>\n",
       "      <td>101</td>\n",
       "      <td>0.857143</td>\n",
       "      <td>0.041000</td>\n",
       "      <td>11</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>QuantileTransformer(n_quantiles=100)</td>\n",
       "      <td>101</td>\n",
       "      <td>0.812991</td>\n",
       "      <td>0.044788</td>\n",
       "      <td>12</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>None</td>\n",
       "      <td>5</td>\n",
       "      <td>0.739838</td>\n",
       "      <td>0.086685</td>\n",
       "      <td>13</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>None</td>\n",
       "      <td>101</td>\n",
       "      <td>0.613857</td>\n",
       "      <td>0.031472</td>\n",
       "      <td>14</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>None</td>\n",
       "      <td>51</td>\n",
       "      <td>0.605182</td>\n",
       "      <td>0.036480</td>\n",
       "      <td>15</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                      param_preprocessor param_classifier__n_neighbors  \\\n",
       "1                       StandardScaler()                             5   \n",
       "2                         MinMaxScaler()                             5   \n",
       "3   QuantileTransformer(n_quantiles=100)                             5   \n",
       "4     PowerTransformer(method='box-cox')                             5   \n",
       "6                       StandardScaler()                            51   \n",
       "8   QuantileTransformer(n_quantiles=100)                            51   \n",
       "9     PowerTransformer(method='box-cox')                            51   \n",
       "7                         MinMaxScaler()                            51   \n",
       "11                      StandardScaler()                           101   \n",
       "12                        MinMaxScaler()                           101   \n",
       "14    PowerTransformer(method='box-cox')                           101   \n",
       "13  QuantileTransformer(n_quantiles=100)                           101   \n",
       "0                                   None                             5   \n",
       "10                                  None                           101   \n",
       "5                                   None                            51   \n",
       "\n",
       "    mean_test_score  std_test_score  rank_test_score  \n",
       "1          0.952198        0.039902                1  \n",
       "2          0.947778        0.034268                2  \n",
       "3          0.947094        0.033797                3  \n",
       "4          0.946960        0.047387                4  \n",
       "6          0.941880        0.038905                5  \n",
       "8          0.927277        0.043759                6  \n",
       "9          0.922833        0.047883                7  \n",
       "7          0.920293        0.045516                8  \n",
       "11         0.876642        0.041618                9  \n",
       "12         0.862357        0.046244               10  \n",
       "14         0.857143        0.041000               11  \n",
       "13         0.812991        0.044788               12  \n",
       "0          0.739838        0.086685               13  \n",
       "10         0.613857        0.031472               14  \n",
       "5          0.605182        0.036480               15  "
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cv_results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1d11951a",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "jupytext": {
   "cell_metadata_filter": "-all",
   "main_language": "python",
   "notebook_metadata_filter": "-all",
   "text_representation": {
    "extension": ".md",
    "format_name": "markdown"
   }
  },
  "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.4"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}