Basic_Search.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Basic Search.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "H4xQWJVsf5X2"
      },
      "source": [
        "# Basic Search"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ePqN5_7Aey0F"
      },
      "source": [
        "## Hyperparameter Nature\n",
        "\n",
        "\n",
        "\n",
        "*   **Some hyperparameters are discrete**\n",
        "    *    number of estimators in ensemble models\n",
        "*   **Some hyperparameters are continuous**\n",
        "    *    Penalization coefficient\n",
        "    *    Number of samples per split\n",
        "*   **Some hyperparameters are categorical**\n",
        "    *    Loss (deviance, exponential)\n",
        "    *    Regularization (Lasso, Ridge)\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "26gLQzK0ghI1"
      },
      "source": [
        "## Considerations\n",
        "\n",
        "**When we create hyperparameter sampling strategies we need to consider:**\n",
        "\n",
        "\n",
        "\n",
        "*   **Number of hyperparameters of the machine learning model**\n",
        "*   **The low effective dimension**\n",
        "*   **The nature of the parameters (discrete, continuous)**\n",
        "*   **The computing resources available to us**\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wIpS5OZog7S6"
      },
      "source": [
        "## Basic Hyperparameter Tuning Methods\n",
        "\n",
        "\n",
        "\n",
        "*   **Manual Search**\n",
        "*   **Grid Search**\n",
        "*   **Random Search**\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-j9OZW6PhVqj"
      },
      "source": [
        "### Manual Search"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hslcqimAhZL6"
      },
      "source": [
        "***Different hyperparameters are set and experimented with manually.***"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aqi7XRSphfxi"
      },
      "source": [
        "#### Uses\n",
        "\n",
        "\n",
        "\n",
        "*   **Used to identify regions of promising hyperparameters**\n",
        "*   **To delimit the Grid Search**\n",
        "*   **Get familiar with the hyperparameters and their effect on the models**\n",
        "*   **Establishing the benchmark model**\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "V79SJHyOhx4y"
      },
      "source": [
        "#### Limitations\n",
        "\n",
        "\n",
        "\n",
        "*   **Lack of reproducibility**\n",
        "*   **Time consuming**\n",
        "*   **Does not explore the entire hyperparameter space**\n",
        "*   **Does not scale**\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2g02DG6viOL6"
      },
      "source": [
        "#### Implementation\n",
        "\n",
        "you just play with the parameters to estimate the prefered hyperparameters"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1HzXOOncik-D"
      },
      "source": [
        "### Grid Search"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9tFOCQPsi45K"
      },
      "source": [
        "**Exhaustive search through a specified subset of hyperparameters of a learning algorithm.**\n",
        "\n",
        "Examines ***all possible combinations*** of the specified hyperparameters.\n",
        "\n",
        "Has a Cartesian product"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KfAV3h4PjM3p"
      },
      "source": [
        "Combinations: \n",
        "\n",
        ">   ℎ𝑦𝑝1 × ℎ𝑦𝑝2 × … × ℎ𝑦𝑝𝑛"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "F5hFG8c0jaaO"
      },
      "source": [
        "#### Limitations\n",
        "\n",
        "\n",
        "\n",
        "*   **Curse of dimensionality**: possible combinations grow exponentially with the number of hyperparameters\n",
        "*   **Computationally expensive**\n",
        "*   Hyperparameter **values** are **determined manually**\n",
        "*   **Not ideal for continuous hyperparameters**\n",
        "    *   A subset of “reasonable” hyperparameter values are set manually\n",
        "*   Does not explore the entire hyperparameter space **(not feasible)**\n",
        "*   It **performs worse** than other searches **(for models with complex hyperparameter spaces)**\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wseK76PWkC4L"
      },
      "source": [
        "#### Advantages\n",
        "\n",
        "\n",
        "\n",
        "*   **For models with simpler hyperparameter spaces works well.**\n",
        "*   **It can be parallelized.**\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DgU0BBrZkO4y"
      },
      "source": [
        "#### Considerations\n",
        "***Grid Search is the most expensive method in terms of total computation time. However, if run in parallel, it is fast in terms of wall clock time.***\n",
        "\n",
        "***Sometimes, we run a small grid, determine where the optimum lies, and then expand the grid in that direction.***"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vGVywzE0kq5i"
      },
      "source": [
        "#### Implementation"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qq76X4DLlRBY"
      },
      "source": [
        "from sklearn.model_selection import (\n",
        "    GridSearchCV\n",
        ")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aoM49M3UlaiB"
      },
      "source": [
        "only for example"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6dEuIh0oijdP",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0ff96c78-24c4-4fe1-bc55-51d6e18da39e"
      },
      "source": [
        "from sklearn.ensemble import GradientBoostingClassifier\n",
        "# set up the model\n",
        "gbm = GradientBoostingClassifier(random_state=0)\n",
        "\n",
        "# determine the hyperparameter space\n",
        "param_grid = dict(\n",
        "    n_estimators=[10, 20, 50, 100],\n",
        "    min_samples_split=[0.1, 0.3, 0.5],\n",
        "    max_depth=[1,2,3,4,None],\n",
        "    )\n",
        "\n",
        "print('Number of hyperparam combinations: ', \n",
        "      len(param_grid['n_estimators'])\n",
        "      *len(param_grid['min_samples_split'])\n",
        "      *len(param_grid['max_depth']))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Number of hyperparam combinations:  60\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bX69_LVmlmpR"
      },
      "source": [
        "# set up the search\n",
        "search = GridSearchCV(gbm, param_grid, scoring='roc_auc', cv=5, refit=True)\n",
        "\n",
        "# gbm is your model object.\n",
        "# param_grid is your list of parameters.\n",
        "# scoring is the type of the scoring function.\n",
        "# cv is your cross validation scheme.\n",
        "# refit: Refit an estimator using the best found parameters on the whole dataset.\n",
        "\n",
        "# find best hyperparameters\n",
        "search.fit(X_train, y_train)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dDlWaJwRmvSS"
      },
      "source": [
        "# the best hyperparameters are stored in an attribute\n",
        "\n",
        "search.best_params_"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hapnyIs6ojQq"
      },
      "source": [
        "***plot the accuracies***"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "q1tn0C7BmwMZ"
      },
      "source": [
        "# we also find the data for all models evaluated\n",
        "\n",
        "results = pd.DataFrame(search.cv_results_)\n",
        "\n",
        "print(results.shape)\n",
        "\n",
        "results.head()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wU-2vijjnfYR"
      },
      "source": [
        "# we can order the different models based on their performance\n",
        "results.sort_values(by='mean_test_score', ascending=False, inplace=True)\n",
        "\n",
        "results.reset_index(drop=True, inplace=True)\n",
        "\n",
        "results[[\n",
        "    'param_max_depth', 'param_min_samples_split', 'param_n_estimators',\n",
        "    'mean_test_score', 'std_test_score',\n",
        "]].head()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wC2BR5j3nmEY"
      },
      "source": [
        "results[[\n",
        "    'param_max_depth', 'param_min_samples_split', 'param_n_estimators',\n",
        "    'mean_test_score', 'std_test_score',\n",
        "]].tail()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8BGol5_znmro"
      },
      "source": [
        "# plot model performance and error\n",
        "\n",
        "results['mean_test_score'].plot(yerr=[results['std_test_score'], results['std_test_score']], subplots=True)\n",
        "\n",
        "plt.ylabel('Mean test score')\n",
        "plt.xlabel('Hyperparameter combinations')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ofmD42EHoM3P"
      },
      "source": [
        "use this to see the effects of ***low effective dimension***"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_m5WZVHnnwrS"
      },
      "source": [
        "# let's make a function to evaluate the model performance based on\n",
        "# single hyperparameters\n",
        "\n",
        "def summarize_by_param(hparam):\n",
        "    \n",
        "    tmp = pd.concat([\n",
        "        results.groupby(hparam)['mean_test_score'].mean(),\n",
        "        results.groupby(hparam)['mean_test_score'].std(),\n",
        "    ], axis=1)\n",
        "\n",
        "    tmp.columns = ['mean_test_score', 'std_test_score']\n",
        "    \n",
        "    return tmp"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uQaawD6Jn0UH"
      },
      "source": [
        "# performance change for n_estimators\n",
        "\n",
        "tmp = summarize_by_param('param_n_estimators')\n",
        "\n",
        "tmp.head()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "T8CCtqgIn0-4"
      },
      "source": [
        "tmp['mean_test_score'].plot(yerr=[tmp['std_test_score'], tmp['std_test_score']], subplots=True)\n",
        "plt.ylabel('roc-auc')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "drBg0_M9n3qY"
      },
      "source": [
        "tmp = summarize_by_param('param_max_depth')\n",
        "tmp['mean_test_score'].plot(yerr=[tmp['std_test_score'], tmp['std_test_score']], subplots=True)\n",
        "plt.ylabel('roc-auc')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "H9A_dRLXn9wj"
      },
      "source": [
        "tmp = summarize_by_param('param_min_samples_split')\n",
        "tmp['mean_test_score'].plot(yerr=[tmp['std_test_score'], tmp['std_test_score']], subplots=True)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7y19YjIeijdX"
      },
      "source": [
        "This parameter does not seem to improve performance much."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oh2s8XWfoYWo"
      },
      "source": [
        "***now remove the low effective dimensionality parameters***"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "r9vzVIsxoCUH"
      },
      "source": [
        "# determine the hyperparameter space\n",
        "# remove the low dimensionality parameters\n",
        "param_grid = dict(\n",
        "    n_estimators=[60, 80, 100, 120],\n",
        "    max_depth=[2,3],\n",
        "    loss = ['deviance', 'exponential'],\n",
        "    )\n",
        "\n",
        "# set up the search\n",
        "search = GridSearchCV(gbm, param_grid, scoring='roc_auc', cv=5, refit=True)\n",
        "\n",
        "# find best hyperparameters\n",
        "search.fit(X_train, y_train)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "D5HHzq2Eo3Fx"
      },
      "source": [
        "***now for more than 1 hyperparameter space use this example***"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2a394-tTpAr3"
      },
      "source": [
        "# set up the model\n",
        "svm = SVC(random_state=0)\n",
        "\n",
        "# determine the hyperparameter space\n",
        "param_grid = [\n",
        "  {'C': [1, 10, 100, 1000], 'kernel': ['linear']},\n",
        "  {'C': [1, 10, 100, 1000], 'gamma': [0.001, 0.0001], 'kernel': ['rbf']},\n",
        " ]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ajkOEMd4pWbA"
      },
      "source": [
        "still works with this codes"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "omJAXIy_pZ7I"
      },
      "source": [
        "# we also find the data for all models evaluated\n",
        "\n",
        "results = pd.DataFrame(search.cv_results_)\n",
        "\n",
        "print(results.shape)\n",
        "\n",
        "results.head()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OvMob9kEpaeg"
      },
      "source": [
        "# we can order the different models based on their performance\n",
        "results.sort_values(by='mean_test_score', ascending=False, inplace=True)\n",
        "\n",
        "results.reset_index(drop=True, inplace=True)\n",
        "\n",
        "results[[\n",
        "    'param_C', 'param_kernel', 'param_gamma',\n",
        "    'mean_test_score', 'std_test_score',\n",
        "]].head()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gfBNSLi-pcRv"
      },
      "source": [
        "results[[\n",
        "    'param_C', 'param_kernel', 'param_gamma',\n",
        "    'mean_test_score', 'std_test_score',\n",
        "]].tail()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6GPOpqBUpdyn"
      },
      "source": [
        "# plot model performance and error\n",
        "\n",
        "results['mean_test_score'].plot(yerr=[results['std_test_score'], results['std_test_score']], subplots=True)\n",
        "\n",
        "plt.ylabel('Mean test score')\n",
        "plt.xlabel('Hyperparameter combinations')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PlNt4hmgprIg"
      },
      "source": [
        "### Random Search"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8Wa26TlTpzOq"
      },
      "source": [
        "***Hyperparameter values are selected by independent (random) draws from a uniform distribution of the hyperparameter space.***\n",
        "\n",
        "***In plain English, Random Search selects the combinations of hyperparameter values at random from all the possible combinations given a hyperparameter space.***\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "*   Examines **some combinations** of the specified hyperparameters, **selected at random**.\n",
        "*   **User** ***determines*** **the number of combinations** to examine.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4czBYXMmqSWz"
      },
      "source": [
        "#### Grid vs Random Search\n",
        "\n",
        "\n",
        "\n",
        "*   **Random Search allows the exploration of more dimensions of the important parameter**\n",
        "*   **Grid Search wastes time exploring non-important dimensions**\n",
        "\n",
        "![a.png](data:image/png;base64,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)\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gquAazzqqkVG"
      },
      "source": [
        "\n",
        "\n",
        "*   **Random Search selects values from a distribution of parameter values**\n",
        "*   **As opposed to Grid Search where parameters are defined manually.**\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8K8I-ThBqvDo"
      },
      "source": [
        "*   ***Random Search is suitable for continuous hyperparameters***"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xTgEGf8nq3VA"
      },
      "source": [
        "##### Advantages\n",
        "\n",
        "![a.png](data:image/png;base64,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)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jftaaKsEq_6N"
      },
      "source": [
        "![a.png](data:image/png;base64,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)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SX6EI4GWrP0g"
      },
      "source": [
        "#### Considerations\n",
        "\n",
        "\n",
        "\n",
        "*   **We choose a (computational) budget independently(ish) of the number of parameters and possible values.**\n",
        "*   **Adding parameters that do not influence the performance does not decrease efficiency of the search (if enough iterations are allowed).**\n",
        "*   **Important to specify a continuous distribution of the hyperparameter to take full advantage of the randomization.**\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CH-WjBlvr4Yh"
      },
      "source": [
        "#### Implementation"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "x12g-S8lpqP0"
      },
      "source": [
        "##### Random Search for Hyperparameters in scikit-learn\n",
        "\n",
        "\n",
        "https://scikit-learn.org/stable/modules/grid_search.html#randomized-parameter-optimization\n",
        "\n",
        "https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.RandomizedSearchCV.html"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bBkcVc9_sGQO"
      },
      "source": [
        "from sklearn.model_selection import (\n",
        "    RandomizedSearchCV\n",
        ")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "I51A8pNDsQ_-"
      },
      "source": [
        "**for distribution we use scipy package**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ykQ8k0QqsKFu"
      },
      "source": [
        "from scipy import stats"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rOlJd-lbpqQC"
      },
      "source": [
        "###### Random Search\n",
        "\n",
        "Let's use Grid Search to find the best hyperparameters for a Gradient Boosting Classifier."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "98Ky7eIDsggX"
      },
      "source": [
        "# set up the model\n",
        "gbm = GradientBoostingClassifier(random_state=0)\n",
        "\n",
        "# determine the hyperparameter space\n",
        "param_grid = dict(\n",
        "    n_estimators=stats.randint(10, 120),\n",
        "    min_samples_split=stats.uniform(0, 1),\n",
        "    max_depth=stats.randint(1, 5),\n",
        "    loss=('deviance', 'exponential'),\n",
        "    )\n",
        "\n",
        "# for mor information on stats module see the scipy documentation"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "U3BS0U9ltYM3"
      },
      "source": [
        "# set up the search\n",
        "search = RandomizedSearchCV(gbm,\n",
        "                            param_grid,\n",
        "                            scoring='roc_auc',\n",
        "                            cv=5,\n",
        "                            n_iter = 60, # is the number of random searches\n",
        "                            random_state=10,\n",
        "                            n_jobs=4,\n",
        "                            refit=True)\n",
        "\n",
        "# find best hyperparameters\n",
        "search.fit(X_train, y_train)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QLJraD5ptiEk"
      },
      "source": [
        "# the best hyperparameters are stored in an attribute\n",
        "\n",
        "search.best_params_"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "91GSVWfVtkYf"
      },
      "source": [
        "**PLOT**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EiewR6SLtivt"
      },
      "source": [
        "# we also find the data for all models evaluated\n",
        "\n",
        "results = pd.DataFrame(search.cv_results_)\n",
        "\n",
        "print(results.shape)\n",
        "\n",
        "results.head()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "p9RlRRE3tnc9"
      },
      "source": [
        "# we can order the different models based on their performance\n",
        "results.sort_values(by='mean_test_score', ascending=False, inplace=True)\n",
        "\n",
        "results.reset_index(drop=True, inplace=True)\n",
        "\n",
        "#differ for other algorithms\n",
        "results[[\n",
        "    'param_max_depth', 'param_min_samples_split', 'param_n_estimators',\n",
        "    'mean_test_score', 'std_test_score',\n",
        "]].head()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uSxj0ezetqK1"
      },
      "source": [
        "results[[\n",
        "    'param_max_depth', 'param_min_samples_split', 'param_n_estimators',\n",
        "    'mean_test_score', 'std_test_score',\n",
        "]].tail()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "r97DwVlXtykW"
      },
      "source": [
        "# plot model performance and error\n",
        "\n",
        "results['mean_test_score'].plot(yerr=[results['std_test_score'], results['std_test_score']], subplots=True)\n",
        "\n",
        "plt.ylabel('Mean test score')\n",
        "plt.xlabel('Hyperparameter combinations')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ad0w6AvNt26X"
      },
      "source": [
        "**for the low effect dimensionality**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KLXeGXzwtz8O"
      },
      "source": [
        "# let's make a function to evaluate the model performance based on\n",
        "# single hyperparameters\n",
        "\n",
        "def summarize_by_param(hparam):\n",
        "    \n",
        "    tmp = pd.concat([\n",
        "        results.groupby(hparam)['mean_test_score'].mean(),\n",
        "        results.groupby(hparam)['mean_test_score'].std(),\n",
        "    ], axis=1)\n",
        "\n",
        "    tmp.columns = ['mean_test_score', 'std_test_score']\n",
        "    \n",
        "    return tmp"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FuXefaBeuBx-"
      },
      "source": [
        "# performance change for n_estimators\n",
        "\n",
        "tmp = summarize_by_param('param_n_estimators')\n",
        "\n",
        "tmp.head()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-9lwGeNEuDeg"
      },
      "source": [
        "tmp['mean_test_score'].plot(yerr=[tmp['std_test_score'], tmp['std_test_score']], subplots=True)\n",
        "plt.ylabel('roc-auc')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hmKoxx3UpqQL"
      },
      "source": [
        "The optimal hyperparameter seems to be somewhere between this plot use it to determine the possible best parameter."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JG4YcOt4uE3G"
      },
      "source": [
        "tmp = summarize_by_param('param_max_depth')\n",
        "tmp['mean_test_score'].plot(yerr=[tmp['std_test_score'], tmp['std_test_score']], subplots=True)\n",
        "plt.ylabel('roc-auc')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "c6glPzKduWLZ"
      },
      "source": [
        "The optimal hyperparameter seems to be somewhere between this plot use it to determine the possible best parameter."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "37DAS6_0uYrW"
      },
      "source": [
        "tmp = summarize_by_param('param_min_samples_split')\n",
        "tmp['mean_test_score'].plot(yerr=[tmp['std_test_score'], tmp['std_test_score']], subplots=True)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5SOW6UPypqQN"
      },
      "source": [
        "This some parameter does not seem to improve performance much."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0GsDVl1hufRG"
      },
      "source": [
        "you can also plot for categorical parameters"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rps3jDIIpqQO"
      },
      "source": [
        "tmp = summarize_by_param('param_loss')\n",
        "tmp['mean_test_score'].plot.bar(yerr=[tmp['std_test_score'], tmp['std_test_score']], subplots=True)\n",
        "plt.ylim(0.97,1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Rz8MaedMuqCs"
      },
      "source": [
        "##### Randomized Search with Scikit-Optimize\n",
        "\n",
        "In this notebook, we will perform **Randomized Search** to select the best **hyperparameters** for a Gradient Boosting Classifier, using the open source Python package [Scikit-Optimize](https://scikit-optimize.github.io/stable/index.html).\n",
        "\n",
        "The randomized search is performed with the class [dummy_minimize](https://scikit-optimize.github.io/stable/modules/generated/skopt.dummy_minimize.html#skopt.dummy_minimize).\n",
        "\n",
        "\n",
        "### Procedure\n",
        "\n",
        "To tune the hyper-parameters of our model we need to:\n",
        "\n",
        "- define a model\n",
        "- decide which parameters to optimize\n",
        "- define the objective function we want to minimize.\n",
        "\n",
        "### NOTE\n",
        "\n",
        "Scikit-Optimize will always **minimize** the objective function, so if we want to maximize a function, for example the roc-auc, we need to **negate** the metric. Thus, instead of maximizing the roc-auc, we minimize the -roc-auc.\n",
        "\n",
        "also require\n",
        "\n",
        ">   dimensions : list, shape (n_dims,)\n",
        "\n",
        ">>List of search space dimensions. Each search dimension can be defined either as\n",
        ">>*   a (lower_bound, upper_bound) tuple (for Real or Integer dimensions),\n",
        ">>*   a (lower_bound, upper_bound, prior) tuple (for Real dimensions),\n",
        ">>*   as a list of categories (for Categorical dimensions), or\n",
        ">>*   an instance of a Dimension object (Real, Integer or Categorical).\n",
        "\n",
        "and also you can set\n",
        "\n",
        ">initial_point_generator : str, InitialPointGenerator instance, default: \"random\"\n",
        "\n",
        ">>Sets a initial points generator. Can be either\n",
        ">>*   \"random\" for uniform random numbers,\n",
        ">>*   \"sobol\" for a Sobol sequence,\n",
        ">>*   \"halton\" for a Halton sequence,\n",
        ">>*   \"hammersly\" for a Hammersly sequence,\n",
        ">>*   \"lhs\" for a latin hypercube sequence,\n",
        ">>*   \"grid\" for a uniform grid sequence\n",
        "\n",
        "see the documentation for more info"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qjC4_bznwPEG"
      },
      "source": [
        "from skopt import dummy_minimize # for the randomized search\n",
        "from skopt.plots import plot_convergence # plots the convergence\n",
        "from skopt.space import Real, Integer, Categorical # for our hyper-parameter space \n",
        "from skopt.utils import use_named_args"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "brGZlT97uqC1"
      },
      "source": [
        "###### Define the Hyperparameter Space\n",
        "\n",
        "Scikit-optimize provides an utility function to create the range of values to examine for each hyperparameters. More details in [skopt.Space](https://scikit-optimize.github.io/stable/modules/generated/skopt.Space.html)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ErhklKkouqC1",
        "outputId": "e9eece9f-50a2-4659-a2f7-b1fa0571fe56"
      },
      "source": [
        "# With Integer, we create a space of integers, sampled uniformly\n",
        "# between the minimum and maximum indicated values\n",
        "\n",
        "Integer(10, 120, name=\"n_estimators\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "Integer(low=10, high=120, prior='uniform', transform='identity')"
            ]
          },
          "execution_count": 5,
          "metadata": {},
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_fBZoTBsuqC2",
        "outputId": "be0f43cc-b16a-4001-cb15-859d55022264"
      },
      "source": [
        "# With Real, we create a space of real values, sampled uniformly\n",
        "# between the minimum and maximum indicated values\n",
        "\n",
        "Real(0, 1, name=\"min_samples_split\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "Real(low=0, high=1, prior='uniform', transform='identity')"
            ]
          },
          "execution_count": 6,
          "metadata": {},
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HUooFQ23uqC3",
        "outputId": "34996143-b743-42e3-caaf-31562285a156"
      },
      "source": [
        "# With Categorical, we create a space of categories\n",
        "\n",
        "Categorical(['deviance', 'exponential'], name=\"loss\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "Categorical(categories=('deviance', 'exponential'), prior=None)"
            ]
          },
          "execution_count": 7,
          "metadata": {},
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JYFLrATguqC3",
        "outputId": "fcac1b76-9c87-451d-9099-d0af9ca3d1f0"
      },
      "source": [
        "# determine the hyperparameter space\n",
        "\n",
        "param_grid = [\n",
        "    Integer(10, 120, name=\"n_estimators\"),\n",
        "    Real(0, 0.999, name=\"min_samples_split\"),\n",
        "    Integer(1, 5, name=\"max_depth\"),\n",
        "    Categorical(['deviance', 'exponential'], name=\"loss\"),\n",
        "]\n",
        "\n",
        "# Scikit-optimize parameter grid is a list\n",
        "type(param_grid)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "list"
            ]
          },
          "execution_count": 8,
          "metadata": {},
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XIEJxRkOuqC4"
      },
      "source": [
        "###### Define the model"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EdDHs6dQuqC4"
      },
      "source": [
        "# set up the gradient boosting classifier\n",
        "\n",
        "gbm = GradientBoostingClassifier(random_state=0)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "U6Dk5NQDuqC5"
      },
      "source": [
        "###### Define the objective function\n",
        "\n",
        "This is the hyperparameter response space, the function we want to minimize."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FXwXatwfuqC5"
      },
      "source": [
        "# We design a function to maximize the accuracy, of a GBM,\n",
        "# with cross-validation\n",
        "\n",
        "# the decorator allows our objective function to receive the parameters as\n",
        "# keyword arguments. This is a requirement for scikit-optimize.\n",
        "\n",
        "@use_named_args(param_grid)\n",
        "def objective(**params):\n",
        "    \n",
        "    # model with new parameters\n",
        "    gbm.set_params(**params)\n",
        "\n",
        "    # optimization function (hyperparam response function)\n",
        "    value = np.mean(\n",
        "        cross_val_score(\n",
        "            gbm, \n",
        "            X_train,\n",
        "            y_train,\n",
        "            cv=3,\n",
        "            n_jobs=-4,\n",
        "            scoring='accuracy')\n",
        "    )\n",
        "\n",
        "    # negate because we need to minimize\n",
        "    return -value  # depends on scoring function. we choose accuracy \n",
        "                   #so we need that to be max so in this function we need to set it to negative"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uQhtWXoBuqC5"
      },
      "source": [
        "###### Randomized Search"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vFebe0K3uqC6"
      },
      "source": [
        "# dummy_minimize performs the randomized search\n",
        "\n",
        "search = dummy_minimize(\n",
        "    objective,  # the objective function to minimize\n",
        "    param_grid,  # the hyperparameter space\n",
        "    n_calls=50,  # the number of subsequent evaluations of f(x)\n",
        "    random_state=0,\n",
        ")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "q28gRW_LuqC6"
      },
      "source": [
        "# function value at the minimum.\n",
        "# note that it is the negative of the accuracy\n",
        "\n",
        "\"Best score=%.4f\" % search.fun"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nPJOBPmduqC7"
      },
      "source": [
        "print(\"\"\"Best parameters:\n",
        "=========================\n",
        "- n_estimators=%d\n",
        "- min_samples_split=%.6f\n",
        "- max_depth=%d\n",
        "- loss=%s\"\"\" % (search.x[0], \n",
        "                search.x[1],\n",
        "                search.x[2],\n",
        "                search.x[3]))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "moVq50xYuqC7"
      },
      "source": [
        "###### Evaluate convergence of the search\n",
        "\n",
        "[plot_convergence](https://scikit-optimize.github.io/stable/modules/generated/skopt.plots.plot_convergence.html#skopt.plots.plot_convergence)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-DSq_gF2uqC7"
      },
      "source": [
        "plot_convergence(search)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hCOuo8aDuqC8"
      },
      "source": [
        "Note that with around some iterations, the procedure already found the minimum of the hyperparamter response function."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lSufmLhbyUCi"
      },
      "source": [
        "##### Randomized Search with Hyperopt\n",
        "\n",
        "In this notebook, we will perform **Randomized Search** to select the best **hyperparameters** for a Gradient Boosting Classifier, using the open source Python package [Hyperopt](http://hyperopt.github.io/hyperopt/).\n",
        "\n",
        "The randomized search is performed with the class **rand**.\n",
        "\n",
        "I find the documentation for Hyperopt quite unintuitive, so it helps to refer to the [original article](https://iopscience.iop.org/article/10.1088/1749-4699/8/1/014008/pdf) to understand the different parameters and classes.\n",
        "\n",
        "To step out of Scikit-learn, we will optimise the parameters of a Gradient Boosting Machine of the [xgboost package](https://xgboost.readthedocs.io/en/latest/python/python_intro.html).\n",
        "\n",
        "\n",
        "### Procedure\n",
        "\n",
        "To tune the hyper-parameters of our model we need to:\n",
        "\n",
        "- define a model\n",
        "- define the hyperparameter space\n",
        "- define the objective function we want to minimize."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NsbhlepMzBxt"
      },
      "source": [
        "for more information you can visit these links\n",
        "\n",
        "*   [Getting started with Hyperopt](http://hyperopt.github.io/hyperopt/getting-started/overview/)\n",
        "*   [Defining a Search Space](http://hyperopt.github.io/hyperopt/getting-started/search_spaces/)\n",
        "*   [Defining a Function to Minimize](http://hyperopt.github.io/hyperopt/getting-started/minimizing_functions/)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oNTvpKbpyoLs"
      },
      "source": [
        "import xgboost as xgb\n",
        "\n",
        "from hyperopt import hp, rand, fmin, Trials\n",
        "\n",
        "# hp: define the hyperparameter space\n",
        "# rand: random search\n",
        "# fmin: optimization function\n",
        "# Trials: to evaluate the different searched hyperparameters"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NdgWoO0GyUCv"
      },
      "source": [
        "###### Define the Hyperparameter Space\n",
        "\n",
        "- [Hyperopt search space](http://hyperopt.github.io/hyperopt/getting-started/search_spaces/)\n",
        "\n",
        "- [xgb.XGBClassifier hyperparameters](https://xgboost.readthedocs.io/en/latest/python/python_api.html#xgboost.XGBClassifier)\n",
        "\n",
        "- [xgb general parameters](https://xgboost.readthedocs.io/en/latest/parameter.html)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "T5Q_Ok_s1csU"
      },
      "source": [
        "# determine the hyperparameter space\n",
        "\n",
        "param_grid = {\n",
        "    'n_estimators': hp.quniform('n_estimators', 200, 2500, 100),\n",
        "    'max_depth': hp.uniform('max_depth', 1, 10),\n",
        "    'learning_rate': hp.uniform('learning_rate', 0.01, 0.99),\n",
        "    'booster': hp.choice('booster', ['gbtree', 'dart']),\n",
        "    'gamma': hp.quniform('gamma', 0.01, 10, 0.1),\n",
        "    'subsample': hp.uniform('subsample', 0.50, 0.90),\n",
        "    'colsample_bytree': hp.uniform('colsample_bytree', 0.50, 0.99),\n",
        "    'colsample_bylevel': hp.uniform('colsample_bylevel', 0.50, 0.99),\n",
        "    'colsample_bynode': hp.uniform('colsample_bynode', 0.50, 0.99),\n",
        "    'reg_lambda': hp.uniform('reg_lambda', 1, 20)\n",
        "}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hB-IIGUOzweT"
      },
      "source": [
        "###### Parameter Expressions\n",
        "\n",
        "**The stochastic expressions currently recognized by hyperopt's optimization algorithms are:**\n",
        "\n",
        "    hp.choice(label, options)\n",
        "> Returns one of the options, which should be a list or tuple. The elements of **options** can themselves be [nested] stochastic expressions. In this case, the stochastic choices that only appear in some of the options become conditional parameters.\n",
        "\n",
        "    hp.randint(label, upper)\n",
        ">Returns a random integer in the range [0, upper). The semantics of this distribution is that there is no more correlation in the loss function between nearby integer values, as compared with more distant integer values. This is an appropriate distribution for describing random seeds for example. If the loss function is probably more correlated for nearby integer values, then you should probably use one of the \"quantized\" continuous distributions, such as either **quniform**, **qloguniform**, **qnormal** or **qlognormal**.\n",
        "\n",
        "    hp.uniform(label, low, high)\n",
        "\n",
        ">Returns a value uniformly between **low** and **high**.\n",
        "When optimizing, this variable is constrained to a two-sided interval.\n",
        "\n",
        "    hp.quniform(label, low, high, q)\n",
        "\n",
        ">Returns a value like round(uniform(low, high) / q) * q\n",
        "Suitable for a discrete value with respect to which the objective is still somewhat \"smooth\", but which should be bounded both above and below.\n",
        "\n",
        "    hp.loguniform(label, low, high)\n",
        "\n",
        ">Returns a value drawn according to exp(uniform(low, high)) so that the logarithm of the return value is uniformly distributed.\n",
        "When optimizing, this variable is constrained to the interval [exp(low), exp(high)].\n",
        "\n",
        "    hp.qloguniform(label, low, high, q)\n",
        "\n",
        ">Returns a value like round(exp(uniform(low, high)) / q) * q\n",
        "Suitable for a discrete variable with respect to which the objective is \"smooth\" and gets smoother with the size of the value, but which should be bounded both above and below.\n",
        "\n",
        "    hp.normal(label, mu, sigma)\n",
        "\n",
        ">Returns a real value that's normally-distributed with mean mu and standard deviation sigma. When optimizing, this is an unconstrained variable.\n",
        "\n",
        "    hp.qnormal(label, mu, sigma, q)\n",
        "\n",
        ">Returns a value like round(normal(mu, sigma) / q) * q\n",
        "Suitable for a discrete variable that probably takes a value around mu, but is fundamentally unbounded.\n",
        "\n",
        "    hp.lognormal(label, mu, sigma)\n",
        "\n",
        ">Returns a value drawn according to exp(normal(mu, sigma)) so that the logarithm of the return value is normally distributed. When optimizing, this variable is constrained to be positive.\n",
        "\n",
        "    hp.qlognormal(label, mu, sigma, q)\n",
        "\n",
        ">Returns a value like round(exp(normal(mu, sigma)) / q) * q\n",
        "Suitable for a discrete variable with respect to which the objective is smooth and gets smoother with the size of the variable, which is bounded from one side."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "z6XzDqq4yUCx"
      },
      "source": [
        "###### Define the objective function\n",
        "\n",
        "This is the hyperparameter response space, the function we want to minimize."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "phVPDFUz1mis"
      },
      "source": [
        "# the objective function takes the hyperparameter space\n",
        "# as input\n",
        "\n",
        "def objective(params):\n",
        "\n",
        "    # we need a dictionary to indicate which value from the space\n",
        "    # to attribute to each value of the hyperparameter in the xgb\n",
        "    params_dict = {\n",
        "        'n_estimators': int(params['n_estimators']), # important int, as it takes integers only\n",
        "        'max_depth': int(params['max_depth']), # important int, as it takes integers only\n",
        "        'learning_rate': params['learning_rate'],\n",
        "        'booster': params['booster'],\n",
        "        'gamma': params['gamma'],\n",
        "        'subsample': params['subsample'],\n",
        "        'colsample_bytree': params['colsample_bytree'],\n",
        "        'colsample_bylevel': params['colsample_bylevel'],\n",
        "        'colsample_bynode': params['colsample_bynode'],\n",
        "        'random_state': 1000,\n",
        "    }\n",
        "\n",
        "    # with ** we pass the items in the dictionary as parameters\n",
        "    # to the xgb\n",
        "    gbm = xgb.XGBClassifier(**params_dict)\n",
        "\n",
        "    # train with cv\n",
        "    score = cross_val_score(gbm, X_train, y_train,\n",
        "                            scoring='accuracy', cv=5, n_jobs=4).mean()\n",
        "\n",
        "    # to minimize, we negate the score\n",
        "    return -score"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tzuKpqFOyUCy"
      },
      "source": [
        "###### Randomized Search\n",
        "\n",
        "[fmin](http://hyperopt.github.io/hyperopt/getting-started/minimizing_functions/)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HYQtzV8A12oK"
      },
      "source": [
        "# fmin performs the minimization\n",
        "# rand.suggest samples the parameters at random\n",
        "# i.e., performs the random search\n",
        "\n",
        "search = fmin(\n",
        "    fn=objective,\n",
        "    space=param_grid,\n",
        "    max_evals=50,\n",
        "    rstate=np.random.RandomState(42),\n",
        "    algo=rand.suggest,  # randomized search\n",
        ")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AB4w-tu1yUC0",
        "outputId": "3e1392d6-7e5e-439e-8aa8-367b8a032568"
      },
      "source": [
        "# fmin returns a dictionary with the best parameters\n",
        "\n",
        "type(search)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "dict"
            ]
          },
          "execution_count": 8,
          "metadata": {},
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "r_tkBu8K14RD"
      },
      "source": [
        "search"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "geAetySC2AWj"
      },
      "source": [
        "# create another dictionary to pass the search items as parameters\n",
        "# to a new xgb\n",
        "\n",
        "best_hp_dict = {\n",
        "        'n_estimators': int(search['n_estimators']), # important int, as it takes integers only\n",
        "        'max_depth': int(search['max_depth']), # important int, as it takes integers only\n",
        "        'learning_rate': search['learning_rate'],\n",
        "        'booster': 'gbtree',\n",
        "        'gamma': search['gamma'],\n",
        "        'subsample': search['subsample'],\n",
        "        'colsample_bytree': search['colsample_bytree'],\n",
        "        'colsample_bylevel': search['colsample_bylevel'],\n",
        "        'colsample_bynode': search['colsample_bynode'],\n",
        "        'random_state': 1000,\n",
        "}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "r-IwvMGo2B1R"
      },
      "source": [
        "# after the search we can train the model with the\n",
        "# best parameters manually\n",
        "\n",
        "gbm_final = xgb.XGBClassifier(**best_hp_dict)\n",
        "\n",
        "gbm_final.fit(X_train, y_train)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bqLcZtOAyUC1"
      },
      "source": [
        "###### Evaluating the search\n",
        "\n",
        "We can use Trials if we want to look into the search, and the performance values encountered during the process."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PBTF-uHy2H5y"
      },
      "source": [
        "trials = Trials()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "n7ZXoXGH2Jts"
      },
      "source": [
        "second_search = fmin(\n",
        "    fn=objective,\n",
        "    space=param_grid,\n",
        "    max_evals=50,\n",
        "    rstate=np.random.RandomState(42),\n",
        "    algo=rand.suggest,  # randomized search\n",
        "    trials = trials\n",
        ")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UdRSsUpn2LMY"
      },
      "source": [
        "# best hyperparameters\n",
        "\n",
        "second_search"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "G5DMsMIj2Mhb"
      },
      "source": [
        "# the best hyperparameters can also be found in\n",
        "# trials\n",
        "\n",
        "trials.argmin"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MdobUl242Zv9"
      },
      "source": [
        "**plot**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wg0GVHqX2QSb"
      },
      "source": [
        "# the search hyperparameter combinations\n",
        "\n",
        "pd.DataFrame(trials.vals).head()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oG0XZ9gw2Svr"
      },
      "source": [
        "# the results\n",
        "\n",
        "pd.DataFrame(trials.results).head()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UsafrVCx2Wr6"
      },
      "source": [
        "results = pd.concat([\n",
        "    pd.DataFrame(trials.vals),\n",
        "    pd.DataFrame(trials.results)],\n",
        "    axis=1,\n",
        ").sort_values(by='loss', ascending=False).reset_index(drop=True)\n",
        "\n",
        "results.head()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qyfR5zKW2djy"
      },
      "source": [
        "results['loss'].plot()\n",
        "plt.ylabel('Accuracy')\n",
        "plt.xlabel('Hyperparam combination')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AuSdG4w9yUC4"
      },
      "source": [
        "pd.DataFrame(trials.results)['loss'].min()"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}