From ea60d31e70df99b14843275a47829b00fc01f197 Mon Sep 17 00:00:00 2001 From: SvenKlaassen Date: Wed, 12 Nov 2025 15:20:35 +0000 Subject: [PATCH 01/11] restructure learner example --- doc/examples/index.rst | 3 ++- .../py_learner.ipynb} | 5 +++-- 2 files changed, 5 insertions(+), 3 deletions(-) rename doc/examples/{py_double_ml_learner.ipynb => learners/py_learner.ipynb} (99%) diff --git a/doc/examples/index.rst b/doc/examples/index.rst index 94896f76..4e28bc5b 100644 --- a/doc/examples/index.rst +++ b/doc/examples/index.rst @@ -22,7 +22,8 @@ General Examples py_double_ml_sensitivity.ipynb py_double_ml_apo.ipynb py_double_ml_irm_vs_apo.ipynb - py_double_ml_learner.ipynb + learners/py_learner.ipynb + learners/py_optuna.ipynb py_double_ml_firststage.ipynb py_double_ml_multiway_cluster.ipynb py_double_ml_ssm.ipynb diff --git a/doc/examples/py_double_ml_learner.ipynb b/doc/examples/learners/py_learner.ipynb similarity index 99% rename from doc/examples/py_double_ml_learner.ipynb rename to doc/examples/learners/py_learner.ipynb index a63b468a..f6d0d106 100644 --- a/doc/examples/py_double_ml_learner.ipynb +++ b/doc/examples/learners/py_learner.ipynb @@ -7,9 +7,10 @@ "source": [ "# Python: Choice of learners\n", "\n", - "This notebooks contains some practical recommendations to choose the right learner and evaluate different learners for the corresponding nuisance components.\n", + "This notebook contains some practical recommendations to choose the right learner and evaluate different learners for the corresponding nuisance components.\n", + "This notebook mainly highlights the differences in using different learners, i.e. linear or tree-based methods. Generally, we recommend to tune hyperparameters for the chosen learners, see [Example Gallery](https://docs.doubleml.org/stable/examples/index.html).\n", "\n", - "For the example, we will work with a IRM, but all of the important components are directly usable for all other models too.\n", + "For the example, we will work with a IRM, but all of the important components are directly usable for all other models, too.\n", "\n", "To be able to compare the properties of different learners, we will start by setting the true treatment parameter to zero, fix some other parameters of the data generating process and generate several datasets \n", "to obtain some information about the distribution of the estimators." From 1e8c1f7957437ad3277ee85a1d45ff325e9355e9 Mon Sep 17 00:00:00 2001 From: SvenKlaassen Date: Wed, 12 Nov 2025 15:20:44 +0000 Subject: [PATCH 02/11] first optuna example --- doc/examples/learners/py_optuna.ipynb | 758 ++++++++++++++++++++++++++ 1 file changed, 758 insertions(+) create mode 100644 doc/examples/learners/py_optuna.ipynb diff --git a/doc/examples/learners/py_optuna.ipynb b/doc/examples/learners/py_optuna.ipynb new file mode 100644 index 00000000..4c503ead --- /dev/null +++ b/doc/examples/learners/py_optuna.ipynb @@ -0,0 +1,758 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "50de5573", + "metadata": {}, + "source": [ + "# Python: Hyperparametertuning with Optuna\n", + "\n", + "This notebook explains how to use the implmented `tune_ml_models()` method to tune hyperparameters using the [Optuna](https://optuna.org/) package.\n", + "\n", + "In this example, we will focus on the [DoubleMLAPO](https://docs.doubleml.org/stable/api/generated/doubleml.irm.DoubleMLAPO.html#doubleml.irm.DoubleMLAPO) model to estimate average potential outcomes (APOs) in an interactive regression model (see [DoubleMLIRM](https://docs.doubleml.org/stable/guide/models.html#binary-interactive-regression-model-irm)).\n", + "\n", + "The goal is to estimate the average potential outcome\n", + "\n", + " $$\\theta_0 =\\mathbb{E}[Y(d)]$$\n", + "\n", + "for a given treatment level $d$ and and discrete valued treatment $D$.\n", + "\n", + "For a more detailed description of the DoubleMLAPO model, see [Average Potential Outcome Model](https://docs.doubleml.org/stable/guide/models.html#average-potential-outcomes-apos) or [Example Gallery](https://docs.doubleml.org/stable/examples/index.html)." + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "7e56470f", + "metadata": {}, + "outputs": [], + "source": [ + "import optuna\n", + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "from lightgbm import LGBMRegressor, LGBMClassifier\n", + "\n", + "from doubleml.data import DoubleMLData\n", + "from doubleml.irm import DoubleMLAPO\n", + "from doubleml.irm.datasets import make_irm_data_discrete_treatments" + ] + }, + { + "cell_type": "markdown", + "id": "433cbe4c", + "metadata": {}, + "source": [ + "## Data Generating Process (DGP)" + ] + }, + { + "cell_type": "markdown", + "id": "ebdfa1ad", + "metadata": {}, + "source": [ + "At first, let us generate data according to the [make_irm_data_discrete_treatments](https://docs.doubleml.org/dev/api/datasets.html#dataset-generators) data generating process. The process generates data with a continuous treatment variable and contains the true individual treatment effects (ITEs) with respect to option of not getting treated.\n", + "\n", + "According to the continuous treatment variable, the treatment is discretized into multiple levels, based on quantiles. Using the *oracle* ITEs, enables the comparison to the true APOs and averate treatment effects (ATEs) for the different levels of the treatment variable.\n", + "\n", + "**Remark:** The average potential outcome model does not require an underlying continuous treatment variable. The model will work identically if the treatment variable is discrete by design." + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "e246dbc8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Average Individual effects in each group:\n", + "[ 0. 1.75 7.03 9.43 10.4 10.49]\n", + "\n", + "Average Potential Outcomes in each group:\n", + "[210.04 211.79 217.06 219.47 220.44 220.53]\n", + "\n", + "Levels and their counts:\n", + "(array([0., 1., 2., 3., 4., 5.]), array([615, 487, 465, 482, 480, 471]))\n" + ] + } + ], + "source": [ + "# Parameters\n", + "n_obs = 3000\n", + "n_levels = 5\n", + "linear = True\n", + "n_rep = 10\n", + "\n", + "np.random.seed(42)\n", + "data_apo = make_irm_data_discrete_treatments(n_obs=n_obs,n_levels=n_levels, linear=linear)\n", + "\n", + "y0 = data_apo['oracle_values']['y0']\n", + "cont_d = data_apo['oracle_values']['cont_d']\n", + "ite = data_apo['oracle_values']['ite']\n", + "d = data_apo['d']\n", + "potential_level = data_apo['oracle_values']['potential_level']\n", + "level_bounds = data_apo['oracle_values']['level_bounds']\n", + "\n", + "average_ites = np.full(n_levels + 1, np.nan)\n", + "apos = np.full(n_levels + 1, np.nan)\n", + "mid_points = np.full(n_levels, np.nan)\n", + "\n", + "for i in range(n_levels + 1):\n", + " average_ites[i] = np.mean(ite[d == i]) * (i > 0)\n", + " apos[i] = np.mean(y0) + average_ites[i]\n", + "\n", + "print(f\"Average Individual effects in each group:\\n{np.round(average_ites,2)}\\n\")\n", + "print(f\"Average Potential Outcomes in each group:\\n{np.round(apos,2)}\\n\")\n", + "print(f\"Levels and their counts:\\n{np.unique(d, return_counts=True)}\")" + ] + }, + { + "cell_type": "markdown", + "id": "1cd46dba", + "metadata": {}, + "source": [ + "As for all [DoubleML](https://docs.doubleml.org/stable/index.html) models, we specify a [DoubleMLData](https://docs.doubleml.org/stable/api/generated/doubleml.data.DoubleMLData.html) object to handle the data." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a98bf812", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "================== DoubleMLData Object ==================\n", + "\n", + "------------------ Data summary ------------------\n", + "Outcome variable: y\n", + "Treatment variable(s): ['d']\n", + "Covariates: ['x0', 'x1', 'x2', 'x3', 'x4']\n", + "Instrument variable(s): None\n", + "No. Observations: 3000\n", + "\n", + "------------------ DataFrame info ------------------\n", + "\n", + "RangeIndex: 3000 entries, 0 to 2999\n", + "Columns: 7 entries, y to x4\n", + "dtypes: float64(7)\n", + "memory usage: 164.2 KB\n", + "\n" + ] + } + ], + "source": [ + "y = data_apo['y']\n", + "x = data_apo['x']\n", + "d = data_apo['d']\n", + "df_apo = pd.DataFrame(\n", + " np.column_stack((y, d, x)),\n", + " columns=['y', 'd'] + ['x' + str(i) for i in range(data_apo['x'].shape[1])]\n", + ")\n", + "\n", + "dml_data = DoubleMLData(df_apo, 'y', 'd')\n", + "print(dml_data)" + ] + }, + { + "cell_type": "markdown", + "id": "397fd594", + "metadata": {}, + "source": [ + "## Basic Tuning Example\n", + "\n", + "At first, we will take a look at a very basic tuning example without much customization." + ] + }, + { + "cell_type": "markdown", + "id": "ce8478ec", + "metadata": {}, + "source": [ + "### Define Nuisance Learners\n", + "\n", + "For our example, we will choose [LightGBM](https://lightgbm.readthedocs.io/en/stable/) learners, which are typical non-parametric choice." + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "id": "5ae487e1", + "metadata": {}, + "outputs": [], + "source": [ + "ml_g = LGBMRegressor(random_state=314, verbose=-1)\n", + "ml_m = LGBMClassifier(random_state=314, verbose=-1)" + ] + }, + { + "cell_type": "markdown", + "id": "f3a336e1", + "metadata": {}, + "source": [ + "### Untuned Model\n", + "\n", + "Now let us take a look at the standard workflow, focusing on a single treatment level and using default hyperparameters." + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "id": "86171262", + "metadata": {}, + "outputs": [], + "source": [ + "treatment_level = 1.0" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "id": "68ea7d50", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
coefstd errtP>|t|2.5 %97.5 %
d211.0373.14435467.1161630.0204.874178217.199821
\n", + "
" + ], + "text/plain": [ + " coef std err t P>|t| 2.5 % 97.5 %\n", + "d 211.037 3.144354 67.116163 0.0 204.874178 217.199821" + ] + }, + "execution_count": 63, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dml_obj_untuned = DoubleMLAPO(\n", + " dml_data,\n", + " ml_g,\n", + " ml_m,\n", + " treatment_level=treatment_level,\n", + ")\n", + "\n", + "dml_obj_untuned.fit()\n", + "dml_obj_untuned.summary" + ] + }, + { + "cell_type": "markdown", + "id": "affc29fc", + "metadata": {}, + "source": [ + "### Hyperparametertuning\n", + "\n", + "Now, let us take a look at the basic hyperparametertuning. We will initialize a separate model to compare the results." + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "id": "76ff8ca0", + "metadata": {}, + "outputs": [], + "source": [ + "dml_obj_tuned = DoubleMLAPO(\n", + " dml_data,\n", + " ml_g,\n", + " ml_m,\n", + " treatment_level=treatment_level,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "3fedc3a1", + "metadata": {}, + "source": [ + "To required input for tuning is a parameter space dictionary for the hyperparameters for each learner that should be tuned.\n", + "This dictionary should include a callable for each learner you want to have. \n", + "\n", + "**Remark**: Even if the initialization only requires the learners `ml_g` and `ml_m`, the models in the `irm` submodule generally, copy the learner for `ml_g` and fit different response surfaces for treatment and control groups. These different learners should be tuned separately and require separate parameter spaces. To see which parameter spaces can be tuned you can take a look at the `params_names` property." + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "id": "17fe4e01", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['ml_g_d_lvl0', 'ml_g_d_lvl1', 'ml_m']" + ] + }, + "execution_count": 57, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dml_obj_tuned.params_names" + ] + }, + { + "cell_type": "markdown", + "id": "ebbc62ce", + "metadata": {}, + "source": [ + "The parameter spaces should be a callable and suggest the search spaces via a `trial` object.\n", + "\n", + "Generally, the hyperparameter structure should follow the definitions in [Optuna](https://optuna.org/#key_features), but instead of the objective the hyperparameters have to be specified as a callable. The corresponding DoubleML object then assigns a corresponding objective for each learning using the supplied parameter space.\n", + "\n", + "To keep this example fast and simple, we keep the `n_estimators` fix and only tune a small number of other hyperparameters." + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "id": "6102fe5b", + "metadata": {}, + "outputs": [], + "source": [ + "# parameter space for the propensity score tuning\n", + "def ml_m_params(trial):\n", + " return {\n", + " 'n_estimators': 100,\n", + " 'learning_rate': trial.suggest_float('learning_rate', 0.005, 0.1),\n", + " 'max_depth': trial.suggest_int('max_depth', 2, 5),\n", + " 'min_child_samples': trial.suggest_int('min_child_samples', 5, 100),\n", + " }\n", + "\n", + "# parameter space for the outcome regression tuning at treatment level != 1.0\n", + "def ml_g_d_lvl0_params(trial):\n", + " return {\n", + " 'n_estimators': 100,\n", + " 'learning_rate': trial.suggest_float('learning_rate', 0.005, 0.1),\n", + " 'max_depth': trial.suggest_int('max_depth', 2, 5),\n", + " 'min_child_samples': trial.suggest_int('min_child_samples', 5, 100),\n", + " }\n", + "\n", + "# parameter space for the outcome regression tuning at treatment level == 1.0\n", + "def ml_g_d_lvl1_params(trial):\n", + " return {\n", + " 'n_estimators': 100,\n", + " 'learning_rate': trial.suggest_float('learning_rate', 0.005, 0.1),\n", + " 'max_depth': trial.suggest_int('max_depth', 2, 5),\n", + " 'min_child_samples': trial.suggest_int('min_child_samples', 5, 100),\n", + " }\n", + "\n", + "param_space = {\n", + " 'ml_g_d_lvl0': ml_g_d_lvl0_params,\n", + " 'ml_g_d_lvl1': ml_g_d_lvl1_params,\n", + " 'ml_m': ml_m_params\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "0f1933b3", + "metadata": {}, + "source": [ + "To tune the hyperparameters the `tune_ml_models()` with the `ml_param_space` argument should be called.\n", + "To define the number of trials and other optuna options you can use the `optuna_setttings` argument." + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "id": "66d408ab", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "7f123acd3f914b2dbb22ea4cc23a409b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/20 [00:00" + ] + }, + "execution_count": 71, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "optuna_settings = {\n", + " 'n_trials': 20,\n", + " 'show_progress_bar': True,\n", + "}\n", + "\n", + "dml_obj_tuned.tune_ml_models(\n", + " ml_param_space=param_space,\n", + " optuna_settings=optuna_settings,\n", + ")\n" + ] + }, + { + "cell_type": "markdown", + "id": "412ab2ad", + "metadata": {}, + "source": [ + "Per default, the model will set the best hyperparameters automatically (identical hyperparameters for each fold), and you can directly call the `fit()` method afterwards." + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "id": "8c0776be", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
coefstd errtP>|t|2.5 %97.5 %
d212.4199540.809782262.3174860.0210.83281214.007097
\n", + "
" + ], + "text/plain": [ + " coef std err t P>|t| 2.5 % 97.5 %\n", + "d 212.419954 0.809782 262.317486 0.0 210.83281 214.007097" + ] + }, + "execution_count": 72, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dml_obj_tuned.fit()\n", + "dml_obj_tuned.summary" + ] + }, + { + "cell_type": "markdown", + "id": "6bccb213", + "metadata": {}, + "source": [ + "### Result Comparison\n", + "\n", + "Let us compare the results for both models." + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "id": "e20b5630", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'ml_g_d_lvl0': array([[5.49395703]]),\n", + " 'ml_g_d_lvl1': array([[8.74099323]]),\n", + " 'ml_m': array([[0.37870167]])}" + ] + }, + "execution_count": 75, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dml_obj_untuned.evaluate_learners()" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "id": "c83dc661", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'ml_g_d_lvl0': array([[5.52963968]]),\n", + " 'ml_g_d_lvl1': array([[8.70845178]]),\n", + " 'ml_m': array([[0.36423921]])}" + ] + }, + "execution_count": 76, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dml_obj_tuned.evaluate_learners()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f594a9f7", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 77, + "id": "e9ec0052", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Numerical Comparison:\n", + " Model theta ci_lower ci_upper\n", + "Untuned 211.037000 204.874178 217.199821\n", + " Tuned 212.419954 210.832810 214.007097\n", + "\n", + "True APO at treatment level 1.0: 211.7858\n" + ] + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "\n", + "# Set up the color palette\n", + "palette = sns.color_palette()\n", + "\n", + "# Extract results from both models\n", + "theta_untuned = dml_obj_untuned.coef[0]\n", + "theta_tuned = dml_obj_tuned.coef[0]\n", + "ci_untuned = dml_obj_untuned.confint()\n", + "ci_tuned = dml_obj_tuned.confint()\n", + "\n", + "# Create comparison dataframe\n", + "comparison_data = {\n", + " 'Model': ['Untuned', 'Tuned'],\n", + " 'theta': [theta_untuned, theta_tuned],\n", + " 'ci_lower': [ci_untuned.iloc[0, 0], ci_tuned.iloc[0, 0]],\n", + " 'ci_upper': [ci_untuned.iloc[0, 1], ci_tuned.iloc[0, 1]]\n", + "}\n", + "df_comparison = pd.DataFrame(comparison_data)\n", + "\n", + "# Plotting\n", + "plt.figure(figsize=(10, 6))\n", + "\n", + "# Plot untuned estimate with 95% CI\n", + "plt.errorbar(0, df_comparison.loc[0, 'theta'], \n", + " yerr=[[df_comparison.loc[0, 'theta'] - df_comparison.loc[0, 'ci_lower']], \n", + " [df_comparison.loc[0, 'ci_upper'] - df_comparison.loc[0, 'theta']]], \n", + " fmt='o', capsize=5, capthick=2, ecolor=palette[1], color=palette[0], \n", + " label='Untuned', markersize=10, zorder=2)\n", + "\n", + "# Plot tuned estimate with 95% CI\n", + "plt.errorbar(1, df_comparison.loc[1, 'theta'], \n", + " yerr=[[df_comparison.loc[1, 'theta'] - df_comparison.loc[1, 'ci_lower']], \n", + " [df_comparison.loc[1, 'ci_upper'] - df_comparison.loc[1, 'theta']]], \n", + " fmt='o', capsize=5, capthick=2, ecolor=palette[3], color=palette[2], \n", + " label='Tuned', markersize=10, zorder=2)\n", + "\n", + "# Plot true APO as horizontal reference line\n", + "plt.axhline(y=apos[int(treatment_level)], color=palette[4], linestyle='--', \n", + " linewidth=2, label='True APO', zorder=1)\n", + "\n", + "plt.title(f'Estimated APO Coefficients with and without Tuning (Treatment Level = {treatment_level})')\n", + "plt.ylabel('Coefficient Value')\n", + "plt.xticks([0, 1], ['Untuned', 'Tuned'])\n", + "plt.legend()\n", + "plt.grid(True, alpha=0.3)\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "# Print numerical comparison\n", + "print(\"\\nNumerical Comparison:\")\n", + "print(df_comparison.to_string(index=False))\n", + "print(f\"\\nTrue APO at treatment level {treatment_level}: {apos[int(treatment_level)]:.4f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1b58a708", + "metadata": {}, + "outputs": [], + "source": [ + "# Plotting\n", + "plt.figure(figsize=(10, 6))\n", + "# Plot Estimate with 95% CI\n", + "plt.errorbar(df_apo_ci['treatment_level'], df_apo_ci['theta'], \n", + " yerr=[df_apo_ci['theta'] - df_apo_ci['ci_lower'], df_apo_ci['ci_upper'] - df_apo_ci['theta']], \n", + " fmt='o', capsize=5, capthick=2, ecolor=palette[1], color=palette[0], label='Estimate with 95% CI', zorder=2)\n", + "# Plot APO as a scatter plot, with zorder set to 2 to be in front\n", + "plt.scatter(df_apo_ci['treatment_level'], df_apo_ci['apo'], color=palette[2], label='APO', marker='d', zorder=3)\n", + "\n", + "plt.title('Estimated APO, Theta, and 95% Confidence Interval by Treatment Level')\n", + "plt.xlabel('Treatment Level')\n", + "plt.ylabel('Value')\n", + "plt.xticks(df_apo_ci['treatment_level'])\n", + "plt.legend()\n", + "plt.grid(True)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "4279c7a0", + "metadata": {}, + "source": [ + "## Detailed Hyperparameter Tuning Guide" + ] + }, + { + "cell_type": "markdown", + "id": "e0c8d51b", + "metadata": {}, + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "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.12.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From ff3e0e493ea076f3ccef38d741725f6c31cdb1fa Mon Sep 17 00:00:00 2001 From: SvenKlaassen Date: Thu, 13 Nov 2025 00:57:20 +0000 Subject: [PATCH 03/11] docs: add DMLOptunaResult to utility classes documentation --- doc/api/utility.rst | 1 + 1 file changed, 1 insertion(+) diff --git a/doc/api/utility.rst b/doc/api/utility.rst index f6ee96f4..811943ac 100644 --- a/doc/api/utility.rst +++ b/doc/api/utility.rst @@ -14,6 +14,7 @@ Utility Classes utils.DMLDummyRegressor utils.DMLDummyClassifier + utils.DMLOptunaResult utils.DoubleMLBLP utils.DoubleMLPolicyTree utils.GlobalRegressor From 41af05165adca78c490c984824f64664b3cf64ad Mon Sep 17 00:00:00 2001 From: SvenKlaassen Date: Thu, 13 Nov 2025 00:57:33 +0000 Subject: [PATCH 04/11] Update optuna nb --- doc/examples/learners/py_optuna.ipynb | 816 ++++++++++++++++---------- 1 file changed, 512 insertions(+), 304 deletions(-) diff --git a/doc/examples/learners/py_optuna.ipynb b/doc/examples/learners/py_optuna.ipynb index 4c503ead..df9b8b0e 100644 --- a/doc/examples/learners/py_optuna.ipynb +++ b/doc/examples/learners/py_optuna.ipynb @@ -22,7 +22,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 1, "id": "7e56470f", "metadata": {}, "outputs": [], @@ -30,12 +30,24 @@ "import optuna\n", "import numpy as np\n", "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "from plotly.io import show\n", "\n", + "from sklearn.pipeline import Pipeline\n", + "from sklearn.preprocessing import RobustScaler\n", + "from sklearn.linear_model import LinearRegression, Ridge, LogisticRegression\n", + "from sklearn.ensemble import StackingRegressor, StackingClassifier\n", "from lightgbm import LGBMRegressor, LGBMClassifier\n", "\n", "from doubleml.data import DoubleMLData\n", "from doubleml.irm import DoubleMLAPO\n", - "from doubleml.irm.datasets import make_irm_data_discrete_treatments" + "from doubleml.irm.datasets import make_irm_data_discrete_treatments\n", + "\n", + "palette = sns.color_palette(\"colorblind\")\n", + "\n", + "import warnings\n", + "warnings.filterwarnings(\"ignore\")" ] }, { @@ -60,7 +72,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 2, "id": "e246dbc8", "metadata": {}, "outputs": [ @@ -69,25 +81,24 @@ "output_type": "stream", "text": [ "Average Individual effects in each group:\n", - "[ 0. 1.75 7.03 9.43 10.4 10.49]\n", + "[ 0. 3.44 9.32 10.49]\n", "\n", "Average Potential Outcomes in each group:\n", - "[210.04 211.79 217.06 219.47 220.44 220.53]\n", + "[210.05 213.49 219.38 220.54]\n", "\n", "Levels and their counts:\n", - "(array([0., 1., 2., 3., 4., 5.]), array([615, 487, 465, 482, 480, 471]))\n" + "(array([0., 1., 2., 3.]), array([171, 110, 109, 110]))\n" ] } ], "source": [ "# Parameters\n", - "n_obs = 3000\n", - "n_levels = 5\n", - "linear = True\n", - "n_rep = 10\n", + "n_obs = 500\n", + "n_levels = 3\n", + "treatment_lvl = 1.0\n", "\n", "np.random.seed(42)\n", - "data_apo = make_irm_data_discrete_treatments(n_obs=n_obs,n_levels=n_levels, linear=linear)\n", + "data_apo = make_irm_data_discrete_treatments(n_obs=n_obs,n_levels=n_levels, linear=False)\n", "\n", "y0 = data_apo['oracle_values']['y0']\n", "cont_d = data_apo['oracle_values']['cont_d']\n", @@ -119,7 +130,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "id": "a98bf812", "metadata": {}, "outputs": [ @@ -134,14 +145,14 @@ "Treatment variable(s): ['d']\n", "Covariates: ['x0', 'x1', 'x2', 'x3', 'x4']\n", "Instrument variable(s): None\n", - "No. Observations: 3000\n", + "No. Observations: 500\n", "\n", "------------------ DataFrame info ------------------\n", "\n", - "RangeIndex: 3000 entries, 0 to 2999\n", + "RangeIndex: 500 entries, 0 to 499\n", "Columns: 7 entries, y to x4\n", "dtypes: float64(7)\n", - "memory usage: 164.2 KB\n", + "memory usage: 27.5 KB\n", "\n" ] } @@ -181,7 +192,7 @@ }, { "cell_type": "code", - "execution_count": 61, + "execution_count": 4, "id": "5ae487e1", "metadata": {}, "outputs": [], @@ -202,17 +213,7 @@ }, { "cell_type": "code", - "execution_count": 62, - "id": "86171262", - "metadata": {}, - "outputs": [], - "source": [ - "treatment_level = 1.0" - ] - }, - { - "cell_type": "code", - "execution_count": 63, + "execution_count": 5, "id": "68ea7d50", "metadata": {}, "outputs": [ @@ -248,23 +249,23 @@ " \n", " \n", " d\n", - " 211.037\n", - " 3.144354\n", - " 67.116163\n", - " 0.0\n", - " 204.874178\n", - " 217.199821\n", + " 211.232659\n", + " 15.657431\n", + " 13.490888\n", + " 1.769555e-41\n", + " 180.544657\n", + " 241.920661\n", " \n", " \n", "\n", "" ], "text/plain": [ - " coef std err t P>|t| 2.5 % 97.5 %\n", - "d 211.037 3.144354 67.116163 0.0 204.874178 217.199821" + " coef std err t P>|t| 2.5 % 97.5 %\n", + "d 211.232659 15.657431 13.490888 1.769555e-41 180.544657 241.920661" ] }, - "execution_count": 63, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -274,7 +275,7 @@ " dml_data,\n", " ml_g,\n", " ml_m,\n", - " treatment_level=treatment_level,\n", + " treatment_level=treatment_lvl,\n", ")\n", "\n", "dml_obj_untuned.fit()\n", @@ -293,7 +294,7 @@ }, { "cell_type": "code", - "execution_count": 64, + "execution_count": 6, "id": "76ff8ca0", "metadata": {}, "outputs": [], @@ -302,45 +303,22 @@ " dml_data,\n", " ml_g,\n", " ml_m,\n", - " treatment_level=treatment_level,\n", + " treatment_level=treatment_lvl,\n", ")" ] }, { "cell_type": "markdown", - "id": "3fedc3a1", - "metadata": {}, - "source": [ - "To required input for tuning is a parameter space dictionary for the hyperparameters for each learner that should be tuned.\n", - "This dictionary should include a callable for each learner you want to have. \n", - "\n", - "**Remark**: Even if the initialization only requires the learners `ml_g` and `ml_m`, the models in the `irm` submodule generally, copy the learner for `ml_g` and fit different response surfaces for treatment and control groups. These different learners should be tuned separately and require separate parameter spaces. To see which parameter spaces can be tuned you can take a look at the `params_names` property." - ] - }, - { - "cell_type": "code", - "execution_count": 57, - "id": "17fe4e01", + "id": "087a8a52", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "['ml_g_d_lvl0', 'ml_g_d_lvl1', 'ml_m']" - ] - }, - "execution_count": 57, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ - "dml_obj_tuned.params_names" + "The required input for tuning is a parameter space dictionary for the hyperparameters for each learner that should be tuned.\n", + "This dictionary should include a callable for each learner you want to have (only a subset is also possible, i.e. only tuning `ml_g`)." ] }, { "cell_type": "markdown", - "id": "ebbc62ce", + "id": "09d36a4a", "metadata": {}, "source": [ "The parameter spaces should be a callable and suggest the search spaces via a `trial` object.\n", @@ -352,22 +330,13 @@ }, { "cell_type": "code", - "execution_count": 69, - "id": "6102fe5b", + "execution_count": 7, + "id": "e74257e8", "metadata": {}, "outputs": [], "source": [ - "# parameter space for the propensity score tuning\n", - "def ml_m_params(trial):\n", - " return {\n", - " 'n_estimators': 100,\n", - " 'learning_rate': trial.suggest_float('learning_rate', 0.005, 0.1),\n", - " 'max_depth': trial.suggest_int('max_depth', 2, 5),\n", - " 'min_child_samples': trial.suggest_int('min_child_samples', 5, 100),\n", - " }\n", - "\n", - "# parameter space for the outcome regression tuning at treatment level != 1.0\n", - "def ml_g_d_lvl0_params(trial):\n", + "# parameter space for the outcome regression tuning\n", + "def ml_g_params(trial):\n", " return {\n", " 'n_estimators': 100,\n", " 'learning_rate': trial.suggest_float('learning_rate', 0.005, 0.1),\n", @@ -375,8 +344,8 @@ " 'min_child_samples': trial.suggest_int('min_child_samples', 5, 100),\n", " }\n", "\n", - "# parameter space for the outcome regression tuning at treatment level == 1.0\n", - "def ml_g_d_lvl1_params(trial):\n", + "# parameter space for the propensity score tuning\n", + "def ml_m_params(trial):\n", " return {\n", " 'n_estimators': 100,\n", " 'learning_rate': trial.suggest_float('learning_rate', 0.005, 0.1),\n", @@ -385,95 +354,55 @@ " }\n", "\n", "param_space = {\n", - " 'ml_g_d_lvl0': ml_g_d_lvl0_params,\n", - " 'ml_g_d_lvl1': ml_g_d_lvl1_params,\n", + " 'ml_g': ml_g_params,\n", " 'ml_m': ml_m_params\n", "}" ] }, { "cell_type": "markdown", - "id": "0f1933b3", + "id": "33a2ff6c", "metadata": {}, "source": [ "To tune the hyperparameters the `tune_ml_models()` with the `ml_param_space` argument should be called.\n", - "To define the number of trials and other optuna options you can use the `optuna_setttings` argument." + "Further, to define the number of trials and other optuna options you can use the `optuna_setttings` argument." ] }, { "cell_type": "code", - "execution_count": 71, - "id": "66d408ab", + "execution_count": 8, + "id": "fe81ad26", "metadata": {}, "outputs": [ { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "7f123acd3f914b2dbb22ea4cc23a409b", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/20 [00:00" - ] - }, - "execution_count": 71, - "metadata": {}, - "output_type": "execute_result" + "ename": "TypeError", + "evalue": "_dml_tune_optuna() missing 1 required positional argument: 'params_name'", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mTypeError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[8]\u001b[39m\u001b[32m, line 6\u001b[39m\n\u001b[32m 1\u001b[39m optuna_settings = {\n\u001b[32m 2\u001b[39m \u001b[33m'\u001b[39m\u001b[33mn_trials\u001b[39m\u001b[33m'\u001b[39m: \u001b[32m100\u001b[39m,\n\u001b[32m 3\u001b[39m \u001b[33m'\u001b[39m\u001b[33mshow_progress_bar\u001b[39m\u001b[33m'\u001b[39m: \u001b[38;5;28;01mTrue\u001b[39;00m,\n\u001b[32m 4\u001b[39m }\n\u001b[32m----> \u001b[39m\u001b[32m6\u001b[39m \u001b[43mdml_obj_tuned\u001b[49m\u001b[43m.\u001b[49m\u001b[43mtune_ml_models\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 7\u001b[39m \u001b[43m \u001b[49m\u001b[43mml_param_space\u001b[49m\u001b[43m=\u001b[49m\u001b[43mparam_space\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 8\u001b[39m \u001b[43m \u001b[49m\u001b[43moptuna_settings\u001b[49m\u001b[43m=\u001b[49m\u001b[43moptuna_settings\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 9\u001b[39m \u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/.venv/lib/python3.12/site-packages/doubleml/double_ml.py:1119\u001b[39m, in \u001b[36mDoubleML.tune_ml_models\u001b[39m\u001b[34m(self, ml_param_space, scoring_methods, cv, set_as_params, return_tune_res, optuna_settings)\u001b[39m\n\u001b[32m 1116\u001b[39m \u001b[38;5;28mself\u001b[39m._dml_data.set_x_d(\u001b[38;5;28mself\u001b[39m._dml_data.d_cols[i_d])\n\u001b[32m 1118\u001b[39m \u001b[38;5;66;03m# tune hyperparameters (globally, not fold-specific)\u001b[39;00m\n\u001b[32m-> \u001b[39m\u001b[32m1119\u001b[39m res = \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_nuisance_tuning_optuna\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 1120\u001b[39m \u001b[43m \u001b[49m\u001b[43mexpanded_param_space\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1121\u001b[39m \u001b[43m \u001b[49m\u001b[43mscoring_methods\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1122\u001b[39m \u001b[43m \u001b[49m\u001b[43mcv_splitter\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1123\u001b[39m \u001b[43m \u001b[49m\u001b[43moptuna_settings\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1124\u001b[39m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 1126\u001b[39m filtered_results = {key: value \u001b[38;5;28;01mfor\u001b[39;00m key, value \u001b[38;5;129;01min\u001b[39;00m res.items() \u001b[38;5;28;01mif\u001b[39;00m key \u001b[38;5;129;01min\u001b[39;00m requested_learners}\n\u001b[32m 1127\u001b[39m tuning_res[i_d] = filtered_results\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/.venv/lib/python3.12/site-packages/doubleml/irm/apo.py:484\u001b[39m, in \u001b[36mDoubleMLAPO._nuisance_tuning_optuna\u001b[39m\u001b[34m(self, optuna_params, scoring_methods, cv, optuna_settings)\u001b[39m\n\u001b[32m 482\u001b[39m g_lvl0_param_grid = optuna_params[\u001b[33m\"\u001b[39m\u001b[33mml_g_d_lvl0\u001b[39m\u001b[33m\"\u001b[39m]\n\u001b[32m 483\u001b[39m g_lvl0_scoring = scoring_methods[\u001b[33m\"\u001b[39m\u001b[33mml_g_d_lvl0\u001b[39m\u001b[33m\"\u001b[39m]\n\u001b[32m--> \u001b[39m\u001b[32m484\u001b[39m g_d_lvl0_tune_res = \u001b[43m_dml_tune_optuna\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 485\u001b[39m \u001b[43m \u001b[49m\u001b[43my_lvl0\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 486\u001b[39m \u001b[43m \u001b[49m\u001b[43mdx_lvl0\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 487\u001b[39m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_learner\u001b[49m\u001b[43m[\u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43mml_g\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 488\u001b[39m \u001b[43m \u001b[49m\u001b[43mg_lvl0_param_grid\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 489\u001b[39m \u001b[43m \u001b[49m\u001b[43mg_lvl0_scoring\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 490\u001b[39m \u001b[43m \u001b[49m\u001b[43mcv\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 491\u001b[39m \u001b[43m \u001b[49m\u001b[43moptuna_settings\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 492\u001b[39m \u001b[43m \u001b[49m\u001b[43mlearner_name\u001b[49m\u001b[43m=\u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43mml_g_d_lvl0\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[32m 493\u001b[39m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 495\u001b[39m x_lvl1 = x[mask_lvl1, :]\n\u001b[32m 496\u001b[39m y_lvl1 = y[mask_lvl1]\n", + "\u001b[31mTypeError\u001b[39m: _dml_tune_optuna() missing 1 required positional argument: 'params_name'" + ] } ], "source": [ "optuna_settings = {\n", - " 'n_trials': 20,\n", + " 'n_trials': 100,\n", " 'show_progress_bar': True,\n", "}\n", "\n", "dml_obj_tuned.tune_ml_models(\n", " ml_param_space=param_space,\n", " optuna_settings=optuna_settings,\n", - ")\n" + ")" ] }, { "cell_type": "markdown", - "id": "412ab2ad", + "id": "f345dc41", "metadata": {}, "source": [ "Per default, the model will set the best hyperparameters automatically (identical hyperparameters for each fold), and you can directly call the `fit()` method afterwards." @@ -481,63 +410,9 @@ }, { "cell_type": "code", - "execution_count": 72, - "id": "8c0776be", + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
coefstd errtP>|t|2.5 %97.5 %
d212.4199540.809782262.3174860.0210.83281214.007097
\n", - "
" - ], - "text/plain": [ - " coef std err t P>|t| 2.5 % 97.5 %\n", - "d 212.419954 0.809782 262.317486 0.0 210.83281 214.007097" - ] - }, - "execution_count": 72, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "dml_obj_tuned.fit()\n", "dml_obj_tuned.summary" @@ -545,106 +420,87 @@ }, { "cell_type": "markdown", - "id": "6bccb213", + "id": "db48b7d7", "metadata": {}, "source": [ - "### Result Comparison\n", + "**Remark**: Even if the initialization and tuning only requires the learners `ml_g` and `ml_m`, the models in the `irm` submodule generally, copy the learner for `ml_g` and fit different response surfaces for treatment and control (or not-treatment) groups. These different learners are tuned separately but with the same parameter space. To see which parameter spaces can be tuned you can take a look at the `params_names` property.\n", "\n", - "Let us compare the results for both models." + "In this example, we specified the parameter spaces for `ml_m` and `ml_g`, but actually three sets of hyperparameters were tuned, i.e. `ml_m`, `ml_g_d_lvl0` and `ml_g_d_lvl1` (two response surfaces for the outcome)." ] }, { "cell_type": "code", - "execution_count": 75, - "id": "e20b5630", + "execution_count": null, + "id": "31a70f0a", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'ml_g_d_lvl0': array([[5.49395703]]),\n", - " 'ml_g_d_lvl1': array([[8.74099323]]),\n", - " 'ml_m': array([[0.37870167]])}" - ] - }, - "execution_count": 75, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "dml_obj_untuned.evaluate_learners()" + "dml_obj_tuned.params_names" + ] + }, + { + "cell_type": "markdown", + "id": "3b6aa5f6", + "metadata": {}, + "source": [ + "Each hyperparameter combination is set for each fold." ] }, { "cell_type": "code", - "execution_count": 76, - "id": "c83dc661", + "execution_count": null, + "id": "35aaf050", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'ml_g_d_lvl0': array([[5.52963968]]),\n", - " 'ml_g_d_lvl1': array([[8.70845178]]),\n", - " 'ml_m': array([[0.36423921]])}" - ] - }, - "execution_count": 76, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "dml_obj_tuned.evaluate_learners()" + "dml_obj_tuned.params" + ] + }, + { + "cell_type": "markdown", + "id": "6bccb213", + "metadata": {}, + "source": [ + "### Comparison\n", + " \n", + "Let us compare the results for both models. If we take a look at the predictive performance of the learners, the main difference can be observed in the log loss of the propensity score `ml_m`" ] }, { "cell_type": "code", "execution_count": null, - "id": "f594a9f7", + "id": "20a95719", "metadata": {}, "outputs": [], - "source": [] + "source": [ + "dml_obj_untuned.evaluate_learners()" + ] }, { "cell_type": "code", - "execution_count": 77, - "id": "e9ec0052", + "execution_count": null, + "id": "68e08448", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Numerical Comparison:\n", - " Model theta ci_lower ci_upper\n", - "Untuned 211.037000 204.874178 217.199821\n", - " Tuned 212.419954 210.832810 214.007097\n", - "\n", - "True APO at treatment level 1.0: 211.7858\n" - ] - } - ], + "outputs": [], + "source": [ + "dml_obj_tuned.evaluate_learners()" + ] + }, + { + "cell_type": "markdown", + "id": "3b58e994", + "metadata": {}, + "source": [ + "As a result the standard error is reduced and confidence intervals are much tighter." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f594a9f7", + "metadata": {}, + "outputs": [], "source": [ - "import matplotlib.pyplot as plt\n", - "import seaborn as sns\n", - "\n", - "# Set up the color palette\n", - "palette = sns.color_palette()\n", - "\n", - "# Extract results from both models\n", "theta_untuned = dml_obj_untuned.coef[0]\n", "theta_tuned = dml_obj_tuned.coef[0]\n", "ci_untuned = dml_obj_untuned.confint()\n", @@ -659,79 +515,431 @@ "}\n", "df_comparison = pd.DataFrame(comparison_data)\n", "\n", - "# Plotting\n", - "plt.figure(figsize=(10, 6))\n", + "print(f\"\\nTrue APO at treatment level {treatment_lvl}: {apos[int(treatment_lvl)]:.4f}\\n\")\n", + "print(df_comparison.to_string(index=False))\n", "\n", - "# Plot untuned estimate with 95% CI\n", + "plt.figure(figsize=(10, 6))\n", "plt.errorbar(0, df_comparison.loc[0, 'theta'], \n", " yerr=[[df_comparison.loc[0, 'theta'] - df_comparison.loc[0, 'ci_lower']], \n", " [df_comparison.loc[0, 'ci_upper'] - df_comparison.loc[0, 'theta']]], \n", - " fmt='o', capsize=5, capthick=2, ecolor=palette[1], color=palette[0], \n", + " fmt='o', capsize=5, capthick=2, ecolor=palette[0], color=palette[0], \n", " label='Untuned', markersize=10, zorder=2)\n", - "\n", - "# Plot tuned estimate with 95% CI\n", "plt.errorbar(1, df_comparison.loc[1, 'theta'], \n", " yerr=[[df_comparison.loc[1, 'theta'] - df_comparison.loc[1, 'ci_lower']], \n", " [df_comparison.loc[1, 'ci_upper'] - df_comparison.loc[1, 'theta']]], \n", - " fmt='o', capsize=5, capthick=2, ecolor=palette[3], color=palette[2], \n", + " fmt='o', capsize=5, capthick=2, ecolor=palette[1], color=palette[1], \n", " label='Tuned', markersize=10, zorder=2)\n", - "\n", - "# Plot true APO as horizontal reference line\n", - "plt.axhline(y=apos[int(treatment_level)], color=palette[4], linestyle='--', \n", + "plt.axhline(y=apos[int(treatment_lvl)], color=palette[4], linestyle='--', \n", " linewidth=2, label='True APO', zorder=1)\n", "\n", - "plt.title(f'Estimated APO Coefficients with and without Tuning (Treatment Level = {treatment_level})')\n", + "plt.title(f'Estimated APO Coefficients with and without Tuning for Treatment Level {treatment_lvl}')\n", "plt.ylabel('Coefficient Value')\n", "plt.xticks([0, 1], ['Untuned', 'Tuned'])\n", "plt.legend()\n", "plt.grid(True, alpha=0.3)\n", "plt.tight_layout()\n", - "plt.show()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "4279c7a0", + "metadata": {}, + "source": [ + "## Detailed Hyperparameter Tuning Guide\n", "\n", - "# Print numerical comparison\n", - "print(\"\\nNumerical Comparison:\")\n", - "print(df_comparison.to_string(index=False))\n", - "print(f\"\\nTrue APO at treatment level {treatment_level}: {apos[int(treatment_level)]:.4f}\")" + "In this section, we explore tuning options in more detail and employ a more complicated learning pipeline." + ] + }, + { + "cell_type": "markdown", + "id": "86c7d75f", + "metadata": {}, + "source": [ + "### Define Nuisance Learners\n", + "\n", + "For our example, we will choose [Pipelines](https://scikit-learn.org/stable/modules/compose.html#pipeline) to generate a complex [StackingRegressor](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.StackingRegressor.html) or [StackingClassifier](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.StackingClassifier.html)." ] }, { "cell_type": "code", "execution_count": null, - "id": "1b58a708", + "id": "76937e73", "metadata": {}, "outputs": [], "source": [ - "# Plotting\n", - "plt.figure(figsize=(10, 6))\n", - "# Plot Estimate with 95% CI\n", - "plt.errorbar(df_apo_ci['treatment_level'], df_apo_ci['theta'], \n", - " yerr=[df_apo_ci['theta'] - df_apo_ci['ci_lower'], df_apo_ci['ci_upper'] - df_apo_ci['theta']], \n", - " fmt='o', capsize=5, capthick=2, ecolor=palette[1], color=palette[0], label='Estimate with 95% CI', zorder=2)\n", - "# Plot APO as a scatter plot, with zorder set to 2 to be in front\n", - "plt.scatter(df_apo_ci['treatment_level'], df_apo_ci['apo'], color=palette[2], label='APO', marker='d', zorder=3)\n", - "\n", - "plt.title('Estimated APO, Theta, and 95% Confidence Interval by Treatment Level')\n", - "plt.xlabel('Treatment Level')\n", - "plt.ylabel('Value')\n", - "plt.xticks(df_apo_ci['treatment_level'])\n", + "base_regressors = [\n", + " ('linear_regression', LinearRegression()),\n", + " ('lgbm', LGBMRegressor(random_state=42, verbose=-1))\n", + "]\n", + "\n", + "stacking_regressor = StackingRegressor(\n", + " estimators=base_regressors,\n", + " final_estimator=Ridge()\n", + ")\n", + "\n", + "ml_g_pipeline = Pipeline([\n", + " ('scaler', RobustScaler()),\n", + " ('stacking', stacking_regressor)\n", + "])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "395bb00f", + "metadata": {}, + "outputs": [], + "source": [ + "base_classifiers = [\n", + " ('logistic_regression', LogisticRegression(max_iter=1000, random_state=42)),\n", + " ('lgbm', LGBMClassifier(random_state=42, verbose=-1))\n", + "]\n", + "\n", + "stacking_classifier = StackingClassifier(\n", + " estimators=base_classifiers,\n", + " final_estimator=LogisticRegression(),\n", + ")\n", + "\n", + "ml_m_pipeline = Pipeline([\n", + " ('scaler', RobustScaler()),\n", + " ('stacking', stacking_classifier)\n", + "])" + ] + }, + { + "cell_type": "markdown", + "id": "d49756f0", + "metadata": {}, + "source": [ + "### Untuned Model with Pipeline\n", + "\n", + "Now let us take a look at the standard workflow, focusing on a single treatment level and using default hyperparameters." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cbf47ae5", + "metadata": {}, + "outputs": [], + "source": [ + "dml_obj_untuned_pipeline = DoubleMLAPO(\n", + " dml_data,\n", + " ml_g_pipeline,\n", + " ml_m_pipeline,\n", + " treatment_level=treatment_lvl,\n", + ")\n", + "\n", + "dml_obj_untuned_pipeline.fit()\n", + "dml_obj_untuned_pipeline.summary" + ] + }, + { + "cell_type": "markdown", + "id": "fb8fb3b6", + "metadata": {}, + "source": [ + "### Hyperparametertuning with Pipelines\n", + "\n", + "Now, let us take a look at more complex. Again, we will initialize a separate model to compare the results." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c33bf5f1", + "metadata": {}, + "outputs": [], + "source": [ + "dml_obj_tuned_pipeline = DoubleMLAPO(\n", + " dml_data,\n", + " ml_g_pipeline,\n", + " ml_m_pipeline,\n", + " treatment_level=treatment_lvl,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "ea0febfc", + "metadata": {}, + "source": [ + "As before the tuning input is a parameter space dictionary for the hyperparameters for each learner that should be tuned.\n", + "This dictionary should include a callable for each learner you want to have (only a subset is also possible, i.e. only tuning `ml_g`).\n", + "\n", + "Since we have now a much more complicated learner the tuning inputs have to passed correctly into the pipeline." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d88d60a0", + "metadata": {}, + "outputs": [], + "source": [ + "# parameter space for the outcome regression tuning\n", + "def ml_g_params_pipeline(trial):\n", + " return {\n", + " 'stacking__lgbm__n_estimators': 100,\n", + " 'stacking__lgbm__learning_rate': trial.suggest_float('learning_rate', 0.005, 0.1),\n", + " 'stacking__lgbm__max_depth': trial.suggest_int('max_depth', 2, 5),\n", + " 'stacking__lgbm__min_child_samples': trial.suggest_int('min_child_samples', 5, 100),\n", + " 'stacking__final_estimator__alpha': trial.suggest_float('alpha', 0.001, 10.0, log=True),\n", + " }\n", + "\n", + "# parameter space for the propensity score tuning\n", + "def ml_m_params_pipeline(trial):\n", + " return {\n", + " 'stacking__lgbm__n_estimators': 100,\n", + " 'stacking__lgbm__learning_rate': trial.suggest_float('learning_rate', 0.005, 0.1),\n", + " 'stacking__lgbm__max_depth': trial.suggest_int('max_depth', 2, 5),\n", + " 'stacking__lgbm__min_child_samples': trial.suggest_int('min_child_samples', 5, 100),\n", + " 'stacking__final_estimator__C': trial.suggest_float('C', 0.01, 100.0, log=True),\n", + " 'stacking__final_estimator__max_iter': 1000,\n", + " }\n", + "\n", + "param_space_pipeline = {\n", + " 'ml_g': ml_g_params_pipeline,\n", + " 'ml_m': ml_m_params_pipeline\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "6cf12fb1", + "metadata": {}, + "source": [ + "As before, we can pass the arguments for optuna via `optuna_settings`. For possible option please take a look at the [Optuna Documenation](https://optuna.readthedocs.io/en/stable/index.html). For each learner you can pass local settings which will override the settings.\n", + "\n", + "Here, we will reduce the number of trials for `ml_g` as it did already perform quite well before.\n", + "In principle, we could also use different [samplers](https://optuna.readthedocs.io/en/stable/reference/samplers/index.html), but generally we recommend to use the [TPESampler](https://optuna.readthedocs.io/en/stable/reference/samplers/generated/optuna.samplers.TPESampler.html), which is used by default." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "vscode": { + "languageId": "javascript" + } + }, + "outputs": [], + "source": [ + "optuna_settings_pipeline = {\n", + " 'n_trials': 100,\n", + " 'show_progress_bar': True,\n", + " 'ml_g': {\n", + " 'n_trials': 50\n", + " }\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "aca5cc9a", + "metadata": {}, + "source": [ + "As before, we can tune the hyperparameters via the `tune_ml_models()` method. If we would like to inspect the optuna.study results, we can return all tuning results via the `return_tune_res` argument.\n", + "\n", + "We will have a detailed look at the returned results later in the notebook." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8468d9fd", + "metadata": {}, + "outputs": [], + "source": [ + "tuning_results = dml_obj_tuned.tune_ml_models(\n", + " ml_param_space=param_space_pipeline,\n", + " optuna_settings=optuna_settings_pipeline,\n", + " return_tune_res=True,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "00dd3f7d", + "metadata": {}, + "outputs": [], + "source": [ + "dml_obj_tuned_pipeline.fit()\n", + "dml_obj_tuned_pipeline.summary" + ] + }, + { + "cell_type": "markdown", + "id": "c4037bd4", + "metadata": {}, + "source": [ + "**Remark**: All settings (`optuna_settings` and `ml_param_space`) can also be set on the `params_names` level instead of the `learner_names` level, i.e. `ml_g_d_lvl1` instead of `ml_g`. Generally, more specific settings will override more general settings." + ] + }, + { + "cell_type": "markdown", + "id": "e24e73bb", + "metadata": {}, + "source": [ + "### Comparison" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "deb5359c", + "metadata": {}, + "outputs": [], + "source": [ + "# Extract coefficients and confidence intervals for all models\n", + "theta_untuned = dml_obj_untuned.coef[0]\n", + "theta_tuned = dml_obj_tuned.coef[0]\n", + "theta_untuned_pipeline = dml_obj_untuned_pipeline.coef[0]\n", + "theta_tuned_pipeline = dml_obj_tuned_pipeline.coef[0]\n", + "\n", + "ci_untuned = dml_obj_untuned.confint()\n", + "ci_tuned = dml_obj_tuned.confint()\n", + "ci_untuned_pipeline = dml_obj_untuned_pipeline.confint()\n", + "ci_tuned_pipeline = dml_obj_tuned_pipeline.confint()\n", + "\n", + "# Create comparison dataframe\n", + "comparison_data = {\n", + " 'Model': ['Untuned', 'Tuned', 'Untuned Pipeline', 'Tuned Pipeline'],\n", + " 'theta': [theta_untuned, theta_tuned, theta_untuned_pipeline, theta_tuned_pipeline],\n", + " 'ci_lower': [ci_untuned.iloc[0, 0], ci_tuned.iloc[0, 0], \n", + " ci_untuned_pipeline.iloc[0, 0], ci_tuned_pipeline.iloc[0, 0]],\n", + " 'ci_upper': [ci_untuned.iloc[0, 1], ci_tuned.iloc[0, 1],\n", + " ci_untuned_pipeline.iloc[0, 1], ci_tuned_pipeline.iloc[0, 1]]\n", + "}\n", + "df_comparison = pd.DataFrame(comparison_data)\n", + "\n", + "print(f\"\\nTrue APO at treatment level {treatment_lvl}: {apos[int(treatment_lvl)]:.4f}\\n\")\n", + "print(df_comparison.to_string(index=False))\n", + "\n", + "# Create plot with all 4 models\n", + "plt.figure(figsize=(12, 6))\n", + "\n", + "for i in range(len(df_comparison)):\n", + " plt.errorbar(i, df_comparison.loc[i, 'theta'], \n", + " yerr=[[df_comparison.loc[i, 'theta'] - df_comparison.loc[i, 'ci_lower']], \n", + " [df_comparison.loc[i, 'ci_upper'] - df_comparison.loc[i, 'theta']]], \n", + " fmt='o', capsize=5, capthick=2, ecolor=palette[i], color=palette[i], \n", + " label=df_comparison.loc[i, 'Model'], markersize=10, zorder=2)\n", + "\n", + "plt.axhline(y=apos[int(treatment_lvl)], color=palette[4], linestyle='--', \n", + " linewidth=2, label='True APO', zorder=1)\n", + "\n", + "plt.title('Estimated APO Coefficients: Comparison Across All Models')\n", + "plt.ylabel('Coefficient Value')\n", + "plt.xticks(range(4), df_comparison['Model'], rotation=15, ha='right')\n", "plt.legend()\n", - "plt.grid(True)\n", + "plt.grid(True, alpha=0.3)\n", + "plt.tight_layout()\n", "plt.show()" ] }, { "cell_type": "markdown", - "id": "4279c7a0", + "id": "e0c8d51b", + "metadata": {}, + "source": [ + "### Detailed Tuning Result Analysis\n", + "\n", + "The `tune_ml_models()` method creates several [Optuna Studies](https://optuna.readthedocs.io/en/stable/reference/study.html), which can be inspected in detail via the returned results.\n", + "\n", + "The results are a list of dictionaries, which contain a corresponding `DMLOptunaResult` for each treatment variable on the `param_names` level, i.e. for each [Optuna Study](https://optuna.readthedocs.io/en/stable/reference/study.html) object a separate `DMLOptunaResult` is constructed." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "41cbd33f", + "metadata": {}, + "outputs": [], + "source": [ + "# Optuna results for the single treatment\n", + "print(tuning_results[0])" + ] + }, + { + "cell_type": "markdown", + "id": "45acd97b", + "metadata": {}, + "source": [ + "In this example, we take a more detailed look in the tuning of `ml_m`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "94e92730", "metadata": {}, + "outputs": [], "source": [ - "## Detailed Hyperparameter Tuning Guide" + "print(tuning_results[0]['ml_m'])" ] }, { "cell_type": "markdown", - "id": "e0c8d51b", + "id": "d85cfecd", + "metadata": {}, + "source": [ + "As we have access to the saved [Optuna Study](https://optuna.readthedocs.io/en/stable/reference/study.html) object, it is possible to access all trials and hyperparameter combinations" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fe4c6e84", "metadata": {}, - "source": [] + "outputs": [], + "source": [ + "ml_m_study = tuning_results[0]['ml_m'].study_\n", + "ml_m_study.trials_dataframe()" + ] + }, + { + "cell_type": "markdown", + "id": "047f6d0f", + "metadata": {}, + "source": [ + " Additionally, we can access all [Optuna visualization options](https://optuna.readthedocs.io/en/stable/reference/visualization/index.html)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7d35c2c0", + "metadata": {}, + "outputs": [], + "source": [ + "fig = optuna.visualization.plot_optimization_history(ml_m_study)\n", + "show(fig)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f97a88d6", + "metadata": {}, + "outputs": [], + "source": [ + "fig = optuna.visualization.plot_parallel_coordinate(ml_m_study)\n", + "show(fig)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e7b5f011", + "metadata": {}, + "outputs": [], + "source": [ + "fig = optuna.visualization.plot_param_importances(ml_m_study)\n", + "show(fig)" + ] } ], "metadata": { From 97273080fabb20cf3bf1c4b822d4739ef83fe21c Mon Sep 17 00:00:00 2001 From: SvenKlaassen Date: Sun, 16 Nov 2025 13:02:14 +0000 Subject: [PATCH 05/11] split up learner guide --- doc/guide/learners.rst | 768 +----------------- .../learners/python/evaluate_learners.rst | 59 ++ doc/guide/learners/python/external_preds.rst | 68 ++ .../learners/python/learners_overview.inc | 38 + doc/guide/learners/python/minimum_req.rst | 14 + doc/guide/learners/python/set_hyperparams.rst | 61 ++ .../learners/python/tune_hyperparams.rst | 83 ++ doc/guide/learners/r/learners_overview.inc | 39 + doc/guide/learners/r/minimum_req.rst | 23 + doc/guide/learners/r/pipelines.rst | 59 ++ doc/guide/learners/r/set_hyperparams.rst | 130 +++ doc/guide/learners/r/tune_and_pipelines.rst | 61 ++ doc/guide/learners/r/tune_hyperparams.rst | 177 ++++ 13 files changed, 814 insertions(+), 766 deletions(-) create mode 100644 doc/guide/learners/python/evaluate_learners.rst create mode 100644 doc/guide/learners/python/external_preds.rst create mode 100644 doc/guide/learners/python/learners_overview.inc create mode 100644 doc/guide/learners/python/minimum_req.rst create mode 100644 doc/guide/learners/python/set_hyperparams.rst create mode 100644 doc/guide/learners/python/tune_hyperparams.rst create mode 100644 doc/guide/learners/r/learners_overview.inc create mode 100644 doc/guide/learners/r/minimum_req.rst create mode 100644 doc/guide/learners/r/pipelines.rst create mode 100644 doc/guide/learners/r/set_hyperparams.rst create mode 100644 doc/guide/learners/r/tune_and_pipelines.rst create mode 100644 doc/guide/learners/r/tune_hyperparams.rst diff --git a/doc/guide/learners.rst b/doc/guide/learners.rst index bb34f239..4489e545 100644 --- a/doc/guide/learners.rst +++ b/doc/guide/learners.rst @@ -16,778 +16,14 @@ separately for :ref:`Python ` and :ref:`R `. Python: Learners and hyperparameters ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -Minimum requirements for learners -################################# +.. include:: learners/python/learners_overview.inc -The minimum requirement for a learner to be used for nuisance models in the :ref:`DoubleML ` -package is - -* The implementation of a ``fit()`` and ``predict()`` method. - Some models, like :py:class:`doubleml.DoubleMLIRM` and :py:class:`doubleml.DoubleMLIIVM` require classifiers. -* In case of classifiers, the learner needs to come with a ``predict_proba()`` instead of, or in addition to, a - ``predict()`` method, see for example :py:meth:`sklearn.ensemble.RandomForestClassifier.predict_proba`. -* In order to be able to use the ``set_ml_nuisance_params()`` method of :ref:`DoubleML ` classes the - learner additionally needs to come with a ``set_params()`` method, - see for example :py:meth:`sklearn.ensemble.RandomForestRegressor.set_params`. -* We further rely on the function :py:func:`sklearn.base.clone` which adds the requirement of a ``get_params()`` - method for a learner in order to be used for nuisance models of :ref:`DoubleML ` model classes. - -Most learners from `scikit-learn `_ satisfy all these minimum requirements. - -Specifying learners and set hyperparameters -########################################### - -The learners are set during initialization of the :ref:`DoubleML ` model classes -:py:class:`doubleml.DoubleMLPLR`, :py:class:`doubleml.DoubleMLPLIV`, -:py:class:`doubleml.DoubleMLIRM` and :py:class:`doubleml.DoubleMLIIVM`. -Lets simulate some data and consider the partially linear regression model. -We need to specify learners for the nuisance functions :math:`g_0(X) = E[Y|X]` and :math:`m_0(X) = E[D|X]`, -for example :py:class:`sklearn.ensemble.RandomForestRegressor`. - -.. tab-set:: - - .. tab-item:: Python - :sync: py - - .. ipython:: python - - import doubleml as dml - from doubleml.plm.datasets import make_plr_CCDDHNR2018 - from sklearn.ensemble import RandomForestRegressor - - np.random.seed(1234) - ml_l = RandomForestRegressor() - ml_m = RandomForestRegressor() - data = make_plr_CCDDHNR2018(alpha=0.5, return_type='DataFrame') - obj_dml_data = dml.DoubleMLData(data, 'y', 'd') - dml_plr_obj = dml.DoubleMLPLR(obj_dml_data, ml_l, ml_m) - dml_plr_obj.fit().summary - -Without further specification of the hyperparameters, default values are used. To set hyperparameters: - -* We can also use pre-parametrized learners, like ``RandomForestRegressor(n_estimators=10)``. -* Alternatively, hyperparameters can also be set after initialization via the method - ``set_ml_nuisance_params(learner, treat_var, params)`` - - -.. tab-set:: - - .. tab-item:: Python - :sync: py - - .. ipython:: python - - np.random.seed(1234) - dml_plr_obj = dml.DoubleMLPLR(obj_dml_data, - RandomForestRegressor(n_estimators=10), - RandomForestRegressor()) - print(dml_plr_obj.fit().summary) - - np.random.seed(1234) - dml_plr_obj = dml.DoubleMLPLR(obj_dml_data, - RandomForestRegressor(), - RandomForestRegressor()) - dml_plr_obj.set_ml_nuisance_params('ml_l', 'd', {'n_estimators': 10}); - print(dml_plr_obj.fit().summary) - -Setting treatment-variable-specific or fold-specific hyperparameters: - -* In the multiple-treatment case, the method ``set_ml_nuisance_params(learner, treat_var, params)`` can be used to set - different hyperparameters for different treatment variables. -* The method ``set_ml_nuisance_params(learner, treat_var, params)`` accepts dicts and lists for ``params``. - A dict should be provided if for each fold the same hyperparameters should be used. - Fold-specific parameters are supported. To do so, provide a nested list as ``params``, where the outer list is of - length ``n_rep`` and the inner list of length ``n_folds``. - - -Hyperparameter tuning -##################### - -Parameter tuning of learners for the nuisance functions of :ref:`DoubleML ` models can be done via -the ``tune()`` method. -To illustrate the parameter tuning, we generate data from a sparse partially linear regression model. - -.. tab-set:: - - .. tab-item:: Python - :sync: py - - .. ipython:: python - - import doubleml as dml - import numpy as np - - np.random.seed(3141) - n_obs = 200 - n_vars = 200 - theta = 3 - X = np.random.normal(size=(n_obs, n_vars)) - d = np.dot(X[:, :3], np.array([5, 5, 5])) + np.random.standard_normal(size=(n_obs,)) - y = theta * d + np.dot(X[:, :3], np.array([5, 5, 5])) + np.random.standard_normal(size=(n_obs,)) - dml_data = dml.DoubleMLData.from_arrays(X, y, d) - -The hyperparameter-tuning is performed using either an exhaustive search over specified parameter values -implemented in :class:`sklearn.model_selection.GridSearchCV` or via a randomized search implemented in -:class:`sklearn.model_selection.RandomizedSearchCV`. - -.. tab-set:: - - .. tab-item:: Python - :sync: py - - .. ipython:: python - - import doubleml as dml - from sklearn.linear_model import Lasso - - ml_l = Lasso() - ml_m = Lasso() - dml_plr_obj = dml.DoubleMLPLR(dml_data, ml_l, ml_m) - par_grids = {'ml_l': {'alpha': np.arange(0.05, 1., 0.1)}, - 'ml_m': {'alpha': np.arange(0.05, 1., 0.1)}} - dml_plr_obj.tune(par_grids, search_mode='grid_search'); - print(dml_plr_obj.params) - print(dml_plr_obj.fit().summary) - - np.random.seed(1234) - par_grids = {'ml_l': {'alpha': np.arange(0.05, 1., 0.01)}, - 'ml_m': {'alpha': np.arange(0.05, 1., 0.01)}} - dml_plr_obj.tune(par_grids, search_mode='randomized_search', n_iter_randomized_search=20); - print(dml_plr_obj.params) - print(dml_plr_obj.fit().summary) - -Hyperparameter tuning can also be done with more sophisticated methods, like for example an iterative fitting along -a regularization path implemented in :py:class:`sklearn.linear_model.LassoCV`. -In this case the tuning should be done externally and the parameters can then be set via the -``set_ml_nuisance_params()`` method. - -.. tab-set:: - - .. tab-item:: Python - :sync: py - - .. ipython:: python - - import doubleml as dml - from sklearn.linear_model import LassoCV - - np.random.seed(1234) - ml_l_tune = LassoCV().fit(dml_data.x, dml_data.y) - ml_m_tune = LassoCV().fit(dml_data.x, dml_data.d) - - ml_l = Lasso() - ml_m = Lasso() - dml_plr_obj = dml.DoubleMLPLR(dml_data, ml_l, ml_m) - dml_plr_obj.set_ml_nuisance_params('ml_l', 'd', {'alpha': ml_l_tune.alpha_}); - dml_plr_obj.set_ml_nuisance_params('ml_m', 'd', {'alpha': ml_m_tune.alpha_}); - print(dml_plr_obj.params) - print(dml_plr_obj.fit().summary) - - -.. TODO: Also discuss other specification options like `tune_on_folds` or `scoring_methods`. - -.. _eval_learners: - -Evaluate learners -################# - -To compare different learners it is possible to evaluate the out-of-sample performance of each learner. The ``summary`` -already displays either the root-mean-squared error (for regressions) or log-loss (for classifications) for each learner -and each corresponding repetition of cross-fitting (``n_rep`` argument). - -To illustrate the parameter tuning, we work with the following example. - -.. tab-set:: - - .. tab-item:: Python - :sync: py - - .. ipython:: python - - import doubleml as dml - from doubleml.plm.datasets import make_plr_CCDDHNR2018 - from sklearn.ensemble import RandomForestRegressor - - np.random.seed(1234) - ml_l = RandomForestRegressor() - ml_m = RandomForestRegressor() - data = make_plr_CCDDHNR2018(alpha=0.5, return_type='DataFrame') - obj_dml_data = dml.DoubleMLData(data, 'y', 'd') - dml_plr_obj = dml.DoubleMLPLR(obj_dml_data, ml_l, ml_m) - dml_plr_obj.fit() - print(dml_plr_obj) - -The loss of each learner are also stored in the ``nuisance_loss`` attribute. -Further, the ``evaluate_learners()`` method allows to evalute customized evaluation metrics as e.g. the mean absolute error. -The default option is still the root-mean-squared error for evaluation. - -.. tab-set:: - - .. tab-item:: Python - :sync: py - - .. ipython:: python - - print(dml_plr_obj.nuisance_loss) - print(dml_plr_obj.evaluate_learners()) - -To evaluate a customized metric one has to define a ``callable``. For some models (e.g. the IRM model) it is important that -the metric can handle ``nan`` values as not all target values are known. - -.. tab-set:: - - .. tab-item:: Python - :sync: py - - .. ipython:: python - - from sklearn.metrics import mean_absolute_error - - def mae(y_true, y_pred): - subset = np.logical_not(np.isnan(y_true)) - return mean_absolute_error(y_true[subset], y_pred[subset]) - - dml_plr_obj.evaluate_learners(learners=['ml_l'], metric=mae) - -A more detailed notebook on the choice of learners is available in the :ref:`example gallery `. - -.. _ext_pred: - -Advanced: External Predictions -############################## - -Since there might be cases where the user wants to use a learner that is not supported by :ref:`DoubleML ` -or do some extensive hyperparameter tuning, it is possible to use external predictions for the nuisance functions. -Remark that this requires the user to take care of the cross-fitting procedure and learner evaluation. - -To illustrate the use of external predictions, we work with the following example. - -.. tab-set:: - - .. tab-item:: Python - :sync: py - - .. ipython:: python - - import numpy as np - import doubleml as dml - from doubleml.irm.datasets import make_irm_data - from sklearn.ensemble import RandomForestRegressor, RandomForestClassifier - - np.random.seed(3333) - data = make_irm_data(theta=0.5, n_obs=500, dim_x=10, return_type='DataFrame') - obj_dml_data = dml.DoubleMLData(data, 'y', 'd') - - # DoubleML with interal predictions - ml_g = RandomForestRegressor(n_estimators=100, max_features=10, max_depth=5, min_samples_leaf=2) - ml_m = RandomForestClassifier(n_estimators=100, max_features=10, max_depth=5, min_samples_leaf=2) - dml_irm_obj = dml.DoubleMLIRM(obj_dml_data, ml_g, ml_m) - dml_irm_obj.fit() - print(dml_irm_obj.summary) - -The :py:class:`doubleml.DoubleMLIRM` model class saves nuisance predictions in the ``predictions`` attribute as a nested dictionary. -To rely on external predictions, the user has to provide a nested dictionary, where the outer level keys correspond to the treatment -variable names and the inner level keys correspond to the nuisance learner names. Further the values have to be ``numpy`` arrays of shape -``(n_obs, n_rep)``. Here we generate an external predictions dictionary from the internal ``predictions`` attribute. - -.. tab-set:: - - .. tab-item:: Python - :sync: py - - .. ipython:: python - - pred_dict = {"d": { - "ml_g0": dml_irm_obj.predictions["ml_g0"][:, :, 0], - "ml_g1": dml_irm_obj.predictions["ml_g1"][:, :, 0], - "ml_m": dml_irm_obj.predictions["ml_m"][:, :, 0] - } - } - -The external predictions can be passed to the ``fit()`` method of the :py:class:`doubleml.DoubleML` class via the ``external_predictions`` argument. - -.. tab-set:: - - .. tab-item:: Python - :sync: py - - .. ipython:: python - - ml_g = dml.utils.DMLDummyRegressor() - ml_m = dml.utils.DMLDummyClassifier() - dml_irm_obj_ext = dml.DoubleMLIRM(obj_dml_data, ml_g, ml_m) - dml_irm_obj_ext.fit(external_predictions=pred_dict) - print(dml_irm_obj_ext.summary) - -Both model have identical estimates. Remark that :py:class:`doubleml.DoubleML` class usually require learners for initialization. -With external predictions these learners are not used. The ``DMLDummyRegressor`` and ``DMLDummyClassifier`` are dummy learners which -are used to initialize the :py:class:`doubleml.DoubleML` class. Both dummy learners raise errors if specific methods are called to safeguard against -undesired behavior. Further, the :py:class:`doubleml.DoubleMLData` class requires features (e.g. via the ``x_cols`` argument) which are not used. -This can be handled by adding a dummy column to the data. .. _learners_r: R: Learners and hyperparameters ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -Minimum requirements for learners -################################# - -The minimum requirement for a learner to be used for nuisance models in the :ref:`DoubleML ` package is - -* The implementation as a learner for regression or classification in the `mlr3 `_ package - or its extension packages `mlr3learners `_ and - `mlr3extralearners `_ . A guide on how to add a learner is provided in the - `chapter on extending learners in the mlr3 book `_ . -* The `mlr3 `_ package makes sure that the learners satisfy some core functionalities. - To specify a specific learner in :ref:`DoubleML ` users can pass objects of the class - `Learner `_. A fast way to construct these objects is to use the - `mlr3 `_ function `lrn() `_. - An introduction to learners in `mlr3 `_ is provided in the `chapter on learners of the mlr3 book `_. -* It is also possible to pass learners that have been constructed from a pipeline with the `mlr3pipelines `_ - package. -* The models `DoubleML::DoubleMLIRM `_ and - `DoubleML::DoubleMLIIVM `_ require classifiers. - Users can also specify classifiers in the `DoubleML::DoubleMLPLR `_ - in cases with binary treatment variables. -* Hyperparameters of learners can either be set at instantiation in `mlr3 `_ or after - instantiation using the ``set_ml_nuisance_params()`` method. - - -An interactive list of provided learners in the `mlr3 `_ and extension packages can be found on the -`website of the mlr3extralearners package `_. - - - -Specifying learners and set hyperparameters -########################################### - -The learners are set during initialization of the :ref:`DoubleML ` model classes -`DoubleML::DoubleMLPLR `_, -`DoubleML::DoubleMLPLIV `_ , -`DoubleML::DoubleMLIRM `_ -and `DoubleML::DoubleMLIIVM `_. -Lets simulate some data and consider the partially linear regression model. -We need to specify learners for the nuisance functions :math:`g_0(X) = E[Y|X]` and :math:`m_0(X) = E[D|X]`, -for example `LearnerRegrRanger `_ -(``lrn("regr.ranger")``) for regression with random forests based on the `ranger `_ -package for R. - -.. tab-set:: - - .. tab-item:: R - :sync: r - - .. jupyter-execute:: - - library(DoubleML) - library(mlr3) - library(mlr3learners) - library(data.table) - lgr::get_logger("mlr3")$set_threshold("warn") - - # set up a mlr3 learner - learner = lrn("regr.ranger") - ml_l = learner$clone() - ml_m = learner$clone() - set.seed(3141) - data = make_plr_CCDDHNR2018(alpha=0.5, return_type='data.table') - obj_dml_data = DoubleMLData$new(data, y_col="y", d_cols="d") - dml_plr_obj = DoubleMLPLR$new(obj_dml_data, ml_l, ml_m) - dml_plr_obj$fit() - dml_plr_obj$summary() - -Without further specification of the hyperparameters, default values are used. To set hyperparameters: - -* We can also use pre-parametrized learners ``lrn("regr.ranger", num.trees=10)``. -* Alternatively, hyperparameters can be set after initialization via the method - ``set_ml_nuisance_params(learner, treat_var, params, set_fold_specific)``. - -.. tab-set:: - - .. tab-item:: R - :sync: r - - .. jupyter-execute:: - - set.seed(3141) - ml_l = lrn("regr.ranger", num.trees=10) - ml_m = lrn("regr.ranger") - obj_dml_data = DoubleMLData$new(data, y_col="y", d_cols="d") - dml_plr_obj = DoubleMLPLR$new(obj_dml_data, ml_l, ml_m) - dml_plr_obj$fit() - dml_plr_obj$summary() - - set.seed(3141) - ml_l = lrn("regr.ranger") - dml_plr_obj = DoubleMLPLR$new(obj_dml_data, ml_l , ml_m) - dml_plr_obj$set_ml_nuisance_params("ml_l", "d", list("num.trees"=10)) - dml_plr_obj$fit() - dml_plr_obj$summary() - -Setting treatment-variable-specific or fold-specific hyperparameters: - -* In the multiple-treatment case, the method ``set_ml_nuisance_params(learner, treat_var, params, set_fold_specific)`` - can be used to set different hyperparameters for different treatment variables. -* The method ``set_ml_nuisance_params(learner, treat_var, params, set_fold_specific)`` accepts lists for ``params``. - The structure of the list depends on whether the same parameters should be provided for all folds or separate values - are passed for specific folds. -* Global parameter passing: The values in ``params`` are used for estimation on all folds. - The named list in the argument ``params`` should have entries with names corresponding to - the parameters of the learners. It is required that option ``set_fold_specific`` is set to ``FALSE`` (default). -* Fold-specific parameter passing: ``params`` is a nested list. The outer list needs to be of length ``n_rep`` and the inner - list of length ``n_folds``. The innermost list must have named entries that correspond to the parameters of the learner. - It is required that option ``set_fold_specific`` is set to ``TRUE``. Moreover, fold-specific - parameter passing is only supported, if all parameters are set fold-specific. -* External setting of parameters will override previously set parameters. To assert the choice of parameters, access the - fields ``$learner`` and ``$params``. - -.. tab-set:: - - .. tab-item:: R - :sync: r - - .. jupyter-execute:: - - set.seed(3141) - ml_l = lrn("regr.ranger") - ml_m = lrn("regr.ranger") - obj_dml_data = DoubleMLData$new(data, y_col="y", d_cols="d") - - n_rep = 2 - n_folds = 3 - dml_plr_obj = DoubleMLPLR$new(obj_dml_data, ml_l, ml_m, n_rep=n_rep, n_folds=n_folds) - - # Set globally - params = list("num.trees"=10) - dml_plr_obj$set_ml_nuisance_params("ml_l", "d", params=params) - dml_plr_obj$set_ml_nuisance_params("ml_m", "d", params=params) - dml_plr_obj$learner - dml_plr_obj$params - dml_plr_obj$fit() - dml_plr_obj$summary() - - -The following example illustrates how to set parameters for each fold. - -.. tab-set:: - - .. tab-item:: R - :sync: r - - .. jupyter-execute:: - - learner = lrn("regr.ranger") - ml_l = learner$clone() - ml_m = learner$clone() - dml_plr_obj = DoubleMLPLR$new(obj_dml_data, ml_l, ml_m, n_rep=n_rep, n_folds=n_folds) - - # Set values for each fold - params_exact = rep(list(rep(list(params), n_folds)), n_rep) - dml_plr_obj$set_ml_nuisance_params("ml_l", "d", params=params_exact, - set_fold_specific=TRUE) - dml_plr_obj$set_ml_nuisance_params("ml_m", "d", params=params_exact, - set_fold_specific=TRUE) - dml_plr_obj$learner - dml_plr_obj$params - dml_plr_obj$fit() - dml_plr_obj$summary() - - -Using pipelines to construct learners -##################################### - -Users can also specify learners that have been constructed from a pipeline using the `mlr3pipelines `_ -package. In general, pipelines can be used to perform data preprocessing, feature selection, combine learners and even -to perform hyperparameter tuning. In the following, we provide two examples on how to construct a single learner and how -to stack different learners via a pipeline. For a more detailed introduction to `mlr3pipelines `_, -we refer to the `Pipelines Chapter in the mlr3book `_. Moreover, a -notebook on how to use `mlr3pipelines `_ in combination with :ref:`DoubleML ` -is available in the example gallery. - -.. tab-set:: - - .. tab-item:: R - :sync: r - - .. jupyter-execute:: - - library(mlr3pipelines) - - set.seed(3141) - # Define random forest learner in a pipeline - single_learner_pipeline = po("learner", lrn("regr.ranger", num.trees = 10)) - - # Use pipeline to create a new instance of a learner - ml_g = as_learner(single_learner_pipeline) - ml_m = as_learner(single_learner_pipeline) - - obj_dml_data = DoubleMLData$new(data, y_col="y", d_cols="d") - - n_rep = 2 - n_folds = 3 - dml_plr_obj = DoubleMLPLR$new(obj_dml_data, ml_g, ml_m, n_rep=n_rep, n_folds=n_folds) - dml_plr_obj$learner - dml_plr_obj$fit() - dml_plr_obj$summary() - - set.seed(3141) - # Define ensemble learner in a pipeline - ensemble_learner_pipeline = gunion(list( - po("learner", lrn("regr.cv_glmnet", s = "lambda.min")), - po("learner", lrn("regr.ranger")), - po("learner", lrn("regr.rpart", cp = 0.01)))) %>>% - po("regravg", 3) - - # Use pipeline to create a new instance of a learner - ml_g = as_learner(ensemble_learner_pipeline) - ml_m = as_learner(ensemble_learner_pipeline) - - obj_dml_data = DoubleMLData$new(data, y_col="y", d_cols="d") - - n_rep = 2 - n_folds = 3 - dml_plr_obj = DoubleMLPLR$new(obj_dml_data, ml_g, ml_m, n_rep=n_rep, n_folds=n_folds) - dml_plr_obj$learner - dml_plr_obj$fit() - dml_plr_obj$summary() - - -Hyperparameter tuning -##################### - -Parameter tuning of learners for the nuisance functions of :ref:`DoubleML ` models can be done via the ``tune()`` method. -The ``tune()`` method passes various options and parameters to the tuning interface provided by the -`mlr3tuning `_ package. The `mlr3 book `_ provides a -`step-by-step introduction to parameter tuning `_. - -To illustrate the parameter tuning, we generate data from a sparse partially linear regression model. - -.. tab-set:: - - .. tab-item:: R - :sync: r - - .. jupyter-execute:: - - library(DoubleML) - library(mlr3) - library(data.table) - - set.seed(3141) - n_obs = 200 - n_vars = 200 - theta = 3 - X = matrix(stats::rnorm(n_obs * n_vars), nrow = n_obs, ncol = n_vars) - d = X[, 1:3, drop = FALSE] %*% c(5, 5, 5) + stats::rnorm(n_obs) - y = theta * d + X[, 1:3, drop = FALSE] %*% c(5, 5, 5) + stats::rnorm(n_obs) - dml_data = double_ml_data_from_matrix(X = X, y = y, d = d) - -The hyperparameter-tuning is performed according to options passed through a named list ``tune_settings``. -The entries in the list specify options during parameter tuning with `mlr3tuning `_: - -* ``terminator`` is a `Terminator object `_ passed to - `mlr3tuning `_ that manages the budget to solve the tuning problem. -* ``algorithm`` is an object of class - `Tuner `_ and specifies the tuning algorithm. - Alternatively, ``algorithm`` can be a ``character()`` that is used as an argument in the wrapper - `mlr3tuning `_ call - `tnr(algorithm) `_. - `The corresponding chapter in the mlr3book `_ illustrates - how the `Tuner `_ class supports grid search, random search, - generalized simulated annealing and non-linear optimization. -* ``rsmp_tune`` is an object of class `mlr3 resampling `_ - that specifies the resampling method for evaluation, for example `rsmp("cv", folds = 5)` implements 5-fold cross-validation. - `rsmp("holdout", ratio = 0.8)` implements an evaluation based on a hold-out sample that contains 20 percent of the observations. - By default, 5-fold cross-validation is performed. -* ``measure`` is a named list containing the measures used for tuning of the nuisance components. - The names of the entries must match the learner names (see method ``learner_names()``). The entries in the list must either be - objects of class `Measure `_ or keys passed to `msr() `_. - If ``measure`` is not provided by the user, default measures are used, i.e., mean squared error for regression models - and classification error for binary outcomes. - -In the following example, we tune the penalty parameter :math:`\lambda` (``lambda``) for lasso with the R package -`glmnet `_. To tune the value of ``lambda``, a grid search is performed over a grid of values that range from 0.05 -to 0.1 at a resolution of 10. Using a resolution of 10 splits the grid of values in 10 equally spaced values ranging from a minimum of 0.05 -to a maximum of 0.1. To evaluate the predictive performance in both nuisance parts, the cross-validated mean squared error is used. - -Setting the option ``tune_on_folds=FALSE``, the tuning is performed on the whole sample. Hence, the cross-validated errors -are obtained from a random split of the whole sample into 5 folds. As a result, one set of ``lambda`` values are obtained -which are later used in the fitting stage for all folds. - -Alternatively, setting the option ``tune_on_folds=TRUE`` would assign the tuning resampling scheme ``rsmp_tune`` to each fold. -For example, if we set ``n_folds=2`` at initialization of the ``DoubleMLPLR`` object and use a 5-fold cross-validated error -for tuning, each of the two folds would be split up into 5 subfolds and the error would be evaluated on these subfolds. - - -.. tab-set:: - - .. tab-item:: R - :sync: r - - .. jupyter-execute:: - - library(DoubleML) - library(mlr3) - library(data.table) - library(mlr3learners) - library(mlr3tuning) - library(paradox) - lgr::get_logger("mlr3")$set_threshold("warn") - lgr::get_logger("bbotk")$set_threshold("warn") - - set.seed(1234) - ml_l = lrn("regr.glmnet") - ml_m = lrn("regr.glmnet") - dml_plr_obj = DoubleMLPLR$new(dml_data, ml_l, ml_m) - - par_grids = list( - "ml_l" = ps(lambda = p_dbl(lower = 0.05, upper = 0.1)), - "ml_m" = ps(lambda = p_dbl(lower = 0.05, upper = 0.1))) - - tune_settings = list(terminator = trm("evals", n_evals = 100), - algorithm = tnr("grid_search", resolution = 10), - rsmp_tune = rsmp("cv", folds = 5), - measure = list("ml_l" = msr("regr.mse"), - "ml_m" = msr("regr.mse"))) - dml_plr_obj$tune(param_set=par_grids, tune_settings=tune_settings, tune_on_fold=TRUE) - dml_plr_obj$params - - dml_plr_obj$fit() - dml_plr_obj$summary() - - -Hyperparameter tuning can also be done with more sophisticated methods, for example by using built-in tuning -paths of learners. For example, the learner `regr.cv_glmnet `_ -performs an internal cross-validated choice of the parameter ``lambda``. -Alternatively, the powerful functionalities of the `mlr3tuning `_ package can be used for -external parameter tuning of the nuisance parts. The optimally chosen parameters can then be passed to the -:ref:`DoubleML ` models using the ``set_ml_nuisance_params()`` method. - -.. tab-set:: - - .. tab-item:: R - :sync: r - - .. jupyter-execute:: - - library(DoubleML) - library(mlr3) - library(data.table) - library(mlr3learners) - library(mlr3tuning) - lgr::get_logger("mlr3")$set_threshold("warn") - lgr::get_logger("bbotk")$set_threshold("warn") - - set.seed(1234) - ml_l = lrn("regr.cv_glmnet", s="lambda.min") - ml_m = lrn("regr.cv_glmnet", s="lambda.min") - dml_plr_obj = DoubleMLPLR$new(dml_data, ml_l, ml_m) - - dml_plr_obj$fit() - dml_plr_obj$summary() - - -The following code chunk illustrates another example for global parameter tuning with random forests -as provided by the `ranger `_ package. In this example, we use random search to find optimal -parameters ``mtry`` and ``max.depth`` of a random forest. Evaluation is based on 3-fold cross-validation. - -.. tab-set:: - - .. tab-item:: R - :sync: r - - .. jupyter-execute:: - - library(DoubleML) - library(mlr3) - library(mlr3learners) - library(data.table) - library(mlr3tuning) - library(paradox) - lgr::get_logger("mlr3")$set_threshold("warn") - lgr::get_logger("bbotk")$set_threshold("warn") - - # set up a mlr3 learner - learner = lrn("regr.ranger") - ml_l = learner$clone() - ml_m = learner$clone() - - set.seed(3141) - obj_dml_data = make_plr_CCDDHNR2018(alpha=0.5) - dml_plr_obj = DoubleMLPLR$new(obj_dml_data, ml_l, ml_m) - - # set up a list of parameter grids - param_grid = list("ml_l" = ps(mtry = p_int(lower = 2 , upper = 20), - max.depth = p_int(lower = 2, upper = 5)), - "ml_m" = ps(mtry = p_int(lower = 2 , upper = 20), - max.depth = p_int(lower = 2, upper = 5))) - - tune_settings = list(terminator = mlr3tuning::trm("evals", n_evals = 20), - algorithm = tnr("random_search"), - rsmp_tune = rsmp("cv", folds = 3), - measure = list("ml_l" = msr("regr.mse"), - "ml_m" = msr("regr.mse"))) - dml_plr_obj$tune(param_set=param_grid, tune_settings=tune_settings, tune_on_folds=FALSE) - dml_plr_obj$params - - dml_plr_obj$fit() - dml_plr_obj$summary() - - -Hyperparameter tuning with pipelines -#################################### - -As an alternative to the previously presented tuning approach, it is possible to base the parameter tuning on a pipeline -as provided by the `mlr3pipelines `_ package. The basic idea of this approach is to -define a learner via a pipeline and then perform the tuning via the ``tune()``. We will shortly repeat the lasso example -from above. In general, the pipeline-based approach can be used to find optimal values not only for the parameters of -one or multiple learners, but also for other parameters, which are, for example, involved in the data preprocessing. We -refer to more details provided in the `Pipelines Chapter in the mlr3book `_. - -.. tab-set:: - - .. tab-item:: R - :sync: r - - .. jupyter-execute:: - - library(DoubleML) - library(mlr3) - library(mlr3tuning) - library(mlr3pipelines) - lgr::get_logger("mlr3")$set_threshold("warn") - lgr::get_logger("bbotk")$set_threshold("warn") - - # Define learner in a pipeline - set.seed(1234) - lasso_pipe = po("learner", - learner = lrn("regr.glmnet")) - ml_g = as_learner(lasso_pipe) - ml_m = as_learner(lasso_pipe) - - # Instantiate a DoubleML object - dml_plr_obj = DoubleMLPLR$new(dml_data, ml_g, ml_m) - - # Parameter grid for lambda - par_grids = ps(regr.glmnet.lambda = p_dbl(lower = 0.05, upper = 0.1)) - - tune_settings = list(terminator = trm("evals", n_evals = 100), - algorithm = tnr("grid_search", resolution = 10), - rsmp_tune = rsmp("cv", folds = 5), - measure = list("ml_g" = msr("regr.mse"), - "ml_m" = msr("regr.mse"))) - dml_plr_obj$tune(param_set = list("ml_g" = par_grids, - "ml_m" = par_grids), - tune_settings=tune_settings, - tune_on_fold=TRUE) - dml_plr_obj$fit() - dml_plr_obj$summary() - -References -++++++++++ - -* Lang, M., Binder, M., Richter, J., Schratz, P., Pfisterer, F., Coors, S., Au, Q., Casalicchio, G., Kotthoff, L., Bischl, B. (2019), mlr3: A modern object-oriented machine learing framework in R. Journal of Open Source Software, `doi:10.21105/joss.01903 `_. +.. include:: learners/r/learners_overview.inc -* Becker, M., Binder, M., Bischl, B., Lang, M., Pfisterer, F., Reich, N.G., Richter, J., Schratz, P., Sonabend, R. (2020), mlr3 book, available at `https://mlr3book.mlr-org.com `_. diff --git a/doc/guide/learners/python/evaluate_learners.rst b/doc/guide/learners/python/evaluate_learners.rst new file mode 100644 index 00000000..defbc896 --- /dev/null +++ b/doc/guide/learners/python/evaluate_learners.rst @@ -0,0 +1,59 @@ +To compare different learners it is possible to evaluate the out-of-sample performance of each learner. The ``summary`` +already displays either the root-mean-squared error (for regressions) or log-loss (for classifications) for each learner +and each corresponding repetition of cross-fitting (``n_rep`` argument). + +To illustrate the parameter tuning, we work with the following example. + +.. tab-set:: + + .. tab-item:: Python + :sync: py + + .. ipython:: python + + import doubleml as dml + from doubleml.plm.datasets import make_plr_CCDDHNR2018 + from sklearn.ensemble import RandomForestRegressor + + np.random.seed(1234) + ml_l = RandomForestRegressor() + ml_m = RandomForestRegressor() + data = make_plr_CCDDHNR2018(alpha=0.5, return_type='DataFrame') + obj_dml_data = dml.DoubleMLData(data, 'y', 'd') + dml_plr_obj = dml.DoubleMLPLR(obj_dml_data, ml_l, ml_m) + dml_plr_obj.fit() + print(dml_plr_obj) + +The loss of each learner are also stored in the ``nuisance_loss`` attribute. +Further, the ``evaluate_learners()`` method allows to evalute customized evaluation metrics as e.g. the mean absolute error. +The default option is still the root-mean-squared error for evaluation. + +.. tab-set:: + + .. tab-item:: Python + :sync: py + + .. ipython:: python + + print(dml_plr_obj.nuisance_loss) + print(dml_plr_obj.evaluate_learners()) + +To evaluate a customized metric one has to define a ``callable``. For some models (e.g. the IRM model) it is important that +the metric can handle ``nan`` values as not all target values are known. + +.. tab-set:: + + .. tab-item:: Python + :sync: py + + .. ipython:: python + + from sklearn.metrics import mean_absolute_error + + def mae(y_true, y_pred): + subset = np.logical_not(np.isnan(y_true)) + return mean_absolute_error(y_true[subset], y_pred[subset]) + + dml_plr_obj.evaluate_learners(learners=['ml_l'], metric=mae) + +A more detailed notebook on the choice of learners is available in the :ref:`example gallery `. \ No newline at end of file diff --git a/doc/guide/learners/python/external_preds.rst b/doc/guide/learners/python/external_preds.rst new file mode 100644 index 00000000..6ae30d22 --- /dev/null +++ b/doc/guide/learners/python/external_preds.rst @@ -0,0 +1,68 @@ +Since there might be cases where the user wants to use a learner that is not supported by :ref:`DoubleML ` +or do some extensive hyperparameter tuning, it is possible to use external predictions for the nuisance functions. +Remark that this requires the user to take care of the cross-fitting procedure and learner evaluation. + +To illustrate the use of external predictions, we work with the following example. + +.. tab-set:: + + .. tab-item:: Python + :sync: py + + .. ipython:: python + + import numpy as np + import doubleml as dml + from doubleml.irm.datasets import make_irm_data + from sklearn.ensemble import RandomForestRegressor, RandomForestClassifier + + np.random.seed(3333) + data = make_irm_data(theta=0.5, n_obs=500, dim_x=10, return_type='DataFrame') + obj_dml_data = dml.DoubleMLData(data, 'y', 'd') + + # DoubleML with interal predictions + ml_g = RandomForestRegressor(n_estimators=100, max_features=10, max_depth=5, min_samples_leaf=2) + ml_m = RandomForestClassifier(n_estimators=100, max_features=10, max_depth=5, min_samples_leaf=2) + dml_irm_obj = dml.DoubleMLIRM(obj_dml_data, ml_g, ml_m) + dml_irm_obj.fit() + print(dml_irm_obj.summary) + +The :py:class:`doubleml.DoubleMLIRM` model class saves nuisance predictions in the ``predictions`` attribute as a nested dictionary. +To rely on external predictions, the user has to provide a nested dictionary, where the outer level keys correspond to the treatment +variable names and the inner level keys correspond to the nuisance learner names. Further the values have to be ``numpy`` arrays of shape +``(n_obs, n_rep)``. Here we generate an external predictions dictionary from the internal ``predictions`` attribute. + +.. tab-set:: + + .. tab-item:: Python + :sync: py + + .. ipython:: python + + pred_dict = {"d": { + "ml_g0": dml_irm_obj.predictions["ml_g0"][:, :, 0], + "ml_g1": dml_irm_obj.predictions["ml_g1"][:, :, 0], + "ml_m": dml_irm_obj.predictions["ml_m"][:, :, 0] + } + } + +The external predictions can be passed to the ``fit()`` method of the :py:class:`doubleml.DoubleML` class via the ``external_predictions`` argument. + +.. tab-set:: + + .. tab-item:: Python + :sync: py + + .. ipython:: python + + ml_g = dml.utils.DMLDummyRegressor() + ml_m = dml.utils.DMLDummyClassifier() + dml_irm_obj_ext = dml.DoubleMLIRM(obj_dml_data, ml_g, ml_m) + dml_irm_obj_ext.fit(external_predictions=pred_dict) + print(dml_irm_obj_ext.summary) + +Both model have identical estimates. Remark that :py:class:`doubleml.DoubleML` class usually require learners for initialization. +With external predictions these learners are not used. The ``DMLDummyRegressor`` and ``DMLDummyClassifier`` are dummy learners which +are used to initialize the :py:class:`doubleml.DoubleML` class. Both dummy learners raise errors if specific methods are called to safeguard against +undesired behavior. Further, the :py:class:`doubleml.DoubleMLData` class requires features (e.g. via the ``x_cols`` argument) which are not used. +This can be handled by adding a dummy column to the data. \ No newline at end of file diff --git a/doc/guide/learners/python/learners_overview.inc b/doc/guide/learners/python/learners_overview.inc new file mode 100644 index 00000000..9a173622 --- /dev/null +++ b/doc/guide/learners/python/learners_overview.inc @@ -0,0 +1,38 @@ +.. _py_learner_req: + +Minimum requirements for learners +################################# + +.. include:: /guide/learners/python/minimum_req.rst + + +.. _py_set_params: + +Specifying learners and set hyperparameters +########################################### + +.. include:: /guide/learners/python/set_hyperparams.rst + +.. _py_tune_params: + +Hyperparameter tuning +##################### + +.. include:: /guide/learners/python/tune_hyperparams.rst + + +.. _py_eval_learners: + +Evaluate learners +################# + +.. include:: /guide/learners/python/evaluate_learners.rst + + +.. _py_ext_pred: + +Advanced: External Predictions +############################## + + +.. include:: /guide/learners/python/external_preds.rst \ No newline at end of file diff --git a/doc/guide/learners/python/minimum_req.rst b/doc/guide/learners/python/minimum_req.rst new file mode 100644 index 00000000..cb557ebc --- /dev/null +++ b/doc/guide/learners/python/minimum_req.rst @@ -0,0 +1,14 @@ +The minimum requirement for a learner to be used for nuisance models in the :ref:`DoubleML ` +package is + +* The implementation of a ``fit()`` and ``predict()`` method. + Some models, like :py:class:`doubleml.DoubleMLIRM` and :py:class:`doubleml.DoubleMLIIVM` require classifiers. +* In case of classifiers, the learner needs to come with a ``predict_proba()`` instead of, or in addition to, a + ``predict()`` method, see for example :py:meth:`sklearn.ensemble.RandomForestClassifier.predict_proba`. +* In order to be able to use the ``set_ml_nuisance_params()`` method of :ref:`DoubleML ` classes the + learner additionally needs to come with a ``set_params()`` method, + see for example :py:meth:`sklearn.ensemble.RandomForestRegressor.set_params`. +* We further rely on the function :py:func:`sklearn.base.clone` which adds the requirement of a ``get_params()`` + method for a learner in order to be used for nuisance models of :ref:`DoubleML ` model classes. + +Most learners from `scikit-learn `_ satisfy all these minimum requirements. diff --git a/doc/guide/learners/python/set_hyperparams.rst b/doc/guide/learners/python/set_hyperparams.rst new file mode 100644 index 00000000..039ba2c5 --- /dev/null +++ b/doc/guide/learners/python/set_hyperparams.rst @@ -0,0 +1,61 @@ +The learners are set during initialization of the :ref:`DoubleML ` model classes +:py:class:`doubleml.DoubleMLPLR`, :py:class:`doubleml.DoubleMLPLIV`, +:py:class:`doubleml.DoubleMLIRM` and :py:class:`doubleml.DoubleMLIIVM`. +Lets simulate some data and consider the partially linear regression model. +We need to specify learners for the nuisance functions :math:`g_0(X) = E[Y|X]` and :math:`m_0(X) = E[D|X]`, +for example :py:class:`sklearn.ensemble.RandomForestRegressor`. + +.. tab-set:: + + .. tab-item:: Python + :sync: py + + .. ipython:: python + + import doubleml as dml + from doubleml.plm.datasets import make_plr_CCDDHNR2018 + from sklearn.ensemble import RandomForestRegressor + + np.random.seed(1234) + ml_l = RandomForestRegressor() + ml_m = RandomForestRegressor() + data = make_plr_CCDDHNR2018(alpha=0.5, return_type='DataFrame') + obj_dml_data = dml.DoubleMLData(data, 'y', 'd') + dml_plr_obj = dml.DoubleMLPLR(obj_dml_data, ml_l, ml_m) + dml_plr_obj.fit().summary + +Without further specification of the hyperparameters, default values are used. To set hyperparameters: + +* We can also use pre-parametrized learners, like ``RandomForestRegressor(n_estimators=10)``. +* Alternatively, hyperparameters can also be set after initialization via the method + ``set_ml_nuisance_params(learner, treat_var, params)`` + + +.. tab-set:: + + .. tab-item:: Python + :sync: py + + .. ipython:: python + + np.random.seed(1234) + dml_plr_obj = dml.DoubleMLPLR(obj_dml_data, + RandomForestRegressor(n_estimators=10), + RandomForestRegressor()) + print(dml_plr_obj.fit().summary) + + np.random.seed(1234) + dml_plr_obj = dml.DoubleMLPLR(obj_dml_data, + RandomForestRegressor(), + RandomForestRegressor()) + dml_plr_obj.set_ml_nuisance_params('ml_l', 'd', {'n_estimators': 10}); + print(dml_plr_obj.fit().summary) + +Setting treatment-variable-specific or fold-specific hyperparameters: + +* In the multiple-treatment case, the method ``set_ml_nuisance_params(learner, treat_var, params)`` can be used to set + different hyperparameters for different treatment variables. +* The method ``set_ml_nuisance_params(learner, treat_var, params)`` accepts dicts and lists for ``params``. + A dict should be provided if for each fold the same hyperparameters should be used. + Fold-specific parameters are supported. To do so, provide a nested list as ``params``, where the outer list is of + length ``n_rep`` and the inner list of length ``n_folds``. \ No newline at end of file diff --git a/doc/guide/learners/python/tune_hyperparams.rst b/doc/guide/learners/python/tune_hyperparams.rst new file mode 100644 index 00000000..3ac264ff --- /dev/null +++ b/doc/guide/learners/python/tune_hyperparams.rst @@ -0,0 +1,83 @@ +Parameter tuning of learners for the nuisance functions of :ref:`DoubleML ` models can be done via +the ``tune()`` method. +To illustrate the parameter tuning, we generate data from a sparse partially linear regression model. + +.. tab-set:: + + .. tab-item:: Python + :sync: py + + .. ipython:: python + + import doubleml as dml + import numpy as np + + np.random.seed(3141) + n_obs = 200 + n_vars = 200 + theta = 3 + X = np.random.normal(size=(n_obs, n_vars)) + d = np.dot(X[:, :3], np.array([5, 5, 5])) + np.random.standard_normal(size=(n_obs,)) + y = theta * d + np.dot(X[:, :3], np.array([5, 5, 5])) + np.random.standard_normal(size=(n_obs,)) + dml_data = dml.DoubleMLData.from_arrays(X, y, d) + +The hyperparameter-tuning is performed using either an exhaustive search over specified parameter values +implemented in :class:`sklearn.model_selection.GridSearchCV` or via a randomized search implemented in +:class:`sklearn.model_selection.RandomizedSearchCV`. + +.. tab-set:: + + .. tab-item:: Python + :sync: py + + .. ipython:: python + :okwarning: + + import doubleml as dml + from sklearn.linear_model import Lasso + + ml_l = Lasso() + ml_m = Lasso() + dml_plr_obj = dml.DoubleMLPLR(dml_data, ml_l, ml_m) + par_grids = {'ml_l': {'alpha': np.arange(0.05, 1., 0.1)}, + 'ml_m': {'alpha': np.arange(0.05, 1., 0.1)}} + dml_plr_obj.tune(par_grids, search_mode='grid_search'); + print(dml_plr_obj.params) + print(dml_plr_obj.fit().summary) + + np.random.seed(1234) + par_grids = {'ml_l': {'alpha': np.arange(0.05, 1., 0.01)}, + 'ml_m': {'alpha': np.arange(0.05, 1., 0.01)}} + dml_plr_obj.tune(par_grids, search_mode='randomized_search', n_iter_randomized_search=20); + print(dml_plr_obj.params) + print(dml_plr_obj.fit().summary) + +Hyperparameter tuning can also be done with more sophisticated methods, like for example an iterative fitting along +a regularization path implemented in :py:class:`sklearn.linear_model.LassoCV`. +In this case the tuning should be done externally and the parameters can then be set via the +``set_ml_nuisance_params()`` method. + +.. tab-set:: + + .. tab-item:: Python + :sync: py + + .. ipython:: python + + import doubleml as dml + from sklearn.linear_model import LassoCV + + np.random.seed(1234) + ml_l_tune = LassoCV().fit(dml_data.x, dml_data.y) + ml_m_tune = LassoCV().fit(dml_data.x, dml_data.d) + + ml_l = Lasso() + ml_m = Lasso() + dml_plr_obj = dml.DoubleMLPLR(dml_data, ml_l, ml_m) + dml_plr_obj.set_ml_nuisance_params('ml_l', 'd', {'alpha': ml_l_tune.alpha_}); + dml_plr_obj.set_ml_nuisance_params('ml_m', 'd', {'alpha': ml_m_tune.alpha_}); + print(dml_plr_obj.params) + print(dml_plr_obj.fit().summary) + +External tuning requires knowledge about the underlying machine learning estimators and +is therefore not recommended for all models. diff --git a/doc/guide/learners/r/learners_overview.inc b/doc/guide/learners/r/learners_overview.inc new file mode 100644 index 00000000..b98eee20 --- /dev/null +++ b/doc/guide/learners/r/learners_overview.inc @@ -0,0 +1,39 @@ +.. _r_learner_req: + +Minimum requirements for learners +################################# + +.. include:: /guide/learners/r/minimum_req.rst + + +.. _r_set_params: + +Specifying learners and set hyperparameters +########################################### + +.. include:: /guide/learners/r/set_hyperparams.rst + + +.. _r_pipelines: + +Using pipelines to construct learners +##################################### + +.. include:: /guide/learners/r/pipelines.rst + + +.. _r_tune_params: + +Hyperparameter tuning +##################### + +.. include:: /guide/learners/r/tune_hyperparams.rst + + +.. _r_tune_and_pipelines: + +Hyperparameter tuning with pipelines +#################################### + +.. include:: /guide/learners/r/tune_and_pipelines.rst + diff --git a/doc/guide/learners/r/minimum_req.rst b/doc/guide/learners/r/minimum_req.rst new file mode 100644 index 00000000..7f3abdf0 --- /dev/null +++ b/doc/guide/learners/r/minimum_req.rst @@ -0,0 +1,23 @@ +The minimum requirement for a learner to be used for nuisance models in the :ref:`DoubleML ` package is + +* The implementation as a learner for regression or classification in the `mlr3 `_ package + or its extension packages `mlr3learners `_ and + `mlr3extralearners `_ . A guide on how to add a learner is provided in the + `chapter on extending learners in the mlr3 book `_ . +* The `mlr3 `_ package makes sure that the learners satisfy some core functionalities. + To specify a specific learner in :ref:`DoubleML ` users can pass objects of the class + `Learner `_. A fast way to construct these objects is to use the + `mlr3 `_ function `lrn() `_. + An introduction to learners in `mlr3 `_ is provided in the `chapter on learners of the mlr3 book `_. +* It is also possible to pass learners that have been constructed from a pipeline with the `mlr3pipelines `_ + package. +* The models `DoubleML::DoubleMLIRM `_ and + `DoubleML::DoubleMLIIVM `_ require classifiers. + Users can also specify classifiers in the `DoubleML::DoubleMLPLR `_ + in cases with binary treatment variables. +* Hyperparameters of learners can either be set at instantiation in `mlr3 `_ or after + instantiation using the ``set_ml_nuisance_params()`` method. + + +An interactive list of provided learners in the `mlr3 `_ and extension packages can be found on the +`website of the mlr3extralearners package `_. diff --git a/doc/guide/learners/r/pipelines.rst b/doc/guide/learners/r/pipelines.rst new file mode 100644 index 00000000..de18b6ab --- /dev/null +++ b/doc/guide/learners/r/pipelines.rst @@ -0,0 +1,59 @@ +Users can also specify learners that have been constructed from a pipeline using the `mlr3pipelines `_ +package. In general, pipelines can be used to perform data preprocessing, feature selection, combine learners and even +to perform hyperparameter tuning. In the following, we provide two examples on how to construct a single learner and how +to stack different learners via a pipeline. For a more detailed introduction to `mlr3pipelines `_, +we refer to the `Pipelines Chapter in the mlr3book `_. Moreover, a +notebook on how to use `mlr3pipelines `_ in combination with :ref:`DoubleML ` +is available in the example gallery. + +.. tab-set:: + + .. tab-item:: R + :sync: r + + .. jupyter-execute:: + + library(DoubleML) + library(mlr3) + library(mlr3learners) + library(mlr3pipelines) + library(data.table) + + set.seed(3141) + # Define random forest learner in a pipeline + single_learner_pipeline = po("learner", lrn("regr.ranger", num.trees = 10)) + + # Use pipeline to create a new instance of a learner + ml_g = as_learner(single_learner_pipeline) + ml_m = as_learner(single_learner_pipeline) + + data = make_plr_CCDDHNR2018(alpha=0.5, return_type='data.table') + obj_dml_data = DoubleMLData$new(data, y_col="y", d_cols="d") + + n_rep = 2 + n_folds = 3 + dml_plr_obj = DoubleMLPLR$new(obj_dml_data, ml_g, ml_m, n_rep=n_rep, n_folds=n_folds) + dml_plr_obj$learner + dml_plr_obj$fit() + dml_plr_obj$summary() + + set.seed(3141) + # Define ensemble learner in a pipeline + ensemble_learner_pipeline = gunion(list( + po("learner", lrn("regr.cv_glmnet", s = "lambda.min")), + po("learner", lrn("regr.ranger")), + po("learner", lrn("regr.rpart", cp = 0.01)))) %>>% + po("regravg", 3) + + # Use pipeline to create a new instance of a learner + ml_g = as_learner(ensemble_learner_pipeline) + ml_m = as_learner(ensemble_learner_pipeline) + + obj_dml_data = DoubleMLData$new(data, y_col="y", d_cols="d") + + n_rep = 2 + n_folds = 3 + dml_plr_obj = DoubleMLPLR$new(obj_dml_data, ml_g, ml_m, n_rep=n_rep, n_folds=n_folds) + dml_plr_obj$learner + dml_plr_obj$fit() + dml_plr_obj$summary() diff --git a/doc/guide/learners/r/set_hyperparams.rst b/doc/guide/learners/r/set_hyperparams.rst new file mode 100644 index 00000000..266b8372 --- /dev/null +++ b/doc/guide/learners/r/set_hyperparams.rst @@ -0,0 +1,130 @@ +The learners are set during initialization of the :ref:`DoubleML ` model classes +`DoubleML::DoubleMLPLR `_, +`DoubleML::DoubleMLPLIV `_ , +`DoubleML::DoubleMLIRM `_ +and `DoubleML::DoubleMLIIVM `_. +Lets simulate some data and consider the partially linear regression model. +We need to specify learners for the nuisance functions :math:`g_0(X) = E[Y|X]` and :math:`m_0(X) = E[D|X]`, +for example `LearnerRegrRanger `_ +(``lrn("regr.ranger")``) for regression with random forests based on the `ranger `_ +package for R. + +.. tab-set:: + + .. tab-item:: R + :sync: r + + .. jupyter-execute:: + + library(DoubleML) + library(mlr3) + library(mlr3learners) + library(data.table) + lgr::get_logger("mlr3")$set_threshold("warn") + + # set up a mlr3 learner + learner = lrn("regr.ranger") + ml_l = learner$clone() + ml_m = learner$clone() + set.seed(3141) + data = make_plr_CCDDHNR2018(alpha=0.5, return_type='data.table') + obj_dml_data = DoubleMLData$new(data, y_col="y", d_cols="d") + dml_plr_obj = DoubleMLPLR$new(obj_dml_data, ml_l, ml_m) + dml_plr_obj$fit() + dml_plr_obj$summary() + +Without further specification of the hyperparameters, default values are used. To set hyperparameters: + +* We can also use pre-parametrized learners ``lrn("regr.ranger", num.trees=10)``. +* Alternatively, hyperparameters can be set after initialization via the method + ``set_ml_nuisance_params(learner, treat_var, params, set_fold_specific)``. + +.. tab-set:: + + .. tab-item:: R + :sync: r + + .. jupyter-execute:: + + set.seed(3141) + ml_l = lrn("regr.ranger", num.trees=10) + ml_m = lrn("regr.ranger") + obj_dml_data = DoubleMLData$new(data, y_col="y", d_cols="d") + dml_plr_obj = DoubleMLPLR$new(obj_dml_data, ml_l, ml_m) + dml_plr_obj$fit() + dml_plr_obj$summary() + + set.seed(3141) + ml_l = lrn("regr.ranger") + dml_plr_obj = DoubleMLPLR$new(obj_dml_data, ml_l , ml_m) + dml_plr_obj$set_ml_nuisance_params("ml_l", "d", list("num.trees"=10)) + dml_plr_obj$fit() + dml_plr_obj$summary() + +Setting treatment-variable-specific or fold-specific hyperparameters: + +* In the multiple-treatment case, the method ``set_ml_nuisance_params(learner, treat_var, params, set_fold_specific)`` + can be used to set different hyperparameters for different treatment variables. +* The method ``set_ml_nuisance_params(learner, treat_var, params, set_fold_specific)`` accepts lists for ``params``. + The structure of the list depends on whether the same parameters should be provided for all folds or separate values + are passed for specific folds. +* Global parameter passing: The values in ``params`` are used for estimation on all folds. + The named list in the argument ``params`` should have entries with names corresponding to + the parameters of the learners. It is required that option ``set_fold_specific`` is set to ``FALSE`` (default). +* Fold-specific parameter passing: ``params`` is a nested list. The outer list needs to be of length ``n_rep`` and the inner + list of length ``n_folds``. The innermost list must have named entries that correspond to the parameters of the learner. + It is required that option ``set_fold_specific`` is set to ``TRUE``. Moreover, fold-specific + parameter passing is only supported, if all parameters are set fold-specific. +* External setting of parameters will override previously set parameters. To assert the choice of parameters, access the + fields ``$learner`` and ``$params``. + +.. tab-set:: + + .. tab-item:: R + :sync: r + + .. jupyter-execute:: + + set.seed(3141) + ml_l = lrn("regr.ranger") + ml_m = lrn("regr.ranger") + obj_dml_data = DoubleMLData$new(data, y_col="y", d_cols="d") + + n_rep = 2 + n_folds = 3 + dml_plr_obj = DoubleMLPLR$new(obj_dml_data, ml_l, ml_m, n_rep=n_rep, n_folds=n_folds) + + # Set globally + params = list("num.trees"=10) + dml_plr_obj$set_ml_nuisance_params("ml_l", "d", params=params) + dml_plr_obj$set_ml_nuisance_params("ml_m", "d", params=params) + dml_plr_obj$learner + dml_plr_obj$params + dml_plr_obj$fit() + dml_plr_obj$summary() + + +The following example illustrates how to set parameters for each fold. + +.. tab-set:: + + .. tab-item:: R + :sync: r + + .. jupyter-execute:: + + learner = lrn("regr.ranger") + ml_l = learner$clone() + ml_m = learner$clone() + dml_plr_obj = DoubleMLPLR$new(obj_dml_data, ml_l, ml_m, n_rep=n_rep, n_folds=n_folds) + + # Set values for each fold + params_exact = rep(list(rep(list(params), n_folds)), n_rep) + dml_plr_obj$set_ml_nuisance_params("ml_l", "d", params=params_exact, + set_fold_specific=TRUE) + dml_plr_obj$set_ml_nuisance_params("ml_m", "d", params=params_exact, + set_fold_specific=TRUE) + dml_plr_obj$learner + dml_plr_obj$params + dml_plr_obj$fit() + dml_plr_obj$summary() diff --git a/doc/guide/learners/r/tune_and_pipelines.rst b/doc/guide/learners/r/tune_and_pipelines.rst new file mode 100644 index 00000000..3b735f4e --- /dev/null +++ b/doc/guide/learners/r/tune_and_pipelines.rst @@ -0,0 +1,61 @@ +As an alternative to the previously presented tuning approach, it is possible to base the parameter tuning on a pipeline +as provided by the `mlr3pipelines `_ package. The basic idea of this approach is to +define a learner via a pipeline and then perform the tuning via the ``tune()``. We will shortly repeat the lasso example +from above. In general, the pipeline-based approach can be used to find optimal values not only for the parameters of +one or multiple learners, but also for other parameters, which are, for example, involved in the data preprocessing. We +refer to more details provided in the `Pipelines Chapter in the mlr3book `_. + +.. tab-set:: + + .. tab-item:: R + :sync: r + + .. jupyter-execute:: + + library(DoubleML) + library(mlr3) + library(mlr3tuning) + library(mlr3pipelines) + lgr::get_logger("mlr3")$set_threshold("warn") + lgr::get_logger("bbotk")$set_threshold("warn") + + set.seed(3141) + n_obs = 200 + n_vars = 200 + theta = 3 + X = matrix(stats::rnorm(n_obs * n_vars), nrow = n_obs, ncol = n_vars) + d = X[, 1:3, drop = FALSE] %*% c(5, 5, 5) + stats::rnorm(n_obs) + y = theta * d + X[, 1:3, drop = FALSE] %*% c(5, 5, 5) + stats::rnorm(n_obs) + dml_data = double_ml_data_from_matrix(X = X, y = y, d = d) + + # Define learner in a pipeline + set.seed(1234) + lasso_pipe = po("learner", + learner = lrn("regr.glmnet")) + ml_g = as_learner(lasso_pipe) + ml_m = as_learner(lasso_pipe) + + # Instantiate a DoubleML object + dml_plr_obj = DoubleMLPLR$new(dml_data, ml_g, ml_m) + + # Parameter grid for lambda + par_grids = ps(regr.glmnet.lambda = p_dbl(lower = 0.05, upper = 0.1)) + + tune_settings = list(terminator = trm("evals", n_evals = 100), + algorithm = tnr("grid_search", resolution = 10), + rsmp_tune = rsmp("cv", folds = 5), + measure = list("ml_g" = msr("regr.mse"), + "ml_m" = msr("regr.mse"))) + dml_plr_obj$tune(param_set = list("ml_g" = par_grids, + "ml_m" = par_grids), + tune_settings=tune_settings, + tune_on_fold=TRUE) + dml_plr_obj$fit() + dml_plr_obj$summary() + +References +++++++++++ + +* Lang, M., Binder, M., Richter, J., Schratz, P., Pfisterer, F., Coors, S., Au, Q., Casalicchio, G., Kotthoff, L., Bischl, B. (2019), mlr3: A modern object-oriented machine learing framework in R. Journal of Open Source Software, `doi:10.21105/joss.01903 `_. + +* Becker, M., Binder, M., Bischl, B., Lang, M., Pfisterer, F., Reich, N.G., Richter, J., Schratz, P., Sonabend, R. (2020), mlr3 book, available at `https://mlr3book.mlr-org.com `_. diff --git a/doc/guide/learners/r/tune_hyperparams.rst b/doc/guide/learners/r/tune_hyperparams.rst new file mode 100644 index 00000000..8567794c --- /dev/null +++ b/doc/guide/learners/r/tune_hyperparams.rst @@ -0,0 +1,177 @@ +Parameter tuning of learners for the nuisance functions of :ref:`DoubleML ` models can be done via the ``tune()`` method. +The ``tune()`` method passes various options and parameters to the tuning interface provided by the +`mlr3tuning `_ package. The `mlr3 book `_ provides a +`step-by-step introduction to parameter tuning `_. + +To illustrate the parameter tuning, we generate data from a sparse partially linear regression model. + +.. tab-set:: + + .. tab-item:: R + :sync: r + + .. jupyter-execute:: + + library(DoubleML) + library(mlr3) + library(data.table) + + set.seed(3141) + n_obs = 200 + n_vars = 200 + theta = 3 + X = matrix(stats::rnorm(n_obs * n_vars), nrow = n_obs, ncol = n_vars) + d = X[, 1:3, drop = FALSE] %*% c(5, 5, 5) + stats::rnorm(n_obs) + y = theta * d + X[, 1:3, drop = FALSE] %*% c(5, 5, 5) + stats::rnorm(n_obs) + dml_data = double_ml_data_from_matrix(X = X, y = y, d = d) + +The hyperparameter-tuning is performed according to options passed through a named list ``tune_settings``. +The entries in the list specify options during parameter tuning with `mlr3tuning `_: + +* ``terminator`` is a `Terminator object `_ passed to + `mlr3tuning `_ that manages the budget to solve the tuning problem. +* ``algorithm`` is an object of class + `Tuner `_ and specifies the tuning algorithm. + Alternatively, ``algorithm`` can be a ``character()`` that is used as an argument in the wrapper + `mlr3tuning `_ call + `tnr(algorithm) `_. + `The corresponding chapter in the mlr3book `_ illustrates + how the `Tuner `_ class supports grid search, random search, + generalized simulated annealing and non-linear optimization. +* ``rsmp_tune`` is an object of class `mlr3 resampling `_ + that specifies the resampling method for evaluation, for example `rsmp("cv", folds = 5)` implements 5-fold cross-validation. + `rsmp("holdout", ratio = 0.8)` implements an evaluation based on a hold-out sample that contains 20 percent of the observations. + By default, 5-fold cross-validation is performed. +* ``measure`` is a named list containing the measures used for tuning of the nuisance components. + The names of the entries must match the learner names (see method ``learner_names()``). The entries in the list must either be + objects of class `Measure `_ or keys passed to `msr() `_. + If ``measure`` is not provided by the user, default measures are used, i.e., mean squared error for regression models + and classification error for binary outcomes. + +In the following example, we tune the penalty parameter :math:`\lambda` (``lambda``) for lasso with the R package +`glmnet `_. To tune the value of ``lambda``, a grid search is performed over a grid of values that range from 0.05 +to 0.1 at a resolution of 10. Using a resolution of 10 splits the grid of values in 10 equally spaced values ranging from a minimum of 0.05 +to a maximum of 0.1. To evaluate the predictive performance in both nuisance parts, the cross-validated mean squared error is used. + +Setting the option ``tune_on_folds=FALSE``, the tuning is performed on the whole sample. Hence, the cross-validated errors +are obtained from a random split of the whole sample into 5 folds. As a result, one set of ``lambda`` values are obtained +which are later used in the fitting stage for all folds. + +Alternatively, setting the option ``tune_on_folds=TRUE`` would assign the tuning resampling scheme ``rsmp_tune`` to each fold. +For example, if we set ``n_folds=2`` at initialization of the ``DoubleMLPLR`` object and use a 5-fold cross-validated error +for tuning, each of the two folds would be split up into 5 subfolds and the error would be evaluated on these subfolds. + + +.. tab-set:: + + .. tab-item:: R + :sync: r + + .. jupyter-execute:: + + library(DoubleML) + library(mlr3) + library(data.table) + library(mlr3learners) + library(mlr3tuning) + library(paradox) + lgr::get_logger("mlr3")$set_threshold("warn") + lgr::get_logger("bbotk")$set_threshold("warn") + + set.seed(1234) + ml_l = lrn("regr.glmnet") + ml_m = lrn("regr.glmnet") + dml_plr_obj = DoubleMLPLR$new(dml_data, ml_l, ml_m) + + par_grids = list( + "ml_l" = ps(lambda = p_dbl(lower = 0.05, upper = 0.1)), + "ml_m" = ps(lambda = p_dbl(lower = 0.05, upper = 0.1))) + + tune_settings = list(terminator = trm("evals", n_evals = 100), + algorithm = tnr("grid_search", resolution = 10), + rsmp_tune = rsmp("cv", folds = 5), + measure = list("ml_l" = msr("regr.mse"), + "ml_m" = msr("regr.mse"))) + dml_plr_obj$tune(param_set=par_grids, tune_settings=tune_settings, tune_on_fold=TRUE) + dml_plr_obj$params + + dml_plr_obj$fit() + dml_plr_obj$summary() + + +Hyperparameter tuning can also be done with more sophisticated methods, for example by using built-in tuning +paths of learners. For example, the learner `regr.cv_glmnet `_ +performs an internal cross-validated choice of the parameter ``lambda``. +Alternatively, the powerful functionalities of the `mlr3tuning `_ package can be used for +external parameter tuning of the nuisance parts. The optimally chosen parameters can then be passed to the +:ref:`DoubleML ` models using the ``set_ml_nuisance_params()`` method. + +.. tab-set:: + + .. tab-item:: R + :sync: r + + .. jupyter-execute:: + + library(DoubleML) + library(mlr3) + library(data.table) + library(mlr3learners) + library(mlr3tuning) + lgr::get_logger("mlr3")$set_threshold("warn") + lgr::get_logger("bbotk")$set_threshold("warn") + + set.seed(1234) + ml_l = lrn("regr.cv_glmnet", s="lambda.min") + ml_m = lrn("regr.cv_glmnet", s="lambda.min") + dml_plr_obj = DoubleMLPLR$new(dml_data, ml_l, ml_m) + + dml_plr_obj$fit() + dml_plr_obj$summary() + + +The following code chunk illustrates another example for global parameter tuning with random forests +as provided by the `ranger `_ package. In this example, we use random search to find optimal +parameters ``mtry`` and ``max.depth`` of a random forest. Evaluation is based on 3-fold cross-validation. + +.. tab-set:: + + .. tab-item:: R + :sync: r + + .. jupyter-execute:: + + library(DoubleML) + library(mlr3) + library(mlr3learners) + library(data.table) + library(mlr3tuning) + library(paradox) + lgr::get_logger("mlr3")$set_threshold("warn") + lgr::get_logger("bbotk")$set_threshold("warn") + + # set up a mlr3 learner + learner = lrn("regr.ranger") + ml_l = learner$clone() + ml_m = learner$clone() + + set.seed(3141) + obj_dml_data = make_plr_CCDDHNR2018(alpha=0.5) + dml_plr_obj = DoubleMLPLR$new(obj_dml_data, ml_l, ml_m) + + # set up a list of parameter grids + param_grid = list("ml_l" = ps(mtry = p_int(lower = 2 , upper = 20), + max.depth = p_int(lower = 2, upper = 5)), + "ml_m" = ps(mtry = p_int(lower = 2 , upper = 20), + max.depth = p_int(lower = 2, upper = 5))) + + tune_settings = list(terminator = mlr3tuning::trm("evals", n_evals = 20), + algorithm = tnr("random_search"), + rsmp_tune = rsmp("cv", folds = 3), + measure = list("ml_l" = msr("regr.mse"), + "ml_m" = msr("regr.mse"))) + dml_plr_obj$tune(param_set=param_grid, tune_settings=tune_settings, tune_on_folds=FALSE) + dml_plr_obj$params + + dml_plr_obj$fit() + dml_plr_obj$summary() \ No newline at end of file From bbdb67c9be5bf9701ae181a735e656cc8fb994db Mon Sep 17 00:00:00 2001 From: SvenKlaassen Date: Sun, 16 Nov 2025 13:06:41 +0000 Subject: [PATCH 06/11] update optuna nb --- doc/examples/learners/py_optuna.ipynb | 5899 ++++++++++++++++++++++++- 1 file changed, 5817 insertions(+), 82 deletions(-) diff --git a/doc/examples/learners/py_optuna.ipynb b/doc/examples/learners/py_optuna.ipynb index df9b8b0e..729cd376 100644 --- a/doc/examples/learners/py_optuna.ipynb +++ b/doc/examples/learners/py_optuna.ipynb @@ -341,7 +341,9 @@ " 'n_estimators': 100,\n", " 'learning_rate': trial.suggest_float('learning_rate', 0.005, 0.1),\n", " 'max_depth': trial.suggest_int('max_depth', 2, 5),\n", - " 'min_child_samples': trial.suggest_int('min_child_samples', 5, 100),\n", + " 'min_child_samples': trial.suggest_int('min_child_samples', 20, 100, step=10),\n", + " 'lambda_l1': trial.suggest_float('lambda_l1', 1e-8, 10.0, log=True),\n", + " 'lambda_l2': trial.suggest_float('lambda_l2', 1e-8, 10.0, log=True),\n", " }\n", "\n", "# parameter space for the propensity score tuning\n", @@ -350,7 +352,9 @@ " 'n_estimators': 100,\n", " 'learning_rate': trial.suggest_float('learning_rate', 0.005, 0.1),\n", " 'max_depth': trial.suggest_int('max_depth', 2, 5),\n", - " 'min_child_samples': trial.suggest_int('min_child_samples', 5, 100),\n", + " 'min_child_samples': trial.suggest_int('min_child_samples', 20, 100, step=10),\n", + " 'lambda_l1': trial.suggest_float('lambda_l1', 1e-8, 10.0, log=True),\n", + " 'lambda_l2': trial.suggest_float('lambda_l2', 1e-8, 10.0, log=True),\n", " }\n", "\n", "param_space = {\n", @@ -375,23 +379,63 @@ "metadata": {}, "outputs": [ { - "ename": "TypeError", - "evalue": "_dml_tune_optuna() missing 1 required positional argument: 'params_name'", - "output_type": "error", - "traceback": [ - "\u001b[31m---------------------------------------------------------------------------\u001b[39m", - "\u001b[31mTypeError\u001b[39m Traceback (most recent call last)", - "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[8]\u001b[39m\u001b[32m, line 6\u001b[39m\n\u001b[32m 1\u001b[39m optuna_settings = {\n\u001b[32m 2\u001b[39m \u001b[33m'\u001b[39m\u001b[33mn_trials\u001b[39m\u001b[33m'\u001b[39m: \u001b[32m100\u001b[39m,\n\u001b[32m 3\u001b[39m \u001b[33m'\u001b[39m\u001b[33mshow_progress_bar\u001b[39m\u001b[33m'\u001b[39m: \u001b[38;5;28;01mTrue\u001b[39;00m,\n\u001b[32m 4\u001b[39m }\n\u001b[32m----> \u001b[39m\u001b[32m6\u001b[39m \u001b[43mdml_obj_tuned\u001b[49m\u001b[43m.\u001b[49m\u001b[43mtune_ml_models\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 7\u001b[39m \u001b[43m \u001b[49m\u001b[43mml_param_space\u001b[49m\u001b[43m=\u001b[49m\u001b[43mparam_space\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 8\u001b[39m \u001b[43m \u001b[49m\u001b[43moptuna_settings\u001b[49m\u001b[43m=\u001b[49m\u001b[43moptuna_settings\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 9\u001b[39m \u001b[43m)\u001b[49m\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/.venv/lib/python3.12/site-packages/doubleml/double_ml.py:1119\u001b[39m, in \u001b[36mDoubleML.tune_ml_models\u001b[39m\u001b[34m(self, ml_param_space, scoring_methods, cv, set_as_params, return_tune_res, optuna_settings)\u001b[39m\n\u001b[32m 1116\u001b[39m \u001b[38;5;28mself\u001b[39m._dml_data.set_x_d(\u001b[38;5;28mself\u001b[39m._dml_data.d_cols[i_d])\n\u001b[32m 1118\u001b[39m \u001b[38;5;66;03m# tune hyperparameters (globally, not fold-specific)\u001b[39;00m\n\u001b[32m-> \u001b[39m\u001b[32m1119\u001b[39m res = \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_nuisance_tuning_optuna\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 1120\u001b[39m \u001b[43m \u001b[49m\u001b[43mexpanded_param_space\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1121\u001b[39m \u001b[43m \u001b[49m\u001b[43mscoring_methods\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1122\u001b[39m \u001b[43m \u001b[49m\u001b[43mcv_splitter\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1123\u001b[39m \u001b[43m \u001b[49m\u001b[43moptuna_settings\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1124\u001b[39m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 1126\u001b[39m filtered_results = {key: value \u001b[38;5;28;01mfor\u001b[39;00m key, value \u001b[38;5;129;01min\u001b[39;00m res.items() \u001b[38;5;28;01mif\u001b[39;00m key \u001b[38;5;129;01min\u001b[39;00m requested_learners}\n\u001b[32m 1127\u001b[39m tuning_res[i_d] = filtered_results\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/.venv/lib/python3.12/site-packages/doubleml/irm/apo.py:484\u001b[39m, in \u001b[36mDoubleMLAPO._nuisance_tuning_optuna\u001b[39m\u001b[34m(self, optuna_params, scoring_methods, cv, optuna_settings)\u001b[39m\n\u001b[32m 482\u001b[39m g_lvl0_param_grid = optuna_params[\u001b[33m\"\u001b[39m\u001b[33mml_g_d_lvl0\u001b[39m\u001b[33m\"\u001b[39m]\n\u001b[32m 483\u001b[39m g_lvl0_scoring = scoring_methods[\u001b[33m\"\u001b[39m\u001b[33mml_g_d_lvl0\u001b[39m\u001b[33m\"\u001b[39m]\n\u001b[32m--> \u001b[39m\u001b[32m484\u001b[39m g_d_lvl0_tune_res = \u001b[43m_dml_tune_optuna\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 485\u001b[39m \u001b[43m \u001b[49m\u001b[43my_lvl0\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 486\u001b[39m \u001b[43m \u001b[49m\u001b[43mdx_lvl0\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 487\u001b[39m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_learner\u001b[49m\u001b[43m[\u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43mml_g\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 488\u001b[39m \u001b[43m \u001b[49m\u001b[43mg_lvl0_param_grid\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 489\u001b[39m \u001b[43m \u001b[49m\u001b[43mg_lvl0_scoring\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 490\u001b[39m \u001b[43m \u001b[49m\u001b[43mcv\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 491\u001b[39m \u001b[43m \u001b[49m\u001b[43moptuna_settings\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 492\u001b[39m \u001b[43m \u001b[49m\u001b[43mlearner_name\u001b[49m\u001b[43m=\u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43mml_g_d_lvl0\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[32m 493\u001b[39m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 495\u001b[39m x_lvl1 = x[mask_lvl1, :]\n\u001b[32m 496\u001b[39m y_lvl1 = y[mask_lvl1]\n", - "\u001b[31mTypeError\u001b[39m: _dml_tune_optuna() missing 1 required positional argument: 'params_name'" - ] + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "2fa57cead0704b7ba184153ae5450323", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/100 [00:00" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ "optuna_settings = {\n", " 'n_trials': 100,\n", " 'show_progress_bar': True,\n", + " 'verbosity': optuna.logging.WARNING, # Suppress Optuna logs\n", "}\n", "\n", "dml_obj_tuned.tune_ml_models(\n", @@ -410,9 +454,62 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
coefstd errtP>|t|2.5 %97.5 %
d215.4777332.50568885.9954250.0210.566674220.388792
\n", + "
" + ], + "text/plain": [ + " coef std err t P>|t| 2.5 % 97.5 %\n", + "d 215.477733 2.505688 85.995425 0.0 210.566674 220.388792" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "dml_obj_tuned.fit()\n", "dml_obj_tuned.summary" @@ -430,10 +527,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "id": "31a70f0a", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "['ml_g_d_lvl0', 'ml_g_d_lvl1', 'ml_m']" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "dml_obj_tuned.params_names" ] @@ -448,10 +556,95 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "id": "35aaf050", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "{'ml_g_d_lvl0': {'d': [[{'learning_rate': 0.0925852079401175,\n", + " 'max_depth': 4,\n", + " 'min_child_samples': 20,\n", + " 'lambda_l1': 5.506751245050714e-08,\n", + " 'lambda_l2': 1.8546099728188138e-07},\n", + " {'learning_rate': 0.0925852079401175,\n", + " 'max_depth': 4,\n", + " 'min_child_samples': 20,\n", + " 'lambda_l1': 5.506751245050714e-08,\n", + " 'lambda_l2': 1.8546099728188138e-07},\n", + " {'learning_rate': 0.0925852079401175,\n", + " 'max_depth': 4,\n", + " 'min_child_samples': 20,\n", + " 'lambda_l1': 5.506751245050714e-08,\n", + " 'lambda_l2': 1.8546099728188138e-07},\n", + " {'learning_rate': 0.0925852079401175,\n", + " 'max_depth': 4,\n", + " 'min_child_samples': 20,\n", + " 'lambda_l1': 5.506751245050714e-08,\n", + " 'lambda_l2': 1.8546099728188138e-07},\n", + " {'learning_rate': 0.0925852079401175,\n", + " 'max_depth': 4,\n", + " 'min_child_samples': 20,\n", + " 'lambda_l1': 5.506751245050714e-08,\n", + " 'lambda_l2': 1.8546099728188138e-07}]]},\n", + " 'ml_g_d_lvl1': {'d': [[{'learning_rate': 0.06559593641941427,\n", + " 'max_depth': 4,\n", + " 'min_child_samples': 20,\n", + " 'lambda_l1': 9.379298410790415e-05,\n", + " 'lambda_l2': 0.4512927507791765},\n", + " {'learning_rate': 0.06559593641941427,\n", + " 'max_depth': 4,\n", + " 'min_child_samples': 20,\n", + " 'lambda_l1': 9.379298410790415e-05,\n", + " 'lambda_l2': 0.4512927507791765},\n", + " {'learning_rate': 0.06559593641941427,\n", + " 'max_depth': 4,\n", + " 'min_child_samples': 20,\n", + " 'lambda_l1': 9.379298410790415e-05,\n", + " 'lambda_l2': 0.4512927507791765},\n", + " {'learning_rate': 0.06559593641941427,\n", + " 'max_depth': 4,\n", + " 'min_child_samples': 20,\n", + " 'lambda_l1': 9.379298410790415e-05,\n", + " 'lambda_l2': 0.4512927507791765},\n", + " {'learning_rate': 0.06559593641941427,\n", + " 'max_depth': 4,\n", + " 'min_child_samples': 20,\n", + " 'lambda_l1': 9.379298410790415e-05,\n", + " 'lambda_l2': 0.4512927507791765}]]},\n", + " 'ml_m': {'d': [[{'learning_rate': 0.009250177700256199,\n", + " 'max_depth': 5,\n", + " 'min_child_samples': 100,\n", + " 'lambda_l1': 1.8316548720527778e-05,\n", + " 'lambda_l2': 9.614068806036798},\n", + " {'learning_rate': 0.009250177700256199,\n", + " 'max_depth': 5,\n", + " 'min_child_samples': 100,\n", + " 'lambda_l1': 1.8316548720527778e-05,\n", + " 'lambda_l2': 9.614068806036798},\n", + " {'learning_rate': 0.009250177700256199,\n", + " 'max_depth': 5,\n", + " 'min_child_samples': 100,\n", + " 'lambda_l1': 1.8316548720527778e-05,\n", + " 'lambda_l2': 9.614068806036798},\n", + " {'learning_rate': 0.009250177700256199,\n", + " 'max_depth': 5,\n", + " 'min_child_samples': 100,\n", + " 'lambda_l1': 1.8316548720527778e-05,\n", + " 'lambda_l2': 9.614068806036798},\n", + " {'learning_rate': 0.009250177700256199,\n", + " 'max_depth': 5,\n", + " 'min_child_samples': 100,\n", + " 'lambda_l1': 1.8316548720527778e-05,\n", + " 'lambda_l2': 9.614068806036798}]]}}" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "dml_obj_tuned.params" ] @@ -468,20 +661,46 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "id": "20a95719", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "{'ml_g_d_lvl0': array([[14.49934441]]),\n", + " 'ml_g_d_lvl1': array([[23.50828321]]),\n", + " 'ml_m': array([[0.44349955]])}" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "dml_obj_untuned.evaluate_learners()" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "id": "68e08448", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "{'ml_g_d_lvl0': array([[14.29125279]]),\n", + " 'ml_g_d_lvl1': array([[23.19262364]]),\n", + " 'ml_m': array([[0.4100839]])}" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "dml_obj_tuned.evaluate_learners()" ] @@ -496,20 +715,46 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "id": "f594a9f7", - "metadata": {}, - "outputs": [], + "metadata": { + "tags": [ + "hide-input" + ] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "True APO at treatment level 1.0: 213.4904\n", + "\n", + " Model theta se ci_lower ci_upper\n", + "Untuned 211.232659 15.657431 180.544657 241.920661\n", + " Tuned 215.477733 2.505688 210.566674 220.388792\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "theta_untuned = dml_obj_untuned.coef[0]\n", - "theta_tuned = dml_obj_tuned.coef[0]\n", "ci_untuned = dml_obj_untuned.confint()\n", "ci_tuned = dml_obj_tuned.confint()\n", "\n", "# Create comparison dataframe\n", "comparison_data = {\n", " 'Model': ['Untuned', 'Tuned'],\n", - " 'theta': [theta_untuned, theta_tuned],\n", + " 'theta': [dml_obj_untuned.coef[0], dml_obj_tuned.coef[0]],\n", + " 'se': [dml_obj_untuned.se[0], dml_obj_tuned.se[0]],\n", " 'ci_lower': [ci_untuned.iloc[0, 0], ci_tuned.iloc[0, 0]],\n", " 'ci_upper': [ci_untuned.iloc[0, 1], ci_tuned.iloc[0, 1]]\n", "}\n", @@ -563,10 +808,463 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "id": "76937e73", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
Pipeline(steps=[('scaler', RobustScaler()),\n",
+       "                ('stacking',\n",
+       "                 StackingRegressor(estimators=[('linear_regression',\n",
+       "                                                LinearRegression()),\n",
+       "                                               ('lgbm',\n",
+       "                                                LGBMRegressor(random_state=42,\n",
+       "                                                              verbose=-1))],\n",
+       "                                   final_estimator=Ridge()))])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ], + "text/plain": [ + "Pipeline(steps=[('scaler', RobustScaler()),\n", + " ('stacking',\n", + " StackingRegressor(estimators=[('linear_regression',\n", + " LinearRegression()),\n", + " ('lgbm',\n", + " LGBMRegressor(random_state=42,\n", + " verbose=-1))],\n", + " final_estimator=Ridge()))])" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "base_regressors = [\n", " ('linear_regression', LinearRegression()),\n", @@ -581,15 +1279,469 @@ "ml_g_pipeline = Pipeline([\n", " ('scaler', RobustScaler()),\n", " ('stacking', stacking_regressor)\n", - "])" + "])\n", + "ml_g_pipeline" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "id": "395bb00f", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
Pipeline(steps=[('scaler', RobustScaler()),\n",
+       "                ('stacking',\n",
+       "                 StackingRegressor(estimators=[('linear_regression',\n",
+       "                                                LinearRegression()),\n",
+       "                                               ('lgbm',\n",
+       "                                                LGBMRegressor(random_state=42,\n",
+       "                                                              verbose=-1))],\n",
+       "                                   final_estimator=Ridge()))])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ], + "text/plain": [ + "Pipeline(steps=[('scaler', RobustScaler()),\n", + " ('stacking',\n", + " StackingRegressor(estimators=[('linear_regression',\n", + " LinearRegression()),\n", + " ('lgbm',\n", + " LGBMRegressor(random_state=42,\n", + " verbose=-1))],\n", + " final_estimator=Ridge()))])" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "base_classifiers = [\n", " ('logistic_regression', LogisticRegression(max_iter=1000, random_state=42)),\n", @@ -604,7 +1756,8 @@ "ml_m_pipeline = Pipeline([\n", " ('scaler', RobustScaler()),\n", " ('stacking', stacking_classifier)\n", - "])" + "])\n", + "ml_g_pipeline" ] }, { @@ -619,10 +1772,63 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "id": "cbf47ae5", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
coefstd errtP>|t|2.5 %97.5 %
d213.5128852.33512591.4353060.0208.936124218.089647
\n", + "
" + ], + "text/plain": [ + " coef std err t P>|t| 2.5 % 97.5 %\n", + "d 213.512885 2.335125 91.435306 0.0 208.936124 218.089647" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "dml_obj_untuned_pipeline = DoubleMLAPO(\n", " dml_data,\n", @@ -647,7 +1853,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "id": "c33bf5f1", "metadata": {}, "outputs": [], @@ -673,7 +1879,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "id": "d88d60a0", "metadata": {}, "outputs": [], @@ -682,20 +1888,24 @@ "def ml_g_params_pipeline(trial):\n", " return {\n", " 'stacking__lgbm__n_estimators': 100,\n", - " 'stacking__lgbm__learning_rate': trial.suggest_float('learning_rate', 0.005, 0.1),\n", - " 'stacking__lgbm__max_depth': trial.suggest_int('max_depth', 2, 5),\n", - " 'stacking__lgbm__min_child_samples': trial.suggest_int('min_child_samples', 5, 100),\n", - " 'stacking__final_estimator__alpha': trial.suggest_float('alpha', 0.001, 10.0, log=True),\n", + " 'stacking__lgbm__learning_rate': trial.suggest_float('stacking__lgbm__learning_rate', 0.005, 0.1),\n", + " 'stacking__lgbm__max_depth': trial.suggest_int('stacking__lgbm__max_depth', 2, 5),\n", + " 'stacking__lgbm__min_child_samples': trial.suggest_int('stacking__lgbm__min_child_samples', 20, 100, step=10),\n", + " 'stacking__lgbm__lambda_l1': trial.suggest_float('stacking__lgbm__lambda_l1', 1e-8, 10.0, log=True),\n", + " 'stacking__lgbm__lambda_l2': trial.suggest_float('stacking__lgbm__lambda_l2', 1e-8, 10.0, log=True),\n", + " 'stacking__final_estimator__alpha': trial.suggest_float('stacking__final_estimator__alpha', 0.001, 10.0, log=True),\n", " }\n", "\n", "# parameter space for the propensity score tuning\n", "def ml_m_params_pipeline(trial):\n", " return {\n", " 'stacking__lgbm__n_estimators': 100,\n", - " 'stacking__lgbm__learning_rate': trial.suggest_float('learning_rate', 0.005, 0.1),\n", - " 'stacking__lgbm__max_depth': trial.suggest_int('max_depth', 2, 5),\n", - " 'stacking__lgbm__min_child_samples': trial.suggest_int('min_child_samples', 5, 100),\n", - " 'stacking__final_estimator__C': trial.suggest_float('C', 0.01, 100.0, log=True),\n", + " 'stacking__lgbm__learning_rate': trial.suggest_float('stacking__lgbm__learning_rate', 0.005, 0.1),\n", + " 'stacking__lgbm__max_depth': trial.suggest_int('stacking__lgbm__max_depth', 2, 5),\n", + " 'stacking__lgbm__min_child_samples': trial.suggest_int('stacking__lgbm__min_child_samples', 20, 100, step=10),\n", + " 'stacking__lgbm__lambda_l1': trial.suggest_float('stacking__lgbm__lambda_l1', 1e-8, 10.0, log=True),\n", + " 'stacking__lgbm__lambda_l2': trial.suggest_float('stacking__lgbm__lambda_l2', 1e-8, 10.0, log=True),\n", + " 'stacking__final_estimator__C': trial.suggest_float('stacking__final_estimator__C', 0.01, 100.0, log=True),\n", " 'stacking__final_estimator__max_iter': 1000,\n", " }\n", "\n", @@ -718,17 +1928,15 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "vscode": { - "languageId": "javascript" - } - }, + "execution_count": 20, + "id": "742d903f", + "metadata": {}, "outputs": [], "source": [ "optuna_settings_pipeline = {\n", " 'n_trials': 100,\n", " 'show_progress_bar': True,\n", + " 'verbosity': optuna.logging.WARNING, # Suppress Optuna logs\n", " 'ml_g': {\n", " 'n_trials': 50\n", " }\n", @@ -747,12 +1955,55 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "id": "8468d9fd", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a20733dd0e6946e499718dc4b5d2e027", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/50 [00:00\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
coefstd errtP>|t|2.5 %97.5 %
d213.930022.29280693.3048870.0209.436202218.423837
\n", + "" + ], + "text/plain": [ + " coef std err t P>|t| 2.5 % 97.5 %\n", + "d 213.93002 2.292806 93.304887 0.0 209.436202 218.423837" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "dml_obj_tuned_pipeline.fit()\n", "dml_obj_tuned_pipeline.summary" @@ -788,17 +2092,40 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 23, "id": "deb5359c", - "metadata": {}, - "outputs": [], + "metadata": { + "tags": [ + "hide-input" + ] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "True APO at treatment level 1.0: 213.4904\n", + "\n", + " Model theta se ci_lower ci_upper\n", + " Untuned 211.232659 15.657431 180.544657 241.920661\n", + " Tuned 215.477733 2.505688 210.566674 220.388792\n", + "Untuned Pipeline 213.512885 2.335125 208.936124 218.089647\n", + " Tuned Pipeline 213.930020 2.292806 209.436202 218.423837\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "# Extract coefficients and confidence intervals for all models\n", - "theta_untuned = dml_obj_untuned.coef[0]\n", - "theta_tuned = dml_obj_tuned.coef[0]\n", - "theta_untuned_pipeline = dml_obj_untuned_pipeline.coef[0]\n", - "theta_tuned_pipeline = dml_obj_tuned_pipeline.coef[0]\n", - "\n", "ci_untuned = dml_obj_untuned.confint()\n", "ci_tuned = dml_obj_tuned.confint()\n", "ci_untuned_pipeline = dml_obj_untuned_pipeline.confint()\n", @@ -807,7 +2134,8 @@ "# Create comparison dataframe\n", "comparison_data = {\n", " 'Model': ['Untuned', 'Tuned', 'Untuned Pipeline', 'Tuned Pipeline'],\n", - " 'theta': [theta_untuned, theta_tuned, theta_untuned_pipeline, theta_tuned_pipeline],\n", + " 'theta': [dml_obj_untuned.coef[0], dml_obj_tuned.coef[0], dml_obj_untuned_pipeline.coef[0], dml_obj_tuned_pipeline.coef[0]],\n", + " 'se': [dml_obj_untuned.se[0], dml_obj_tuned.se[0], dml_obj_untuned_pipeline.se[0], dml_obj_tuned_pipeline.se[0]],\n", " 'ci_lower': [ci_untuned.iloc[0, 0], ci_tuned.iloc[0, 0], \n", " ci_untuned_pipeline.iloc[0, 0], ci_tuned_pipeline.iloc[0, 0]],\n", " 'ci_upper': [ci_untuned.iloc[0, 1], ci_tuned.iloc[0, 1],\n", @@ -854,13 +2182,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 24, "id": "41cbd33f", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dict_keys(['ml_g_d_lvl0', 'ml_g_d_lvl1', 'ml_m'])\n" + ] + } + ], "source": [ "# Optuna results for the single treatment\n", - "print(tuning_results[0])" + "print(tuning_results[0].keys())" ] }, { @@ -873,10 +2209,32 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 25, "id": "94e92730", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "================== DMLOptunaResult ==================\n", + "Learner name: ml_m\n", + "Params name: ml_m\n", + "Tuned: True\n", + "Best score: -0.5200200362819768\n", + "Scoring method: neg_log_loss\n", + "\n", + "------------------ Best parameters ------------------\n", + "{'stacking__final_estimator__C': 64.258365026295,\n", + " 'stacking__lgbm__lambda_l1': 6.912832115095844e-07,\n", + " 'stacking__lgbm__lambda_l2': 5.777318708196959e-07,\n", + " 'stacking__lgbm__learning_rate': 0.05065442786589058,\n", + " 'stacking__lgbm__max_depth': 2,\n", + " 'stacking__lgbm__min_child_samples': 50}\n", + "\n" + ] + } + ], "source": [ "print(tuning_results[0]['ml_m'])" ] @@ -891,12 +2249,305 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 26, "id": "fe4c6e84", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
numbervalue_neg_log_loss_ml_mdatetime_startdatetime_completedurationparams_stacking__final_estimator__Cparams_stacking__lgbm__lambda_l1params_stacking__lgbm__lambda_l2params_stacking__lgbm__learning_rateparams_stacking__lgbm__max_depthparams_stacking__lgbm__min_child_samplesstate
00-0.5246672025-11-16 13:03:57.0118762025-11-16 13:03:57.4041290 days 00:00:00.39225337.7357037.602356e-031.779912e-010.050607490COMPLETE
11-0.5268562025-11-16 13:03:57.4048422025-11-16 13:03:57.7532940 days 00:00:00.3484520.4300924.768254e-028.455216e-060.099470290COMPLETE
22-0.5229932025-11-16 13:03:57.7539042025-11-16 13:03:58.2883880 days 00:00:00.53448413.8763632.985171e-015.722090e-080.040414370COMPLETE
33-0.5237862025-11-16 13:03:58.2891912025-11-16 13:03:58.6726890 days 00:00:00.38349814.6298542.704791e-041.035993e-070.009606590COMPLETE
44-0.5252982025-11-16 13:03:58.6735012025-11-16 13:03:59.1024900 days 00:00:00.42898963.9392092.114057e-071.240781e-020.087911220COMPLETE
.......................................
9595-0.5213732025-11-16 13:04:40.2985382025-11-16 13:04:40.6947900 days 00:00:00.39625276.2952811.324351e-082.290295e-020.038527240COMPLETE
9696-0.5219022025-11-16 13:04:40.6956362025-11-16 13:04:41.0974480 days 00:00:00.40181249.8694864.130104e-081.851580e-010.025975250COMPLETE
9797-0.5211882025-11-16 13:04:41.0981142025-11-16 13:04:41.5233630 days 00:00:00.42524962.6242286.794990e-083.302448e-030.035261250COMPLETE
9898-0.5281832025-11-16 13:04:41.5243332025-11-16 13:04:41.8309310 days 00:00:00.3065980.1613752.251480e-084.756110e-020.043396240COMPLETE
9999-0.5218352025-11-16 13:04:41.8317022025-11-16 13:04:42.2443790 days 00:00:00.41267798.4544148.809690e-083.087345e-010.037223260COMPLETE
\n", + "

100 rows × 12 columns

\n", + "
" + ], + "text/plain": [ + " number value_neg_log_loss_ml_m datetime_start \\\n", + "0 0 -0.524667 2025-11-16 13:03:57.011876 \n", + "1 1 -0.526856 2025-11-16 13:03:57.404842 \n", + "2 2 -0.522993 2025-11-16 13:03:57.753904 \n", + "3 3 -0.523786 2025-11-16 13:03:58.289191 \n", + "4 4 -0.525298 2025-11-16 13:03:58.673501 \n", + ".. ... ... ... \n", + "95 95 -0.521373 2025-11-16 13:04:40.298538 \n", + "96 96 -0.521902 2025-11-16 13:04:40.695636 \n", + "97 97 -0.521188 2025-11-16 13:04:41.098114 \n", + "98 98 -0.528183 2025-11-16 13:04:41.524333 \n", + "99 99 -0.521835 2025-11-16 13:04:41.831702 \n", + "\n", + " datetime_complete duration \\\n", + "0 2025-11-16 13:03:57.404129 0 days 00:00:00.392253 \n", + "1 2025-11-16 13:03:57.753294 0 days 00:00:00.348452 \n", + "2 2025-11-16 13:03:58.288388 0 days 00:00:00.534484 \n", + "3 2025-11-16 13:03:58.672689 0 days 00:00:00.383498 \n", + "4 2025-11-16 13:03:59.102490 0 days 00:00:00.428989 \n", + ".. ... ... \n", + "95 2025-11-16 13:04:40.694790 0 days 00:00:00.396252 \n", + "96 2025-11-16 13:04:41.097448 0 days 00:00:00.401812 \n", + "97 2025-11-16 13:04:41.523363 0 days 00:00:00.425249 \n", + "98 2025-11-16 13:04:41.830931 0 days 00:00:00.306598 \n", + "99 2025-11-16 13:04:42.244379 0 days 00:00:00.412677 \n", + "\n", + " params_stacking__final_estimator__C params_stacking__lgbm__lambda_l1 \\\n", + "0 37.735703 7.602356e-03 \n", + "1 0.430092 4.768254e-02 \n", + "2 13.876363 2.985171e-01 \n", + "3 14.629854 2.704791e-04 \n", + "4 63.939209 2.114057e-07 \n", + ".. ... ... \n", + "95 76.295281 1.324351e-08 \n", + "96 49.869486 4.130104e-08 \n", + "97 62.624228 6.794990e-08 \n", + "98 0.161375 2.251480e-08 \n", + "99 98.454414 8.809690e-08 \n", + "\n", + " params_stacking__lgbm__lambda_l2 params_stacking__lgbm__learning_rate \\\n", + "0 1.779912e-01 0.050607 \n", + "1 8.455216e-06 0.099470 \n", + "2 5.722090e-08 0.040414 \n", + "3 1.035993e-07 0.009606 \n", + "4 1.240781e-02 0.087911 \n", + ".. ... ... \n", + "95 2.290295e-02 0.038527 \n", + "96 1.851580e-01 0.025975 \n", + "97 3.302448e-03 0.035261 \n", + "98 4.756110e-02 0.043396 \n", + "99 3.087345e-01 0.037223 \n", + "\n", + " params_stacking__lgbm__max_depth \\\n", + "0 4 \n", + "1 2 \n", + "2 3 \n", + "3 5 \n", + "4 2 \n", + ".. ... \n", + "95 2 \n", + "96 2 \n", + "97 2 \n", + "98 2 \n", + "99 2 \n", + "\n", + " params_stacking__lgbm__min_child_samples state \n", + "0 90 COMPLETE \n", + "1 90 COMPLETE \n", + "2 70 COMPLETE \n", + "3 90 COMPLETE \n", + "4 20 COMPLETE \n", + ".. ... ... \n", + "95 40 COMPLETE \n", + "96 50 COMPLETE \n", + "97 50 COMPLETE \n", + "98 40 COMPLETE \n", + "99 60 COMPLETE \n", + "\n", + "[100 rows x 12 columns]" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "ml_m_study = tuning_results[0]['ml_m'].study_\n", + "ml_m_study = tuning_results[0]['ml_m'].study\n", "ml_m_study.trials_dataframe()" ] }, @@ -910,10 +2561,1340 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 27, "id": "7d35c2c0", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + " \n", + " " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.plotly.v1+json": { + "config": { + "plotlyServerURL": "https://plot.ly" + }, + "data": [ + { + "mode": "markers", + "name": "Objective Value", + "type": "scatter", + "x": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99 + ], + "y": [ + -0.5246673792552463, + -0.5268557512025864, + -0.5229927690785134, + -0.5237855161338375, + -0.5252981901140042, + -0.52273244792942, + -0.524666782331119, + -0.5245695457469202, + -0.5251540646395005, + -0.5251291178426823, + -0.5289710502109296, + -0.5247921143255782, + -0.5253549457494395, + -0.5275932520217148, + -0.5239638780338305, + -0.5246703771705652, + -0.5283636662189845, + -0.523633950914645, + -0.524324698647204, + -0.5245380821586376, + -0.5247429081812913, + -0.5222458364643957, + -0.5221720017824713, + -0.5231919904716036, + -0.526542949858886, + -0.5240146874498702, + -0.5225719878462962, + -0.5219445246243672, + -0.5232228643862769, + -0.5219073270749999, + -0.5248065280576014, + -0.5205904731684051, + -0.5209872436975156, + -0.5219058138779911, + -0.5229868716795648, + -0.5266601887482448, + -0.5237710125218932, + -0.5223226611171666, + -0.5239149971092769, + -0.5210712896803376, + -0.5239851871691985, + -0.5212414018980125, + -0.5208471000119077, + -0.5233034524317859, + -0.5217054917158865, + -0.5200200362819768, + -0.5216847823588252, + -0.5225869673883817, + -0.5289771585191569, + -0.5216173176341884, + -0.5230319899849978, + -0.5217108288796505, + -0.524490866846455, + -0.5218549982101606, + -0.5285759551382639, + -0.5208436772168876, + -0.5217138803252707, + -0.5232781200269747, + -0.5208976669236429, + -0.5225290041827534, + -0.5236160997160445, + -0.5208989670677509, + -0.5208086561618462, + -0.5217746628708194, + -0.5213591864255526, + -0.5209341456336978, + -0.5226477164481265, + -0.5221191321911459, + -0.5290288935695759, + -0.5232951192077749, + -0.5238254695720768, + -0.5208550686378427, + -0.5207623106736918, + -0.5206276068811675, + -0.5222679788575139, + -0.5206002008520167, + -0.5219491896185355, + -0.5219366099099083, + -0.5239426947051072, + -0.5214153923793081, + -0.5263994832506056, + -0.5207983641258609, + -0.5203119996283405, + -0.5213196189246586, + -0.521705856325633, + -0.5202261605920173, + -0.520254335467055, + -0.5221153250156328, + -0.5203676037858227, + -0.5221132005388393, + -0.5218054433411432, + -0.5208801838819099, + -0.5202943658437768, + -0.520559132754211, + -0.5215889774753224, + -0.5213734798442939, + -0.5219021344169802, + -0.5211875129780074, + -0.5281831879435094, + -0.5218354361227235 + ] + }, + { + "mode": "lines", + "name": "Best Value", + "type": "scatter", + "x": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99 + ], + "y": [ + -0.5246673792552463, + -0.5246673792552463, + -0.5229927690785134, + -0.5229927690785134, + -0.5229927690785134, + -0.52273244792942, + -0.52273244792942, + -0.52273244792942, + -0.52273244792942, + -0.52273244792942, + -0.52273244792942, + -0.52273244792942, + -0.52273244792942, + -0.52273244792942, + -0.52273244792942, + -0.52273244792942, + -0.52273244792942, + -0.52273244792942, + -0.52273244792942, + -0.52273244792942, + -0.52273244792942, + -0.5222458364643957, + -0.5221720017824713, + -0.5221720017824713, + -0.5221720017824713, + -0.5221720017824713, + -0.5221720017824713, + -0.5219445246243672, + -0.5219445246243672, + -0.5219073270749999, + -0.5219073270749999, + -0.5205904731684051, + -0.5205904731684051, + -0.5205904731684051, + -0.5205904731684051, + -0.5205904731684051, + -0.5205904731684051, + -0.5205904731684051, + -0.5205904731684051, + -0.5205904731684051, + -0.5205904731684051, + -0.5205904731684051, + -0.5205904731684051, + -0.5205904731684051, + -0.5205904731684051, + -0.5200200362819768, + -0.5200200362819768, + -0.5200200362819768, + -0.5200200362819768, + -0.5200200362819768, + -0.5200200362819768, + -0.5200200362819768, + -0.5200200362819768, + -0.5200200362819768, + -0.5200200362819768, + -0.5200200362819768, + -0.5200200362819768, + -0.5200200362819768, + -0.5200200362819768, + -0.5200200362819768, + -0.5200200362819768, + -0.5200200362819768, + -0.5200200362819768, + -0.5200200362819768, + -0.5200200362819768, + -0.5200200362819768, + -0.5200200362819768, + -0.5200200362819768, + -0.5200200362819768, + -0.5200200362819768, + -0.5200200362819768, + -0.5200200362819768, + -0.5200200362819768, + -0.5200200362819768, + -0.5200200362819768, + -0.5200200362819768, + -0.5200200362819768, + -0.5200200362819768, + -0.5200200362819768, + -0.5200200362819768, + -0.5200200362819768, + -0.5200200362819768, + -0.5200200362819768, + -0.5200200362819768, + -0.5200200362819768, + -0.5200200362819768, + -0.5200200362819768, + -0.5200200362819768, + -0.5200200362819768, + -0.5200200362819768, + -0.5200200362819768, + -0.5200200362819768, + -0.5200200362819768, + -0.5200200362819768, + -0.5200200362819768, + -0.5200200362819768, + -0.5200200362819768, + -0.5200200362819768, + -0.5200200362819768, + -0.5200200362819768 + ] + }, + { + "marker": { + "color": "#cccccc" + }, + "mode": "markers", + "name": "Infeasible Trial", + "showlegend": false, + "type": "scatter", + "x": [], + "y": [] + } + ], + "layout": { + "template": { + "data": { + "bar": [ + { + "error_x": { + "color": "#2a3f5f" + }, + "error_y": { + "color": "#2a3f5f" + }, + "marker": { + "line": { + "color": "#E5ECF6", + "width": 0.5 + }, + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "bar" + } + ], + "barpolar": [ + { + "marker": { + "line": { + "color": "#E5ECF6", + "width": 0.5 + }, + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "barpolar" + } + ], + "carpet": [ + { + "aaxis": { + "endlinecolor": "#2a3f5f", + "gridcolor": "white", + "linecolor": "white", + "minorgridcolor": "white", + "startlinecolor": "#2a3f5f" + }, + "baxis": { + "endlinecolor": "#2a3f5f", + "gridcolor": "white", + "linecolor": "white", + "minorgridcolor": "white", + "startlinecolor": "#2a3f5f" + }, + "type": "carpet" + } + ], + "choropleth": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "choropleth" + } + ], + "contour": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "contour" + } + ], + "contourcarpet": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "contourcarpet" + } + ], + "heatmap": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "heatmap" + } + ], + "heatmapgl": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "heatmapgl" + } + ], + "histogram": [ + { + "marker": { + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "histogram" + } + ], + "histogram2d": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "histogram2d" + } + ], + "histogram2dcontour": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "histogram2dcontour" + } + ], + "mesh3d": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "mesh3d" + } + ], + "parcoords": [ + { + "line": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "parcoords" + } + ], + "pie": [ + { + "automargin": true, + "type": "pie" + } + ], + "scatter": [ + { + "fillpattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + }, + "type": "scatter" + } + ], + "scatter3d": [ + { + "line": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatter3d" + } + ], + "scattercarpet": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattercarpet" + } + ], + "scattergeo": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattergeo" + } + ], + "scattergl": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattergl" + } + ], + "scattermapbox": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattermapbox" + } + ], + "scatterpolar": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterpolar" + } + ], + "scatterpolargl": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterpolargl" + } + ], + "scatterternary": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterternary" + } + ], + "surface": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "surface" + } + ], + "table": [ + { + "cells": { + "fill": { + "color": "#EBF0F8" + }, + "line": { + "color": "white" + } + }, + "header": { + "fill": { + "color": "#C8D4E3" + }, + "line": { + "color": "white" + } + }, + "type": "table" + } + ] + }, + "layout": { + "annotationdefaults": { + "arrowcolor": "#2a3f5f", + "arrowhead": 0, + "arrowwidth": 1 + }, + "autotypenumbers": "strict", + "coloraxis": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "colorscale": { + "diverging": [ + [ + 0, + "#8e0152" + ], + [ + 0.1, + "#c51b7d" + ], + [ + 0.2, + "#de77ae" + ], + [ + 0.3, + "#f1b6da" + ], + [ + 0.4, + "#fde0ef" + ], + [ + 0.5, + "#f7f7f7" + ], + [ + 0.6, + "#e6f5d0" + ], + [ + 0.7, + "#b8e186" + ], + [ + 0.8, + "#7fbc41" + ], + [ + 0.9, + "#4d9221" + ], + [ + 1, + "#276419" + ] + ], + "sequential": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "sequentialminus": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ] + }, + "colorway": [ + "#636efa", + "#EF553B", + "#00cc96", + "#ab63fa", + "#FFA15A", + "#19d3f3", + "#FF6692", + "#B6E880", + "#FF97FF", + "#FECB52" + ], + "font": { + "color": "#2a3f5f" + }, + "geo": { + "bgcolor": "white", + "lakecolor": "white", + "landcolor": "#E5ECF6", + "showlakes": true, + "showland": true, + "subunitcolor": "white" + }, + "hoverlabel": { + "align": "left" + }, + "hovermode": "closest", + "mapbox": { + "style": "light" + }, + "paper_bgcolor": "white", + "plot_bgcolor": "#E5ECF6", + "polar": { + "angularaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "bgcolor": "#E5ECF6", + "radialaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + } + }, + "scene": { + "xaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + }, + "yaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + }, + "zaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + } + }, + "shapedefaults": { + "line": { + "color": "#2a3f5f" + } + }, + "ternary": { + "aaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "baxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "bgcolor": "#E5ECF6", + "caxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + } + }, + "title": { + "x": 0.05 + }, + "xaxis": { + "automargin": true, + "gridcolor": "white", + "linecolor": "white", + "ticks": "", + "title": { + "standoff": 15 + }, + "zerolinecolor": "white", + "zerolinewidth": 2 + }, + "yaxis": { + "automargin": true, + "gridcolor": "white", + "linecolor": "white", + "ticks": "", + "title": { + "standoff": 15 + }, + "zerolinecolor": "white", + "zerolinewidth": 2 + } + } + }, + "title": { + "text": "Optimization History Plot" + }, + "xaxis": { + "title": { + "text": "Trial" + } + }, + "yaxis": { + "title": { + "text": "Objective Value" + } + } + } + }, + "text/html": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "fig = optuna.visualization.plot_optimization_history(ml_m_study)\n", "show(fig)" @@ -921,10 +3902,1853 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 28, "id": "f97a88d6", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "application/vnd.plotly.v1+json": { + "config": { + "plotlyServerURL": "https://plot.ly" + }, + "data": [ + { + "dimensions": [ + { + "label": "Objective Value", + "range": [ + -0.5290288935695759, + -0.5200200362819768 + ], + "values": [ + -0.5246673792552463, + -0.5268557512025864, + -0.5229927690785134, + -0.5237855161338375, + -0.5252981901140042, + -0.52273244792942, + -0.524666782331119, + -0.5245695457469202, + -0.5251540646395005, + -0.5251291178426823, + -0.5289710502109296, + -0.5247921143255782, + -0.5253549457494395, + -0.5275932520217148, + -0.5239638780338305, + -0.5246703771705652, + -0.5283636662189845, + -0.523633950914645, + -0.524324698647204, + -0.5245380821586376, + -0.5247429081812913, + -0.5222458364643957, + -0.5221720017824713, + -0.5231919904716036, + -0.526542949858886, + -0.5240146874498702, + -0.5225719878462962, + -0.5219445246243672, + -0.5232228643862769, + -0.5219073270749999, + -0.5248065280576014, + -0.5205904731684051, + -0.5209872436975156, + -0.5219058138779911, + -0.5229868716795648, + -0.5266601887482448, + -0.5237710125218932, + -0.5223226611171666, + -0.5239149971092769, + -0.5210712896803376, + -0.5239851871691985, + -0.5212414018980125, + -0.5208471000119077, + -0.5233034524317859, + -0.5217054917158865, + -0.5200200362819768, + -0.5216847823588252, + -0.5225869673883817, + -0.5289771585191569, + -0.5216173176341884, + -0.5230319899849978, + -0.5217108288796505, + -0.524490866846455, + -0.5218549982101606, + -0.5285759551382639, + -0.5208436772168876, + -0.5217138803252707, + -0.5232781200269747, + -0.5208976669236429, + -0.5225290041827534, + -0.5236160997160445, + -0.5208989670677509, + -0.5208086561618462, + -0.5217746628708194, + -0.5213591864255526, + -0.5209341456336978, + -0.5226477164481265, + -0.5221191321911459, + -0.5290288935695759, + -0.5232951192077749, + -0.5238254695720768, + -0.5208550686378427, + -0.5207623106736918, + -0.5206276068811675, + -0.5222679788575139, + -0.5206002008520167, + -0.5219491896185355, + -0.5219366099099083, + -0.5239426947051072, + -0.5214153923793081, + -0.5263994832506056, + -0.5207983641258609, + -0.5203119996283405, + -0.5213196189246586, + -0.521705856325633, + -0.5202261605920173, + -0.520254335467055, + -0.5221153250156328, + -0.5203676037858227, + -0.5221132005388393, + -0.5218054433411432, + -0.5208801838819099, + -0.5202943658437768, + -0.520559132754211, + -0.5215889774753224, + -0.5213734798442939, + -0.5219021344169802, + -0.5211875129780074, + -0.5281831879435094, + -0.5218354361227235 + ] + }, + { + "label": "stacking__final_e...", + "range": [ + -1.9882931412036424, + 1.9977926509211557 + ], + "ticktext": [ + "0.0103", + "0.1", + "1", + "10", + "99.5" + ], + "tickvals": [ + -1.9882931412036424, + -1, + 0, + 1, + 1.9977926509211557 + ], + "values": [ + 1.5767524508262494, + -0.36643829581926574, + 1.1422756617412586, + 1.1652399932363764, + 1.8057672620859204, + 1.5984987728767805, + 1.9058110099924177, + 0.9926174953107045, + 1.0224678236346443, + 0.34335928258235593, + -1.7261990056022631, + 0.02050152733022075, + 0.570819561937349, + -0.6322706610403661, + 1.3450484243928764, + 0.6856384149023823, + -1.0892649423661953, + 1.9155424691127267, + 0.19455849962518462, + 1.4546862882644767, + 0.7744806693902375, + 1.9636474863974431, + 1.5601674956020053, + 1.5257502280872923, + 1.6970429889845058, + 1.9977926509211557, + 1.2975101782956278, + 1.3044941818607685, + 0.8949542066609663, + 1.615607514843441, + 0.42798997343475315, + 1.6607988166215069, + 1.6083786096558277, + 1.3387875591893803, + 1.7037335752958869, + -0.29754891589323207, + 1.1677626749232508, + 1.7043782170151218, + 1.0669094202772786, + 1.4440008441201975, + 1.3746615649999048, + 1.191556808187136, + 1.220337989696611, + 0.8825415396808332, + 1.0877133341134797, + 1.8079296712763246, + 1.7011016909988719, + 1.799023104846647, + -1.8064743573562163, + 1.4972388105243508, + 1.8386405641398051, + 1.1982581255221012, + 0.5705706204248958, + 0.9575873287428153, + -1.0836087075328682, + 1.4983930474063243, + 1.5196135840040585, + 1.828758317467696, + 1.4115048848973142, + 1.9927354690530095, + 0.7230170145991727, + 1.4421112371969946, + 1.5972231070537029, + 1.2539610497548368, + 1.8189679880796816, + 1.4272671407089643, + 1.6084040050860438, + 1.7260949405916903, + -1.9882931412036424, + 1.378513206901577, + 1.8949737558418072, + 1.462971228528129, + 1.5771282135371019, + 1.60978373757018, + 1.5981084013461173, + 1.764819924556749, + 1.7642996002281388, + 1.9148535240121325, + 1.6222157927869074, + 1.2761103117406498, + -0.19048053883667676, + 1.5377519683797147, + 1.694036074828709, + 1.5745207644977024, + 1.6951761408901012, + 1.8834585804173725, + 1.902971346094857, + 1.9277699263623178, + 1.8654037979395173, + 1.8702104379240454, + 1.99064728915625, + 1.726143905713795, + 1.8178968847548087, + 1.788035615046017, + 1.799914322035323, + 1.8824976759226628, + 1.6978348962552468, + 1.7967423881466615, + -0.7921648897106622, + 1.9932351928259326 + ] + }, + { + "label": "stacking__lgbm__l...", + "range": [ + -7.996645520995171, + 0.7110839908032037 + ], + "ticktext": [ + "1.01e-08", + "1e-07", + "1e-06", + "1e-05", + "0.0001", + "0.001", + "0.01", + "0.1", + "1", + "5.14" + ], + "tickvals": [ + -7.996645520995171, + -7, + -6, + -5, + -4, + -3, + -2, + -1, + 0, + 0.7110839908032037 + ], + "values": [ + -2.1190518013285233, + -1.3216406606910045, + -0.5250308368404961, + -3.567866274867025, + -6.674883260767865, + -1.2799981431380665, + -1.1666706557405118, + -5.552699930507158, + -6.04192711315931, + -3.027815534274646, + 0.23929419662881868, + 0.7110839908032037, + -0.2827473313661931, + -3.8563387841147345, + -1.153497846612583, + -2.469986277117708, + -4.410918699240957, + -7.738539523126062, + -0.26953503972239995, + -1.8663293055093313, + -0.6042707943835953, + -7.792207897936546, + -4.461983737437197, + -7.914568983939314, + -4.491722177203142, + -5.241002573249119, + -7.085808926286207, + -7.103352288236723, + -6.746098714980794, + -7.293547630836067, + -6.102063558191891, + -7.278677865144894, + -7.294099670407419, + -6.5377480927893785, + -7.331552021266724, + -6.362219671434026, + -5.564353792309973, + -7.4385131700383145, + -6.660573983944535, + -5.396461835322215, + -5.1101821860828105, + -5.898039079052282, + -6.076931601909648, + -5.797257176562613, + -4.992884541591855, + -6.1603439902567, + -6.2887120050199155, + -6.85223543735564, + -5.621812568354937, + -3.954756666310372, + -4.858401993668103, + -5.919293800005873, + -6.177406782008987, + -5.334446314218688, + -3.0356160175671856, + -6.938725491304818, + -7.465711146304931, + -7.6544460995407455, + -6.911834950065636, + -7.996645520995171, + -7.019471507308697, + -6.573918511245414, + -6.523139132294594, + -6.377447946380829, + -6.567490785994383, + -6.886283059543665, + -7.0284402145422815, + -7.6066140430647025, + -6.506605974974707, + -6.06893797713902, + -4.7675901661310025, + -6.81312916483227, + -6.822248021900722, + -7.202540224920946, + -7.2450039739592125, + -7.717506628989573, + -7.791141872720488, + -7.491881135750368, + -7.219085634179925, + -5.7135675156305625, + -7.977300925475265, + -6.246276675282346, + -6.269348352954525, + -6.329353448450942, + -6.720994247364018, + -7.061453455316804, + -7.658952765205891, + -7.662375768751935, + -7.4263304550884115, + -7.16867528174306, + -7.395529873268984, + -7.772411329889455, + -7.58403000255622, + -7.544573959450084, + -7.547650490052145, + -7.877996961350762, + -7.384039008582134, + -7.167811174813736, + -7.647531844067442, + -7.055039360307838 + ] + }, + { + "label": "stacking__lgbm__l...", + "range": [ + -7.992634372488303, + 0.9812414784149013 + ], + "ticktext": [ + "1.02e-08", + "1e-07", + "1e-06", + "1e-05", + "0.0001", + "0.001", + "0.01", + "0.1", + "1", + "9.58" + ], + "tickvals": [ + -7.992634372488303, + -7, + -6, + -5, + -4, + -3, + -2, + -1, + 0, + 0.9812414784149013 + ], + "values": [ + -0.7496014395656575, + -5.072875274623022, + -7.2424453274596585, + -6.984643281176417, + -1.9063049086293393, + -1.8750154415310465, + -1.5102757348420668, + -7.958715077505025, + -4.80917818541002, + -1.5538824475574762, + 0.9812414784149013, + -3.9762185290386056, + -6.115448491343006, + -2.9539914285682936, + 0.24319986103965677, + -3.580535790301635, + -2.5824219632659946, + -6.014542180018189, + -0.1244231522079746, + -4.31541189427841, + -5.678714629429546, + -7.992634372488303, + -7.397728203734438, + -7.691934275126395, + -6.587147875748607, + -2.67766525236862, + -7.232326728609519, + -7.274258325623796, + -6.528193370983073, + -7.969406797398982, + -5.783666184087195, + -7.729000293271348, + -7.328019748240644, + -6.688367873301686, + -5.217086970093833, + -6.726122938751814, + -6.772511796679915, + -7.571292383493456, + -6.250415009188133, + -5.400696603877805, + -5.3325358790296935, + -7.032346939565729, + -6.8301295283870855, + -4.789958832473804, + -7.023790702370935, + -6.238273673761444, + -6.240817980898814, + -5.626754472457717, + -7.60775039447751, + -4.443778333708983, + -6.340545748173987, + -7.135985205262598, + -6.967923121016476, + -5.9640180948412675, + -7.702102600758169, + -5.515416732292671, + -4.94259707260836, + -5.500801375759143, + -3.4808645947264485, + -3.729304303130991, + -3.12851047775088, + -4.41559186958991, + -2.0982538878310644, + -1.394892316182154, + -2.2602648670187406, + -4.300709850872674, + -3.232418334744208, + -1.2368561802811815, + -4.003623715905614, + -0.9161070791401003, + -2.1669956040191867, + -4.151294515584747, + -4.472343840439827, + -3.441060425123589, + -3.9623407486798925, + -4.7029070300519145, + -4.69724810455163, + -5.049649233412751, + -5.802256789765179, + -4.622179344781074, + -6.5084187323798, + -2.8430100469546886, + -2.7244172613053586, + -2.7340695317417327, + -2.163890482869013, + -1.869756294925654, + -1.6830039310517018, + -1.9088543903719448, + -1.7114387396702266, + -2.410126706373064, + -1.8071887261137574, + -0.32294043824866603, + -1.6817134770362405, + -1.050283251710228, + -1.0174700223030044, + -1.6401086132229907, + -0.7324575258087868, + -2.481164068732713, + -1.322748145289114, + -0.510414810462544 + ] + }, + { + "label": "stacking__lgbm__l...", + "range": [ + 0.0065385216754443864, + 0.0994703747548547 + ], + "values": [ + 0.05060708814250141, + 0.0994703747548547, + 0.040413773468428886, + 0.009606384441602885, + 0.0879107638366665, + 0.03853051663170616, + 0.07352844124895622, + 0.08164345683906865, + 0.07637570744640172, + 0.05857090881886341, + 0.02213752375273053, + 0.03625505548835917, + 0.036126312586414494, + 0.04897725801202053, + 0.0337518860899327, + 0.060664883433710515, + 0.020583094467493783, + 0.04480696885089231, + 0.023893306099116652, + 0.0065385216754443864, + 0.06552518590550029, + 0.043860190120681875, + 0.04204432165246505, + 0.031011570458546016, + 0.05908523905851954, + 0.04783876945911114, + 0.028513013372304052, + 0.02818135851055678, + 0.01748161099244821, + 0.056156944394844074, + 0.054914484399226485, + 0.04308686630463505, + 0.05217130488135876, + 0.0652103200952738, + 0.06709858374052159, + 0.053188443244108874, + 0.09781002459658508, + 0.06611718456630097, + 0.07235772265781674, + 0.05289195716422508, + 0.08348159275744957, + 0.05318996650301191, + 0.05087378381832224, + 0.046680492341904724, + 0.0397986377172383, + 0.05065442786589058, + 0.048519163370612066, + 0.06058544449583331, + 0.050781512028268534, + 0.03806032211765512, + 0.0707038600626076, + 0.051834617960889964, + 0.05649737676419844, + 0.043407495951660824, + 0.06245665060550772, + 0.051496143346957894, + 0.04596241221986294, + 0.034656194371441296, + 0.041695520651829326, + 0.04083040128832726, + 0.04922071987102731, + 0.05732704360926667, + 0.05812964983418659, + 0.05726696934306757, + 0.06360719511501338, + 0.044864311008115484, + 0.05886107122649704, + 0.04222269441403454, + 0.03793838586586656, + 0.06851143401590498, + 0.06234729647355647, + 0.045479112145522346, + 0.049682865309307836, + 0.0494203091395676, + 0.0494358171872697, + 0.04599981300247066, + 0.05532930458090647, + 0.03275640670670148, + 0.047916669915282074, + 0.05383571487077739, + 0.050592139301953026, + 0.045044552034509695, + 0.04473185972192169, + 0.039101459208998164, + 0.0364574620978789, + 0.0434862732931055, + 0.04331575198662835, + 0.029950206520334578, + 0.04354378169372908, + 0.04324207660321477, + 0.047325599260472105, + 0.04089045391790169, + 0.04451411285607379, + 0.03686564999192804, + 0.033031672509690274, + 0.03852661037456338, + 0.025975248599970007, + 0.035261223550862135, + 0.04339597990445648, + 0.03722324796530781 + ] + }, + { + "label": "stacking__lgbm__m...", + "range": [ + 2, + 5 + ], + "values": [ + 4, + 2, + 3, + 5, + 2, + 3, + 3, + 3, + 5, + 2, + 4, + 3, + 3, + 4, + 3, + 4, + 2, + 3, + 4, + 2, + 3, + 3, + 3, + 3, + 4, + 3, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 5, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 3, + 2, + 3, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 3, + 2, + 2, + 3, + 2, + 2, + 2, + 2, + 2, + 2, + 4, + 5, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ] + }, + { + "label": "stacking__lgbm__m...", + "range": [ + 20, + 100 + ], + "values": [ + 90, + 90, + 70, + 90, + 20, + 30, + 90, + 60, + 20, + 90, + 40, + 60, + 40, + 70, + 40, + 70, + 50, + 30, + 70, + 50, + 80, + 30, + 30, + 30, + 30, + 20, + 30, + 50, + 50, + 40, + 40, + 50, + 50, + 50, + 60, + 50, + 40, + 60, + 100, + 50, + 60, + 50, + 50, + 60, + 50, + 50, + 40, + 60, + 50, + 60, + 70, + 50, + 40, + 50, + 40, + 50, + 60, + 40, + 50, + 60, + 70, + 50, + 50, + 50, + 40, + 50, + 60, + 50, + 40, + 80, + 60, + 50, + 50, + 50, + 40, + 50, + 60, + 50, + 40, + 50, + 60, + 50, + 50, + 50, + 40, + 50, + 50, + 60, + 50, + 40, + 60, + 50, + 50, + 50, + 50, + 40, + 50, + 50, + 40, + 60 + ] + } + ], + "labelangle": 30, + "labelside": "bottom", + "line": { + "color": [ + -0.5246673792552463, + -0.5268557512025864, + -0.5229927690785134, + -0.5237855161338375, + -0.5252981901140042, + -0.52273244792942, + -0.524666782331119, + -0.5245695457469202, + -0.5251540646395005, + -0.5251291178426823, + -0.5289710502109296, + -0.5247921143255782, + -0.5253549457494395, + -0.5275932520217148, + -0.5239638780338305, + -0.5246703771705652, + -0.5283636662189845, + -0.523633950914645, + -0.524324698647204, + -0.5245380821586376, + -0.5247429081812913, + -0.5222458364643957, + -0.5221720017824713, + -0.5231919904716036, + -0.526542949858886, + -0.5240146874498702, + -0.5225719878462962, + -0.5219445246243672, + -0.5232228643862769, + -0.5219073270749999, + -0.5248065280576014, + -0.5205904731684051, + -0.5209872436975156, + -0.5219058138779911, + -0.5229868716795648, + -0.5266601887482448, + -0.5237710125218932, + -0.5223226611171666, + -0.5239149971092769, + -0.5210712896803376, + -0.5239851871691985, + -0.5212414018980125, + -0.5208471000119077, + -0.5233034524317859, + -0.5217054917158865, + -0.5200200362819768, + -0.5216847823588252, + -0.5225869673883817, + -0.5289771585191569, + -0.5216173176341884, + -0.5230319899849978, + -0.5217108288796505, + -0.524490866846455, + -0.5218549982101606, + -0.5285759551382639, + -0.5208436772168876, + -0.5217138803252707, + -0.5232781200269747, + -0.5208976669236429, + -0.5225290041827534, + -0.5236160997160445, + -0.5208989670677509, + -0.5208086561618462, + -0.5217746628708194, + -0.5213591864255526, + -0.5209341456336978, + -0.5226477164481265, + -0.5221191321911459, + -0.5290288935695759, + -0.5232951192077749, + -0.5238254695720768, + -0.5208550686378427, + -0.5207623106736918, + -0.5206276068811675, + -0.5222679788575139, + -0.5206002008520167, + -0.5219491896185355, + -0.5219366099099083, + -0.5239426947051072, + -0.5214153923793081, + -0.5263994832506056, + -0.5207983641258609, + -0.5203119996283405, + -0.5213196189246586, + -0.521705856325633, + -0.5202261605920173, + -0.520254335467055, + -0.5221153250156328, + -0.5203676037858227, + -0.5221132005388393, + -0.5218054433411432, + -0.5208801838819099, + -0.5202943658437768, + -0.520559132754211, + -0.5215889774753224, + -0.5213734798442939, + -0.5219021344169802, + -0.5211875129780074, + -0.5281831879435094, + -0.5218354361227235 + ], + "colorbar": { + "title": { + "text": "Objective Value" + } + }, + "colorscale": [ + [ + 0, + "rgb(247,251,255)" + ], + [ + 0.125, + "rgb(222,235,247)" + ], + [ + 0.25, + "rgb(198,219,239)" + ], + [ + 0.375, + "rgb(158,202,225)" + ], + [ + 0.5, + "rgb(107,174,214)" + ], + [ + 0.625, + "rgb(66,146,198)" + ], + [ + 0.75, + "rgb(33,113,181)" + ], + [ + 0.875, + "rgb(8,81,156)" + ], + [ + 1, + "rgb(8,48,107)" + ] + ], + "reversescale": false, + "showscale": true + }, + "type": "parcoords" + } + ], + "layout": { + "template": { + "data": { + "bar": [ + { + "error_x": { + "color": "#2a3f5f" + }, + "error_y": { + "color": "#2a3f5f" + }, + "marker": { + "line": { + "color": "#E5ECF6", + "width": 0.5 + }, + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "bar" + } + ], + "barpolar": [ + { + "marker": { + "line": { + "color": "#E5ECF6", + "width": 0.5 + }, + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "barpolar" + } + ], + "carpet": [ + { + "aaxis": { + "endlinecolor": "#2a3f5f", + "gridcolor": "white", + "linecolor": "white", + "minorgridcolor": "white", + "startlinecolor": "#2a3f5f" + }, + "baxis": { + "endlinecolor": "#2a3f5f", + "gridcolor": "white", + "linecolor": "white", + "minorgridcolor": "white", + "startlinecolor": "#2a3f5f" + }, + "type": "carpet" + } + ], + "choropleth": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "choropleth" + } + ], + "contour": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "contour" + } + ], + "contourcarpet": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "contourcarpet" + } + ], + "heatmap": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "heatmap" + } + ], + "heatmapgl": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "heatmapgl" + } + ], + "histogram": [ + { + "marker": { + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "histogram" + } + ], + "histogram2d": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "histogram2d" + } + ], + "histogram2dcontour": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "histogram2dcontour" + } + ], + "mesh3d": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "mesh3d" + } + ], + "parcoords": [ + { + "line": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "parcoords" + } + ], + "pie": [ + { + "automargin": true, + "type": "pie" + } + ], + "scatter": [ + { + "fillpattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + }, + "type": "scatter" + } + ], + "scatter3d": [ + { + "line": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatter3d" + } + ], + "scattercarpet": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattercarpet" + } + ], + "scattergeo": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattergeo" + } + ], + "scattergl": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattergl" + } + ], + "scattermapbox": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattermapbox" + } + ], + "scatterpolar": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterpolar" + } + ], + "scatterpolargl": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterpolargl" + } + ], + "scatterternary": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterternary" + } + ], + "surface": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "surface" + } + ], + "table": [ + { + "cells": { + "fill": { + "color": "#EBF0F8" + }, + "line": { + "color": "white" + } + }, + "header": { + "fill": { + "color": "#C8D4E3" + }, + "line": { + "color": "white" + } + }, + "type": "table" + } + ] + }, + "layout": { + "annotationdefaults": { + "arrowcolor": "#2a3f5f", + "arrowhead": 0, + "arrowwidth": 1 + }, + "autotypenumbers": "strict", + "coloraxis": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "colorscale": { + "diverging": [ + [ + 0, + "#8e0152" + ], + [ + 0.1, + "#c51b7d" + ], + [ + 0.2, + "#de77ae" + ], + [ + 0.3, + "#f1b6da" + ], + [ + 0.4, + "#fde0ef" + ], + [ + 0.5, + "#f7f7f7" + ], + [ + 0.6, + "#e6f5d0" + ], + [ + 0.7, + "#b8e186" + ], + [ + 0.8, + "#7fbc41" + ], + [ + 0.9, + "#4d9221" + ], + [ + 1, + "#276419" + ] + ], + "sequential": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "sequentialminus": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ] + }, + "colorway": [ + "#636efa", + "#EF553B", + "#00cc96", + "#ab63fa", + "#FFA15A", + "#19d3f3", + "#FF6692", + "#B6E880", + "#FF97FF", + "#FECB52" + ], + "font": { + "color": "#2a3f5f" + }, + "geo": { + "bgcolor": "white", + "lakecolor": "white", + "landcolor": "#E5ECF6", + "showlakes": true, + "showland": true, + "subunitcolor": "white" + }, + "hoverlabel": { + "align": "left" + }, + "hovermode": "closest", + "mapbox": { + "style": "light" + }, + "paper_bgcolor": "white", + "plot_bgcolor": "#E5ECF6", + "polar": { + "angularaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "bgcolor": "#E5ECF6", + "radialaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + } + }, + "scene": { + "xaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + }, + "yaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + }, + "zaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + } + }, + "shapedefaults": { + "line": { + "color": "#2a3f5f" + } + }, + "ternary": { + "aaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "baxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "bgcolor": "#E5ECF6", + "caxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + } + }, + "title": { + "x": 0.05 + }, + "xaxis": { + "automargin": true, + "gridcolor": "white", + "linecolor": "white", + "ticks": "", + "title": { + "standoff": 15 + }, + "zerolinecolor": "white", + "zerolinewidth": 2 + }, + "yaxis": { + "automargin": true, + "gridcolor": "white", + "linecolor": "white", + "ticks": "", + "title": { + "standoff": 15 + }, + "zerolinecolor": "white", + "zerolinewidth": 2 + } + } + }, + "title": { + "text": "Parallel Coordinate Plot" + } + } + }, + "text/html": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "fig = optuna.visualization.plot_parallel_coordinate(ml_m_study)\n", "show(fig)" @@ -932,10 +5756,921 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 29, "id": "e7b5f011", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "application/vnd.plotly.v1+json": { + "config": { + "plotlyServerURL": "https://plot.ly" + }, + "data": [ + { + "cliponaxis": false, + "hovertemplate": [ + "stacking__lgbm__lambda_l1 (FloatDistribution): 0.0007768551699921855", + "stacking__lgbm__lambda_l2 (FloatDistribution): 0.011384162419750992", + "stacking__lgbm__min_child_samples (IntDistribution): 0.11262030093167358", + "stacking__lgbm__max_depth (IntDistribution): 0.188195568056322", + "stacking__lgbm__learning_rate (FloatDistribution): 0.33623770168475037", + "stacking__final_estimator__C (FloatDistribution): 0.35078541173751077" + ], + "name": "neg_log_loss_ml_m", + "orientation": "h", + "text": [ + "<0.01", + "0.01", + "0.11", + "0.19", + "0.34", + "0.35" + ], + "textposition": "outside", + "type": "bar", + "x": [ + 0.0007768551699921855, + 0.011384162419750992, + 0.11262030093167358, + 0.188195568056322, + 0.33623770168475037, + 0.35078541173751077 + ], + "y": [ + "stacking__lgbm__lambda_l1", + "stacking__lgbm__lambda_l2", + "stacking__lgbm__min_child_samples", + "stacking__lgbm__max_depth", + "stacking__lgbm__learning_rate", + "stacking__final_estimator__C" + ] + } + ], + "layout": { + "template": { + "data": { + "bar": [ + { + "error_x": { + "color": "#2a3f5f" + }, + "error_y": { + "color": "#2a3f5f" + }, + "marker": { + "line": { + "color": "#E5ECF6", + "width": 0.5 + }, + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "bar" + } + ], + "barpolar": [ + { + "marker": { + "line": { + "color": "#E5ECF6", + "width": 0.5 + }, + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "barpolar" + } + ], + "carpet": [ + { + "aaxis": { + "endlinecolor": "#2a3f5f", + "gridcolor": "white", + "linecolor": "white", + "minorgridcolor": "white", + "startlinecolor": "#2a3f5f" + }, + "baxis": { + "endlinecolor": "#2a3f5f", + "gridcolor": "white", + "linecolor": "white", + "minorgridcolor": "white", + "startlinecolor": "#2a3f5f" + }, + "type": "carpet" + } + ], + "choropleth": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "choropleth" + } + ], + "contour": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "contour" + } + ], + "contourcarpet": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "contourcarpet" + } + ], + "heatmap": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "heatmap" + } + ], + "heatmapgl": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "heatmapgl" + } + ], + "histogram": [ + { + "marker": { + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "histogram" + } + ], + "histogram2d": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "histogram2d" + } + ], + "histogram2dcontour": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "histogram2dcontour" + } + ], + "mesh3d": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "mesh3d" + } + ], + "parcoords": [ + { + "line": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "parcoords" + } + ], + "pie": [ + { + "automargin": true, + "type": "pie" + } + ], + "scatter": [ + { + "fillpattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + }, + "type": "scatter" + } + ], + "scatter3d": [ + { + "line": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatter3d" + } + ], + "scattercarpet": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattercarpet" + } + ], + "scattergeo": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattergeo" + } + ], + "scattergl": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattergl" + } + ], + "scattermapbox": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattermapbox" + } + ], + "scatterpolar": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterpolar" + } + ], + "scatterpolargl": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterpolargl" + } + ], + "scatterternary": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterternary" + } + ], + "surface": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "surface" + } + ], + "table": [ + { + "cells": { + "fill": { + "color": "#EBF0F8" + }, + "line": { + "color": "white" + } + }, + "header": { + "fill": { + "color": "#C8D4E3" + }, + "line": { + "color": "white" + } + }, + "type": "table" + } + ] + }, + "layout": { + "annotationdefaults": { + "arrowcolor": "#2a3f5f", + "arrowhead": 0, + "arrowwidth": 1 + }, + "autotypenumbers": "strict", + "coloraxis": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "colorscale": { + "diverging": [ + [ + 0, + "#8e0152" + ], + [ + 0.1, + "#c51b7d" + ], + [ + 0.2, + "#de77ae" + ], + [ + 0.3, + "#f1b6da" + ], + [ + 0.4, + "#fde0ef" + ], + [ + 0.5, + "#f7f7f7" + ], + [ + 0.6, + "#e6f5d0" + ], + [ + 0.7, + "#b8e186" + ], + [ + 0.8, + "#7fbc41" + ], + [ + 0.9, + "#4d9221" + ], + [ + 1, + "#276419" + ] + ], + "sequential": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "sequentialminus": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ] + }, + "colorway": [ + "#636efa", + "#EF553B", + "#00cc96", + "#ab63fa", + "#FFA15A", + "#19d3f3", + "#FF6692", + "#B6E880", + "#FF97FF", + "#FECB52" + ], + "font": { + "color": "#2a3f5f" + }, + "geo": { + "bgcolor": "white", + "lakecolor": "white", + "landcolor": "#E5ECF6", + "showlakes": true, + "showland": true, + "subunitcolor": "white" + }, + "hoverlabel": { + "align": "left" + }, + "hovermode": "closest", + "mapbox": { + "style": "light" + }, + "paper_bgcolor": "white", + "plot_bgcolor": "#E5ECF6", + "polar": { + "angularaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "bgcolor": "#E5ECF6", + "radialaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + } + }, + "scene": { + "xaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + }, + "yaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + }, + "zaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + } + }, + "shapedefaults": { + "line": { + "color": "#2a3f5f" + } + }, + "ternary": { + "aaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "baxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "bgcolor": "#E5ECF6", + "caxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + } + }, + "title": { + "x": 0.05 + }, + "xaxis": { + "automargin": true, + "gridcolor": "white", + "linecolor": "white", + "ticks": "", + "title": { + "standoff": 15 + }, + "zerolinecolor": "white", + "zerolinewidth": 2 + }, + "yaxis": { + "automargin": true, + "gridcolor": "white", + "linecolor": "white", + "ticks": "", + "title": { + "standoff": 15 + }, + "zerolinecolor": "white", + "zerolinewidth": 2 + } + } + }, + "title": { + "text": "Hyperparameter Importances" + }, + "xaxis": { + "title": { + "text": "Hyperparameter Importance" + } + }, + "yaxis": { + "title": { + "text": "Hyperparameter" + } + } + } + }, + "text/html": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "fig = optuna.visualization.plot_param_importances(ml_m_study)\n", "show(fig)" From 6ca6ba6107b329324ed1a27ea1aad7bc3ace1ed2 Mon Sep 17 00:00:00 2001 From: SvenKlaassen Date: Sun, 16 Nov 2025 13:13:33 +0000 Subject: [PATCH 07/11] remove additional part --- doc/guide/learners/python/tune_hyperparams.rst | 3 --- 1 file changed, 3 deletions(-) diff --git a/doc/guide/learners/python/tune_hyperparams.rst b/doc/guide/learners/python/tune_hyperparams.rst index 3ac264ff..79547666 100644 --- a/doc/guide/learners/python/tune_hyperparams.rst +++ b/doc/guide/learners/python/tune_hyperparams.rst @@ -78,6 +78,3 @@ In this case the tuning should be done externally and the parameters can then be dml_plr_obj.set_ml_nuisance_params('ml_m', 'd', {'alpha': ml_m_tune.alpha_}); print(dml_plr_obj.params) print(dml_plr_obj.fit().summary) - -External tuning requires knowledge about the underlying machine learning estimators and -is therefore not recommended for all models. From e8139272bff3de5bff597a675e654e2d79f8b3f6 Mon Sep 17 00:00:00 2001 From: SvenKlaassen Date: Mon, 17 Nov 2025 17:17:24 +0000 Subject: [PATCH 08/11] first version hyperparameter tuning --- .../learners/python/learners_overview.inc | 9 +++ .../learners/python/tune_hyperparams.rst | 53 ++++-------- .../learners/python/tune_hyperparams_old.rst | 80 +++++++++++++++++++ doc/guide/resampling.rst | 5 +- 4 files changed, 108 insertions(+), 39 deletions(-) create mode 100644 doc/guide/learners/python/tune_hyperparams_old.rst diff --git a/doc/guide/learners/python/learners_overview.inc b/doc/guide/learners/python/learners_overview.inc index 9a173622..25648dac 100644 --- a/doc/guide/learners/python/learners_overview.inc +++ b/doc/guide/learners/python/learners_overview.inc @@ -21,6 +21,15 @@ Hyperparameter tuning .. include:: /guide/learners/python/tune_hyperparams.rst +Hyperparameter tuning (Grid Search) +################################### + +.. warning:: + **Deprecated:** The ``tune()`` method is deprecated and be removed in a future version. + Please use ``tune_ml_models()`` for hyperparameter tuning, see :ref:`Hyperparameter tuning `. + +.. include:: /guide/learners/python/tune_hyperparams_old.rst + .. _py_eval_learners: Evaluate learners diff --git a/doc/guide/learners/python/tune_hyperparams.rst b/doc/guide/learners/python/tune_hyperparams.rst index 79547666..980ce90c 100644 --- a/doc/guide/learners/python/tune_hyperparams.rst +++ b/doc/guide/learners/python/tune_hyperparams.rst @@ -1,5 +1,5 @@ Parameter tuning of learners for the nuisance functions of :ref:`DoubleML ` models can be done via -the ``tune()`` method. +the ``tune_ml_models()`` method. To illustrate the parameter tuning, we generate data from a sparse partially linear regression model. .. tab-set:: @@ -21,9 +21,10 @@ To illustrate the parameter tuning, we generate data from a sparse partially lin y = theta * d + np.dot(X[:, :3], np.array([5, 5, 5])) + np.random.standard_normal(size=(n_obs,)) dml_data = dml.DoubleMLData.from_arrays(X, y, d) -The hyperparameter-tuning is performed using either an exhaustive search over specified parameter values -implemented in :class:`sklearn.model_selection.GridSearchCV` or via a randomized search implemented in -:class:`sklearn.model_selection.RandomizedSearchCV`. +The hyperparameter-tuning is performed using `Optuna `_ as backend. Here, we illustrate +the tuning via defining a search space for the nuisance function learners over ``100`` trials. The most important input +argument is the hyperparameter space via a dictionary of functions. This search space will internally transformed into a +suitable ``objective(trial)`` function for `Optuna `_. .. tab-set:: @@ -35,46 +36,24 @@ implemented in :class:`sklearn.model_selection.GridSearchCV` or via a randomized import doubleml as dml from sklearn.linear_model import Lasso + import optuna ml_l = Lasso() ml_m = Lasso() dml_plr_obj = dml.DoubleMLPLR(dml_data, ml_l, ml_m) - par_grids = {'ml_l': {'alpha': np.arange(0.05, 1., 0.1)}, - 'ml_m': {'alpha': np.arange(0.05, 1., 0.1)}} - dml_plr_obj.tune(par_grids, search_mode='grid_search'); - print(dml_plr_obj.params) - print(dml_plr_obj.fit().summary) - np.random.seed(1234) - par_grids = {'ml_l': {'alpha': np.arange(0.05, 1., 0.01)}, - 'ml_m': {'alpha': np.arange(0.05, 1., 0.01)}} - dml_plr_obj.tune(par_grids, search_mode='randomized_search', n_iter_randomized_search=20); - print(dml_plr_obj.params) - print(dml_plr_obj.fit().summary) + def ml_l_params(trial): + return {'alpha': trial.suggest_float('alpha', 0.05, 1.0)} -Hyperparameter tuning can also be done with more sophisticated methods, like for example an iterative fitting along -a regularization path implemented in :py:class:`sklearn.linear_model.LassoCV`. -In this case the tuning should be done externally and the parameters can then be set via the -``set_ml_nuisance_params()`` method. + def ml_m_params(trial): + return {'alpha': trial.suggest_float('alpha', 0.05, 1.0)} -.. tab-set:: + param_space = {'ml_l': ml_l_params, 'ml_m': ml_m_params} + optuna_settings = {'n_trials': 100, 'verbosity': optuna.logging.WARNING} - .. tab-item:: Python - :sync: py - - .. ipython:: python - - import doubleml as dml - from sklearn.linear_model import LassoCV - - np.random.seed(1234) - ml_l_tune = LassoCV().fit(dml_data.x, dml_data.y) - ml_m_tune = LassoCV().fit(dml_data.x, dml_data.d) - - ml_l = Lasso() - ml_m = Lasso() - dml_plr_obj = dml.DoubleMLPLR(dml_data, ml_l, ml_m) - dml_plr_obj.set_ml_nuisance_params('ml_l', 'd', {'alpha': ml_l_tune.alpha_}); - dml_plr_obj.set_ml_nuisance_params('ml_m', 'd', {'alpha': ml_m_tune.alpha_}); + dml_plr_obj.tune_ml_models(ml_param_space=param_space, optuna_settings=optuna_settings) + print(dml_plr_obj.params) print(dml_plr_obj.fit().summary) + +A more detailed description of hyperparameter-tuning possibilities can be found in the :ref:`Example Gallery `. \ No newline at end of file diff --git a/doc/guide/learners/python/tune_hyperparams_old.rst b/doc/guide/learners/python/tune_hyperparams_old.rst new file mode 100644 index 00000000..79547666 --- /dev/null +++ b/doc/guide/learners/python/tune_hyperparams_old.rst @@ -0,0 +1,80 @@ +Parameter tuning of learners for the nuisance functions of :ref:`DoubleML ` models can be done via +the ``tune()`` method. +To illustrate the parameter tuning, we generate data from a sparse partially linear regression model. + +.. tab-set:: + + .. tab-item:: Python + :sync: py + + .. ipython:: python + + import doubleml as dml + import numpy as np + + np.random.seed(3141) + n_obs = 200 + n_vars = 200 + theta = 3 + X = np.random.normal(size=(n_obs, n_vars)) + d = np.dot(X[:, :3], np.array([5, 5, 5])) + np.random.standard_normal(size=(n_obs,)) + y = theta * d + np.dot(X[:, :3], np.array([5, 5, 5])) + np.random.standard_normal(size=(n_obs,)) + dml_data = dml.DoubleMLData.from_arrays(X, y, d) + +The hyperparameter-tuning is performed using either an exhaustive search over specified parameter values +implemented in :class:`sklearn.model_selection.GridSearchCV` or via a randomized search implemented in +:class:`sklearn.model_selection.RandomizedSearchCV`. + +.. tab-set:: + + .. tab-item:: Python + :sync: py + + .. ipython:: python + :okwarning: + + import doubleml as dml + from sklearn.linear_model import Lasso + + ml_l = Lasso() + ml_m = Lasso() + dml_plr_obj = dml.DoubleMLPLR(dml_data, ml_l, ml_m) + par_grids = {'ml_l': {'alpha': np.arange(0.05, 1., 0.1)}, + 'ml_m': {'alpha': np.arange(0.05, 1., 0.1)}} + dml_plr_obj.tune(par_grids, search_mode='grid_search'); + print(dml_plr_obj.params) + print(dml_plr_obj.fit().summary) + + np.random.seed(1234) + par_grids = {'ml_l': {'alpha': np.arange(0.05, 1., 0.01)}, + 'ml_m': {'alpha': np.arange(0.05, 1., 0.01)}} + dml_plr_obj.tune(par_grids, search_mode='randomized_search', n_iter_randomized_search=20); + print(dml_plr_obj.params) + print(dml_plr_obj.fit().summary) + +Hyperparameter tuning can also be done with more sophisticated methods, like for example an iterative fitting along +a regularization path implemented in :py:class:`sklearn.linear_model.LassoCV`. +In this case the tuning should be done externally and the parameters can then be set via the +``set_ml_nuisance_params()`` method. + +.. tab-set:: + + .. tab-item:: Python + :sync: py + + .. ipython:: python + + import doubleml as dml + from sklearn.linear_model import LassoCV + + np.random.seed(1234) + ml_l_tune = LassoCV().fit(dml_data.x, dml_data.y) + ml_m_tune = LassoCV().fit(dml_data.x, dml_data.d) + + ml_l = Lasso() + ml_m = Lasso() + dml_plr_obj = dml.DoubleMLPLR(dml_data, ml_l, ml_m) + dml_plr_obj.set_ml_nuisance_params('ml_l', 'd', {'alpha': ml_l_tune.alpha_}); + dml_plr_obj.set_ml_nuisance_params('ml_m', 'd', {'alpha': ml_m_tune.alpha_}); + print(dml_plr_obj.params) + print(dml_plr_obj.fit().summary) diff --git a/doc/guide/resampling.rst b/doc/guide/resampling.rst index 3670c28c..61c8e43a 100644 --- a/doc/guide/resampling.rst +++ b/doc/guide/resampling.rst @@ -203,6 +203,7 @@ The aggregation of the estimates of the causal parameter and its standard errors .. math:: \tilde{\theta}_{0} = \text{Median}\big((\tilde{\theta}_{0,m})_{m \in [M]}\big). + The estimate of the causal parameter :math:`\tilde{\theta}_{0}` is stored in the ``coef`` attribute and the asymptotic standard error :math:`\hat{\sigma}/\sqrt{N}` in ``se``. @@ -356,7 +357,7 @@ Note that cross-fitting performs well empirically and is recommended to remove b .. note:: The flag ``apply_cross_fitting`` is deprecated for the python package. To avoid cross-fitting, please use the option - to set :ref:`external predictions `. + to set :ref:`external predictions `. .. tab-item:: R :sync: r @@ -407,7 +408,7 @@ justification, see also :ref:`bias_overfitting`. .. note:: The flag ``apply_cross_fitting`` is deprecated for the python package. To avoid cross-fitting, please use the option - to set :ref:`external predictions `. Additionally, the number of folds ``n_folds`` is expected to be at least ``2``. + to set :ref:`external predictions `. Additionally, the number of folds ``n_folds`` is expected to be at least ``2``. .. tab-item:: R :sync: r From 32ec7a904891d4608ae60ef45ede50a205f8483f Mon Sep 17 00:00:00 2001 From: SvenKlaassen Date: Wed, 26 Nov 2025 16:00:07 +0000 Subject: [PATCH 09/11] update optuna example --- doc/examples/index.rst | 2 +- doc/examples/learners/py_optuna.ipynb | 4335 +++++++++++++++++-------- 2 files changed, 2961 insertions(+), 1376 deletions(-) diff --git a/doc/examples/index.rst b/doc/examples/index.rst index fc92a8d8..03f4e713 100644 --- a/doc/examples/index.rst +++ b/doc/examples/index.rst @@ -24,8 +24,8 @@ General Examples py_double_ml_irm_vs_apo.ipynb py_double_ml_lplr.ipynb py_double_ml_ssm.ipynb - learners/py_learner.ipynb learners/py_optuna.ipynb + learners/py_learner.ipynb py_double_ml_firststage.ipynb py_double_ml_multiway_cluster.ipynb py_double_ml_sensitivity_booking.ipynb diff --git a/doc/examples/learners/py_optuna.ipynb b/doc/examples/learners/py_optuna.ipynb index 729cd376..c861bf8a 100644 --- a/doc/examples/learners/py_optuna.ipynb +++ b/doc/examples/learners/py_optuna.ipynb @@ -17,7 +17,9 @@ "\n", "for a given treatment level $d$ and and discrete valued treatment $D$.\n", "\n", - "For a more detailed description of the DoubleMLAPO model, see [Average Potential Outcome Model](https://docs.doubleml.org/stable/guide/models.html#average-potential-outcomes-apos) or [Example Gallery](https://docs.doubleml.org/stable/examples/index.html)." + "For a more detailed description of the DoubleMLAPO model, see [Average Potential Outcome Model](https://docs.doubleml.org/stable/guide/models.html#average-potential-outcomes-apos) or [Example Gallery](https://docs.doubleml.org/stable/examples/index.html).\n", + "\n", + "**Remark** that the untuned settings and hyperparameter spaces are mainly chosen for display of the tuning possibilities and not a blueprint for standard tuning." ] }, { @@ -41,7 +43,7 @@ "from lightgbm import LGBMRegressor, LGBMClassifier\n", "\n", "from doubleml.data import DoubleMLData\n", - "from doubleml.irm import DoubleMLAPO\n", + "from doubleml.irm import DoubleMLAPO, DoubleMLAPOS\n", "from doubleml.irm.datasets import make_irm_data_discrete_treatments\n", "\n", "palette = sns.color_palette(\"colorblind\")\n", @@ -287,9 +289,9 @@ "id": "affc29fc", "metadata": {}, "source": [ - "### Hyperparametertuning\n", + "### Hyperparameter Tuning\n", "\n", - "Now, let us take a look at the basic hyperparametertuning. We will initialize a separate model to compare the results." + "Now, let us take a look at the basic hyperparameter tuning. We will initialize a separate model to compare the results." ] }, { @@ -325,7 +327,7 @@ "\n", "Generally, the hyperparameter structure should follow the definitions in [Optuna](https://optuna.org/#key_features), but instead of the objective the hyperparameters have to be specified as a callable. The corresponding DoubleML object then assigns a corresponding objective for each learning using the supplied parameter space.\n", "\n", - "To keep this example fast and simple, we keep the `n_estimators` fix and only tune a small number of other hyperparameters." + "To keep this example relatively fast and simple, we keep the `n_estimators` fix and only tune a small number of other hyperparameters." ] }, { @@ -339,22 +341,22 @@ "def ml_g_params(trial):\n", " return {\n", " 'n_estimators': 100,\n", - " 'learning_rate': trial.suggest_float('learning_rate', 0.005, 0.1),\n", - " 'max_depth': trial.suggest_int('max_depth', 2, 5),\n", - " 'min_child_samples': trial.suggest_int('min_child_samples', 20, 100, step=10),\n", - " 'lambda_l1': trial.suggest_float('lambda_l1', 1e-8, 10.0, log=True),\n", - " 'lambda_l2': trial.suggest_float('lambda_l2', 1e-8, 10.0, log=True),\n", + " 'learning_rate': trial.suggest_float('learning_rate', 0.001, 0.1, log=True),\n", + " 'max_depth': 5,\n", + " 'min_child_samples': trial.suggest_int('min_child_samples', 20, 50, step=10),\n", + " 'lambda_l1': trial.suggest_float('lambda_l1', 1e-2, 10.0, log=True),\n", + " 'lambda_l2': trial.suggest_float('lambda_l2', 1e-2, 10.0, log=True),\n", " }\n", "\n", "# parameter space for the propensity score tuning\n", "def ml_m_params(trial):\n", " return {\n", " 'n_estimators': 100,\n", - " 'learning_rate': trial.suggest_float('learning_rate', 0.005, 0.1),\n", - " 'max_depth': trial.suggest_int('max_depth', 2, 5),\n", - " 'min_child_samples': trial.suggest_int('min_child_samples', 20, 100, step=10),\n", - " 'lambda_l1': trial.suggest_float('lambda_l1', 1e-8, 10.0, log=True),\n", - " 'lambda_l2': trial.suggest_float('lambda_l2', 1e-8, 10.0, log=True),\n", + " 'learning_rate': trial.suggest_float('learning_rate', 0.001, 0.1, log=True),\n", + " 'max_depth': 5,\n", + " 'min_child_samples': trial.suggest_int('min_child_samples', 20, 50, step=10),\n", + " 'lambda_l1': trial.suggest_float('lambda_l1', 1e-2, 10.0, log=True),\n", + " 'lambda_l2': trial.suggest_float('lambda_l2', 1e-2, 10.0, log=True),\n", " }\n", "\n", "param_space = {\n", @@ -381,12 +383,12 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "2fa57cead0704b7ba184153ae5450323", + "model_id": "584ba3a562d34a238f8bfdd41ae5fdb6", "version_major": 2, "version_minor": 0 }, "text/plain": [ - " 0%| | 0/100 [00:00" + "" ] }, "execution_count": 8, @@ -433,7 +435,7 @@ ], "source": [ "optuna_settings = {\n", - " 'n_trials': 100,\n", + " 'n_trials': 200,\n", " 'show_progress_bar': True,\n", " 'verbosity': optuna.logging.WARNING, # Suppress Optuna logs\n", "}\n", @@ -489,20 +491,20 @@ " \n", " \n", " d\n", - " 215.477733\n", - " 2.505688\n", - " 85.995425\n", + " 215.273433\n", + " 2.485\n", + " 86.62916\n", " 0.0\n", - " 210.566674\n", - " 220.388792\n", + " 210.402924\n", + " 220.143943\n", " \n", " \n", "\n", "" ], "text/plain": [ - " coef std err t P>|t| 2.5 % 97.5 %\n", - "d 215.477733 2.505688 85.995425 0.0 210.566674 220.388792" + " coef std err t P>|t| 2.5 % 97.5 %\n", + "d 215.273433 2.485 86.62916 0.0 210.402924 220.143943" ] }, "execution_count": 9, @@ -563,81 +565,66 @@ { "data": { "text/plain": [ - "{'ml_g_d_lvl0': {'d': [[{'learning_rate': 0.0925852079401175,\n", - " 'max_depth': 4,\n", + "{'ml_g_d_lvl0': {'d': [[{'learning_rate': 0.09801463544687879,\n", " 'min_child_samples': 20,\n", - " 'lambda_l1': 5.506751245050714e-08,\n", - " 'lambda_l2': 1.8546099728188138e-07},\n", - " {'learning_rate': 0.0925852079401175,\n", - " 'max_depth': 4,\n", + " 'lambda_l1': 3.1247297280098136,\n", + " 'lambda_l2': 0.1676705013704926},\n", + " {'learning_rate': 0.09801463544687879,\n", " 'min_child_samples': 20,\n", - " 'lambda_l1': 5.506751245050714e-08,\n", - " 'lambda_l2': 1.8546099728188138e-07},\n", - " {'learning_rate': 0.0925852079401175,\n", - " 'max_depth': 4,\n", + " 'lambda_l1': 3.1247297280098136,\n", + " 'lambda_l2': 0.1676705013704926},\n", + " {'learning_rate': 0.09801463544687879,\n", " 'min_child_samples': 20,\n", - " 'lambda_l1': 5.506751245050714e-08,\n", - " 'lambda_l2': 1.8546099728188138e-07},\n", - " {'learning_rate': 0.0925852079401175,\n", - " 'max_depth': 4,\n", + " 'lambda_l1': 3.1247297280098136,\n", + " 'lambda_l2': 0.1676705013704926},\n", + " {'learning_rate': 0.09801463544687879,\n", " 'min_child_samples': 20,\n", - " 'lambda_l1': 5.506751245050714e-08,\n", - " 'lambda_l2': 1.8546099728188138e-07},\n", - " {'learning_rate': 0.0925852079401175,\n", - " 'max_depth': 4,\n", + " 'lambda_l1': 3.1247297280098136,\n", + " 'lambda_l2': 0.1676705013704926},\n", + " {'learning_rate': 0.09801463544687879,\n", " 'min_child_samples': 20,\n", - " 'lambda_l1': 5.506751245050714e-08,\n", - " 'lambda_l2': 1.8546099728188138e-07}]]},\n", - " 'ml_g_d_lvl1': {'d': [[{'learning_rate': 0.06559593641941427,\n", - " 'max_depth': 4,\n", + " 'lambda_l1': 3.1247297280098136,\n", + " 'lambda_l2': 0.1676705013704926}]]},\n", + " 'ml_g_d_lvl1': {'d': [[{'learning_rate': 0.09957868943595276,\n", " 'min_child_samples': 20,\n", - " 'lambda_l1': 9.379298410790415e-05,\n", - " 'lambda_l2': 0.4512927507791765},\n", - " {'learning_rate': 0.06559593641941427,\n", - " 'max_depth': 4,\n", + " 'lambda_l1': 1.0312190390696285,\n", + " 'lambda_l2': 0.058903541934281406},\n", + " {'learning_rate': 0.09957868943595276,\n", " 'min_child_samples': 20,\n", - " 'lambda_l1': 9.379298410790415e-05,\n", - " 'lambda_l2': 0.4512927507791765},\n", - " {'learning_rate': 0.06559593641941427,\n", - " 'max_depth': 4,\n", + " 'lambda_l1': 1.0312190390696285,\n", + " 'lambda_l2': 0.058903541934281406},\n", + " {'learning_rate': 0.09957868943595276,\n", " 'min_child_samples': 20,\n", - " 'lambda_l1': 9.379298410790415e-05,\n", - " 'lambda_l2': 0.4512927507791765},\n", - " {'learning_rate': 0.06559593641941427,\n", - " 'max_depth': 4,\n", + " 'lambda_l1': 1.0312190390696285,\n", + " 'lambda_l2': 0.058903541934281406},\n", + " {'learning_rate': 0.09957868943595276,\n", " 'min_child_samples': 20,\n", - " 'lambda_l1': 9.379298410790415e-05,\n", - " 'lambda_l2': 0.4512927507791765},\n", - " {'learning_rate': 0.06559593641941427,\n", - " 'max_depth': 4,\n", + " 'lambda_l1': 1.0312190390696285,\n", + " 'lambda_l2': 0.058903541934281406},\n", + " {'learning_rate': 0.09957868943595276,\n", " 'min_child_samples': 20,\n", - " 'lambda_l1': 9.379298410790415e-05,\n", - " 'lambda_l2': 0.4512927507791765}]]},\n", - " 'ml_m': {'d': [[{'learning_rate': 0.009250177700256199,\n", - " 'max_depth': 5,\n", - " 'min_child_samples': 100,\n", - " 'lambda_l1': 1.8316548720527778e-05,\n", - " 'lambda_l2': 9.614068806036798},\n", - " {'learning_rate': 0.009250177700256199,\n", - " 'max_depth': 5,\n", - " 'min_child_samples': 100,\n", - " 'lambda_l1': 1.8316548720527778e-05,\n", - " 'lambda_l2': 9.614068806036798},\n", - " {'learning_rate': 0.009250177700256199,\n", - " 'max_depth': 5,\n", - " 'min_child_samples': 100,\n", - " 'lambda_l1': 1.8316548720527778e-05,\n", - " 'lambda_l2': 9.614068806036798},\n", - " {'learning_rate': 0.009250177700256199,\n", - " 'max_depth': 5,\n", - " 'min_child_samples': 100,\n", - " 'lambda_l1': 1.8316548720527778e-05,\n", - " 'lambda_l2': 9.614068806036798},\n", - " {'learning_rate': 0.009250177700256199,\n", - " 'max_depth': 5,\n", - " 'min_child_samples': 100,\n", - " 'lambda_l1': 1.8316548720527778e-05,\n", - " 'lambda_l2': 9.614068806036798}]]}}" + " 'lambda_l1': 1.0312190390696285,\n", + " 'lambda_l2': 0.058903541934281406}]]},\n", + " 'ml_m': {'d': [[{'learning_rate': 0.0732109605604835,\n", + " 'min_child_samples': 30,\n", + " 'lambda_l1': 9.590467244372398,\n", + " 'lambda_l2': 0.078138007883929},\n", + " {'learning_rate': 0.0732109605604835,\n", + " 'min_child_samples': 30,\n", + " 'lambda_l1': 9.590467244372398,\n", + " 'lambda_l2': 0.078138007883929},\n", + " {'learning_rate': 0.0732109605604835,\n", + " 'min_child_samples': 30,\n", + " 'lambda_l1': 9.590467244372398,\n", + " 'lambda_l2': 0.078138007883929},\n", + " {'learning_rate': 0.0732109605604835,\n", + " 'min_child_samples': 30,\n", + " 'lambda_l1': 9.590467244372398,\n", + " 'lambda_l2': 0.078138007883929},\n", + " {'learning_rate': 0.0732109605604835,\n", + " 'min_child_samples': 30,\n", + " 'lambda_l1': 9.590467244372398,\n", + " 'lambda_l2': 0.078138007883929}]]}}" ] }, "execution_count": 11, @@ -691,9 +678,9 @@ { "data": { "text/plain": [ - "{'ml_g_d_lvl0': array([[14.29125279]]),\n", - " 'ml_g_d_lvl1': array([[23.19262364]]),\n", - " 'ml_m': array([[0.4100839]])}" + "{'ml_g_d_lvl0': array([[14.73579164]]),\n", + " 'ml_g_d_lvl1': array([[23.25821083]]),\n", + " 'ml_m': array([[0.4101895]])}" ] }, "execution_count": 13, @@ -732,12 +719,12 @@ "\n", " Model theta se ci_lower ci_upper\n", "Untuned 211.232659 15.657431 180.544657 241.920661\n", - " Tuned 215.477733 2.505688 210.566674 220.388792\n" + " Tuned 215.273433 2.485000 210.402924 220.143943\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1846,7 +1833,7 @@ "id": "fb8fb3b6", "metadata": {}, "source": [ - "### Hyperparametertuning with Pipelines\n", + "### Hyperparameter Tuning with Pipelines\n", "\n", "Now, let us take a look at more complex. Again, we will initialize a separate model to compare the results." ] @@ -1888,11 +1875,11 @@ "def ml_g_params_pipeline(trial):\n", " return {\n", " 'stacking__lgbm__n_estimators': 100,\n", - " 'stacking__lgbm__learning_rate': trial.suggest_float('stacking__lgbm__learning_rate', 0.005, 0.1),\n", - " 'stacking__lgbm__max_depth': trial.suggest_int('stacking__lgbm__max_depth', 2, 5),\n", - " 'stacking__lgbm__min_child_samples': trial.suggest_int('stacking__lgbm__min_child_samples', 20, 100, step=10),\n", - " 'stacking__lgbm__lambda_l1': trial.suggest_float('stacking__lgbm__lambda_l1', 1e-8, 10.0, log=True),\n", - " 'stacking__lgbm__lambda_l2': trial.suggest_float('stacking__lgbm__lambda_l2', 1e-8, 10.0, log=True),\n", + " 'stacking__lgbm__learning_rate': trial.suggest_float('stacking__lgbm__learning_rate', 0.001, 0.1, log=True),\n", + " 'stacking__lgbm__max_depth': 5,\n", + " 'stacking__lgbm__min_child_samples': trial.suggest_int('stacking__lgbm__min_child_samples', 20, 50, step=10),\n", + " 'stacking__lgbm__lambda_l1': trial.suggest_float('stacking__lgbm__lambda_l1', 1e-3, 10.0, log=True),\n", + " 'stacking__lgbm__lambda_l2': trial.suggest_float('stacking__lgbm__lambda_l2', 1e-3, 10.0, log=True),\n", " 'stacking__final_estimator__alpha': trial.suggest_float('stacking__final_estimator__alpha', 0.001, 10.0, log=True),\n", " }\n", "\n", @@ -1900,11 +1887,11 @@ "def ml_m_params_pipeline(trial):\n", " return {\n", " 'stacking__lgbm__n_estimators': 100,\n", - " 'stacking__lgbm__learning_rate': trial.suggest_float('stacking__lgbm__learning_rate', 0.005, 0.1),\n", - " 'stacking__lgbm__max_depth': trial.suggest_int('stacking__lgbm__max_depth', 2, 5),\n", - " 'stacking__lgbm__min_child_samples': trial.suggest_int('stacking__lgbm__min_child_samples', 20, 100, step=10),\n", - " 'stacking__lgbm__lambda_l1': trial.suggest_float('stacking__lgbm__lambda_l1', 1e-8, 10.0, log=True),\n", - " 'stacking__lgbm__lambda_l2': trial.suggest_float('stacking__lgbm__lambda_l2', 1e-8, 10.0, log=True),\n", + " 'stacking__lgbm__learning_rate': trial.suggest_float('stacking__lgbm__learning_rate', 0.001, 0.1, log=True),\n", + " 'stacking__lgbm__max_depth': 5,\n", + " 'stacking__lgbm__min_child_samples': trial.suggest_int('stacking__lgbm__min_child_samples', 20, 50, step=10),\n", + " 'stacking__lgbm__lambda_l1': trial.suggest_float('stacking__lgbm__lambda_l1', 1e-3, 10.0, log=True),\n", + " 'stacking__lgbm__lambda_l2': trial.suggest_float('stacking__lgbm__lambda_l2', 1e-3, 10.0, log=True),\n", " 'stacking__final_estimator__C': trial.suggest_float('stacking__final_estimator__C', 0.01, 100.0, log=True),\n", " 'stacking__final_estimator__max_iter': 1000,\n", " }\n", @@ -1934,11 +1921,11 @@ "outputs": [], "source": [ "optuna_settings_pipeline = {\n", - " 'n_trials': 100,\n", + " 'n_trials': 200,\n", " 'show_progress_bar': True,\n", " 'verbosity': optuna.logging.WARNING, # Suppress Optuna logs\n", " 'ml_g': {\n", - " 'n_trials': 50\n", + " 'n_trials': 100\n", " }\n", "}" ] @@ -1962,12 +1949,12 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "a20733dd0e6946e499718dc4b5d2e027", + "model_id": "a36e9e3c08cb4b0db31f600c3229f236", "version_major": 2, "version_minor": 0 }, "text/plain": [ - " 0%| | 0/50 [00:00\n", " \n", " d\n", - " 213.93002\n", - " 2.292806\n", - " 93.304887\n", + " 213.86343\n", + " 2.276774\n", + " 93.932651\n", " 0.0\n", - " 209.436202\n", - " 218.423837\n", + " 209.401035\n", + " 218.325825\n", " \n", " \n", "\n", @@ -2061,7 +2048,7 @@ ], "text/plain": [ " coef std err t P>|t| 2.5 % 97.5 %\n", - "d 213.93002 2.292806 93.304887 0.0 209.436202 218.423837" + "d 213.86343 2.276774 93.932651 0.0 209.401035 218.325825" ] }, "execution_count": 22, @@ -2096,7 +2083,7 @@ "id": "deb5359c", "metadata": { "tags": [ - "hide-input" + "nbsphinx-thumbnail" ] }, "outputs": [ @@ -2109,14 +2096,14 @@ "\n", " Model theta se ci_lower ci_upper\n", " Untuned 211.232659 15.657431 180.544657 241.920661\n", - " Tuned 215.477733 2.505688 210.566674 220.388792\n", + " Tuned 215.273433 2.485000 210.402924 220.143943\n", "Untuned Pipeline 213.512885 2.335125 208.936124 218.089647\n", - " Tuned Pipeline 213.930020 2.292806 209.436202 218.423837\n" + " Tuned Pipeline 213.863430 2.276774 209.401035 218.325825\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -2221,16 +2208,15 @@ "Learner name: ml_m\n", "Params name: ml_m\n", "Tuned: True\n", - "Best score: -0.5200200362819768\n", + "Best score: -0.5210215656500876\n", "Scoring method: neg_log_loss\n", "\n", "------------------ Best parameters ------------------\n", - "{'stacking__final_estimator__C': 64.258365026295,\n", - " 'stacking__lgbm__lambda_l1': 6.912832115095844e-07,\n", - " 'stacking__lgbm__lambda_l2': 5.777318708196959e-07,\n", - " 'stacking__lgbm__learning_rate': 0.05065442786589058,\n", - " 'stacking__lgbm__max_depth': 2,\n", - " 'stacking__lgbm__min_child_samples': 50}\n", + "{'stacking__final_estimator__C': 99.9143065172164,\n", + " 'stacking__lgbm__lambda_l1': 9.771463014326052,\n", + " 'stacking__lgbm__lambda_l2': 0.0013978426220758982,\n", + " 'stacking__lgbm__learning_rate': 0.0011563701553192595,\n", + " 'stacking__lgbm__min_child_samples': 30}\n", "\n" ] } @@ -2275,7 +2261,7 @@ " \n", " \n", " number\n", - " value_neg_log_loss_ml_m\n", + " value\n", " datetime_start\n", " datetime_complete\n", " duration\n", @@ -2283,7 +2269,6 @@ " params_stacking__lgbm__lambda_l1\n", " params_stacking__lgbm__lambda_l2\n", " params_stacking__lgbm__learning_rate\n", - " params_stacking__lgbm__max_depth\n", " params_stacking__lgbm__min_child_samples\n", " state\n", " \n", @@ -2292,76 +2277,71 @@ " \n", " 0\n", " 0\n", - " -0.524667\n", - " 2025-11-16 13:03:57.011876\n", - " 2025-11-16 13:03:57.404129\n", - " 0 days 00:00:00.392253\n", - " 37.735703\n", - " 7.602356e-03\n", - " 1.779912e-01\n", - " 0.050607\n", - " 4\n", - " 90\n", + " -0.528553\n", + " 2025-11-26 15:53:57.489511\n", + " 2025-11-26 15:53:57.890548\n", + " 0 days 00:00:00.401037\n", + " 0.037301\n", + " 0.498575\n", + " 0.001738\n", + " 0.060706\n", + " 30\n", " COMPLETE\n", " \n", " \n", " 1\n", " 1\n", - " -0.526856\n", - " 2025-11-16 13:03:57.404842\n", - " 2025-11-16 13:03:57.753294\n", - " 0 days 00:00:00.348452\n", - " 0.430092\n", - " 4.768254e-02\n", - " 8.455216e-06\n", - " 0.099470\n", - " 2\n", - " 90\n", + " -0.523453\n", + " 2025-11-26 15:53:57.891547\n", + " 2025-11-26 15:53:58.267444\n", + " 0 days 00:00:00.375897\n", + " 24.451158\n", + " 2.007596\n", + " 0.013849\n", + " 0.065453\n", + " 50\n", " COMPLETE\n", " \n", " \n", " 2\n", " 2\n", - " -0.522993\n", - " 2025-11-16 13:03:57.753904\n", - " 2025-11-16 13:03:58.288388\n", - " 0 days 00:00:00.534484\n", - " 13.876363\n", - " 2.985171e-01\n", - " 5.722090e-08\n", - " 0.040414\n", - " 3\n", - " 70\n", + " -0.528991\n", + " 2025-11-26 15:53:58.268406\n", + " 2025-11-26 15:53:58.600445\n", + " 0 days 00:00:00.332039\n", + " 0.014914\n", + " 1.540299\n", + " 0.242604\n", + " 0.030858\n", + " 40\n", " COMPLETE\n", " \n", " \n", " 3\n", " 3\n", - " -0.523786\n", - " 2025-11-16 13:03:58.289191\n", - " 2025-11-16 13:03:58.672689\n", - " 0 days 00:00:00.383498\n", - " 14.629854\n", - " 2.704791e-04\n", - " 1.035993e-07\n", - " 0.009606\n", - " 5\n", - " 90\n", + " -0.521994\n", + " 2025-11-26 15:53:58.601158\n", + " 2025-11-26 15:53:58.929636\n", + " 0 days 00:00:00.328478\n", + " 43.646318\n", + " 7.867187\n", + " 0.004868\n", + " 0.010726\n", + " 20\n", " COMPLETE\n", " \n", " \n", " 4\n", " 4\n", - " -0.525298\n", - " 2025-11-16 13:03:58.673501\n", - " 2025-11-16 13:03:59.102490\n", - " 0 days 00:00:00.428989\n", - " 63.939209\n", - " 2.114057e-07\n", - " 1.240781e-02\n", - " 0.087911\n", - " 2\n", - " 20\n", + " -0.528075\n", + " 2025-11-26 15:53:58.930497\n", + " 2025-11-26 15:53:59.343117\n", + " 0 days 00:00:00.412620\n", + " 0.235419\n", + " 0.636639\n", + " 6.249970\n", + " 0.014593\n", + " 30\n", " COMPLETE\n", " \n", " \n", @@ -2377,168 +2357,149 @@ " ...\n", " ...\n", " ...\n", - " ...\n", " \n", " \n", - " 95\n", - " 95\n", - " -0.521373\n", - " 2025-11-16 13:04:40.298538\n", - " 2025-11-16 13:04:40.694790\n", - " 0 days 00:00:00.396252\n", - " 76.295281\n", - " 1.324351e-08\n", - " 2.290295e-02\n", - " 0.038527\n", - " 2\n", - " 40\n", + " 195\n", + " 195\n", + " -0.521644\n", + " 2025-11-26 15:55:14.129881\n", + " 2025-11-26 15:55:14.449172\n", + " 0 days 00:00:00.319291\n", + " 97.760868\n", + " 7.085697\n", + " 0.001097\n", + " 0.001008\n", + " 30\n", " COMPLETE\n", " \n", " \n", - " 96\n", - " 96\n", - " -0.521902\n", - " 2025-11-16 13:04:40.695636\n", - " 2025-11-16 13:04:41.097448\n", - " 0 days 00:00:00.401812\n", - " 49.869486\n", - " 4.130104e-08\n", - " 1.851580e-01\n", - " 0.025975\n", - " 2\n", - " 50\n", + " 196\n", + " 196\n", + " -0.521990\n", + " 2025-11-26 15:55:14.449715\n", + " 2025-11-26 15:55:14.810118\n", + " 0 days 00:00:00.360403\n", + " 99.447375\n", + " 6.005734\n", + " 0.001353\n", + " 0.001181\n", + " 30\n", " COMPLETE\n", " \n", " \n", - " 97\n", - " 97\n", - " -0.521188\n", - " 2025-11-16 13:04:41.098114\n", - " 2025-11-16 13:04:41.523363\n", - " 0 days 00:00:00.425249\n", - " 62.624228\n", - " 6.794990e-08\n", - " 3.302448e-03\n", - " 0.035261\n", - " 2\n", - " 50\n", + " 197\n", + " 197\n", + " -0.521118\n", + " 2025-11-26 15:55:14.810960\n", + " 2025-11-26 15:55:15.111526\n", + " 0 days 00:00:00.300566\n", + " 99.675451\n", + " 7.589184\n", + " 0.001779\n", + " 0.001080\n", + " 30\n", " COMPLETE\n", " \n", " \n", - " 98\n", - " 98\n", - " -0.528183\n", - " 2025-11-16 13:04:41.524333\n", - " 2025-11-16 13:04:41.830931\n", - " 0 days 00:00:00.306598\n", - " 0.161375\n", - " 2.251480e-08\n", - " 4.756110e-02\n", - " 0.043396\n", - " 2\n", - " 40\n", + " 198\n", + " 198\n", + " -0.525316\n", + " 2025-11-26 15:55:15.112415\n", + " 2025-11-26 15:55:15.543287\n", + " 0 days 00:00:00.430872\n", + " 99.982456\n", + " 0.016786\n", + " 0.001159\n", + " 0.001184\n", + " 30\n", " COMPLETE\n", " \n", " \n", - " 99\n", - " 99\n", - " -0.521835\n", - " 2025-11-16 13:04:41.831702\n", - " 2025-11-16 13:04:42.244379\n", - " 0 days 00:00:00.412677\n", - " 98.454414\n", - " 8.809690e-08\n", - " 3.087345e-01\n", - " 0.037223\n", - " 2\n", - " 60\n", + " 199\n", + " 199\n", + " -0.521044\n", + " 2025-11-26 15:55:15.544058\n", + " 2025-11-26 15:55:15.826366\n", + " 0 days 00:00:00.282308\n", + " 80.453189\n", + " 9.930357\n", + " 0.001576\n", + " 0.001073\n", + " 30\n", " COMPLETE\n", " \n", " \n", "\n", - "

100 rows × 12 columns

\n", + "

200 rows × 11 columns

\n", "" ], "text/plain": [ - " number value_neg_log_loss_ml_m datetime_start \\\n", - "0 0 -0.524667 2025-11-16 13:03:57.011876 \n", - "1 1 -0.526856 2025-11-16 13:03:57.404842 \n", - "2 2 -0.522993 2025-11-16 13:03:57.753904 \n", - "3 3 -0.523786 2025-11-16 13:03:58.289191 \n", - "4 4 -0.525298 2025-11-16 13:03:58.673501 \n", - ".. ... ... ... \n", - "95 95 -0.521373 2025-11-16 13:04:40.298538 \n", - "96 96 -0.521902 2025-11-16 13:04:40.695636 \n", - "97 97 -0.521188 2025-11-16 13:04:41.098114 \n", - "98 98 -0.528183 2025-11-16 13:04:41.524333 \n", - "99 99 -0.521835 2025-11-16 13:04:41.831702 \n", - "\n", - " datetime_complete duration \\\n", - "0 2025-11-16 13:03:57.404129 0 days 00:00:00.392253 \n", - "1 2025-11-16 13:03:57.753294 0 days 00:00:00.348452 \n", - "2 2025-11-16 13:03:58.288388 0 days 00:00:00.534484 \n", - "3 2025-11-16 13:03:58.672689 0 days 00:00:00.383498 \n", - "4 2025-11-16 13:03:59.102490 0 days 00:00:00.428989 \n", - ".. ... ... \n", - "95 2025-11-16 13:04:40.694790 0 days 00:00:00.396252 \n", - "96 2025-11-16 13:04:41.097448 0 days 00:00:00.401812 \n", - "97 2025-11-16 13:04:41.523363 0 days 00:00:00.425249 \n", - "98 2025-11-16 13:04:41.830931 0 days 00:00:00.306598 \n", - "99 2025-11-16 13:04:42.244379 0 days 00:00:00.412677 \n", - "\n", - " params_stacking__final_estimator__C params_stacking__lgbm__lambda_l1 \\\n", - "0 37.735703 7.602356e-03 \n", - "1 0.430092 4.768254e-02 \n", - "2 13.876363 2.985171e-01 \n", - "3 14.629854 2.704791e-04 \n", - "4 63.939209 2.114057e-07 \n", - ".. ... ... \n", - "95 76.295281 1.324351e-08 \n", - "96 49.869486 4.130104e-08 \n", - "97 62.624228 6.794990e-08 \n", - "98 0.161375 2.251480e-08 \n", - "99 98.454414 8.809690e-08 \n", - "\n", - " params_stacking__lgbm__lambda_l2 params_stacking__lgbm__learning_rate \\\n", - "0 1.779912e-01 0.050607 \n", - "1 8.455216e-06 0.099470 \n", - "2 5.722090e-08 0.040414 \n", - "3 1.035993e-07 0.009606 \n", - "4 1.240781e-02 0.087911 \n", - ".. ... ... \n", - "95 2.290295e-02 0.038527 \n", - "96 1.851580e-01 0.025975 \n", - "97 3.302448e-03 0.035261 \n", - "98 4.756110e-02 0.043396 \n", - "99 3.087345e-01 0.037223 \n", - "\n", - " params_stacking__lgbm__max_depth \\\n", - "0 4 \n", - "1 2 \n", - "2 3 \n", - "3 5 \n", - "4 2 \n", - ".. ... \n", - "95 2 \n", - "96 2 \n", - "97 2 \n", - "98 2 \n", - "99 2 \n", - "\n", - " params_stacking__lgbm__min_child_samples state \n", - "0 90 COMPLETE \n", - "1 90 COMPLETE \n", - "2 70 COMPLETE \n", - "3 90 COMPLETE \n", - "4 20 COMPLETE \n", - ".. ... ... \n", - "95 40 COMPLETE \n", - "96 50 COMPLETE \n", - "97 50 COMPLETE \n", - "98 40 COMPLETE \n", - "99 60 COMPLETE \n", - "\n", - "[100 rows x 12 columns]" + " number value datetime_start datetime_complete \\\n", + "0 0 -0.528553 2025-11-26 15:53:57.489511 2025-11-26 15:53:57.890548 \n", + "1 1 -0.523453 2025-11-26 15:53:57.891547 2025-11-26 15:53:58.267444 \n", + "2 2 -0.528991 2025-11-26 15:53:58.268406 2025-11-26 15:53:58.600445 \n", + "3 3 -0.521994 2025-11-26 15:53:58.601158 2025-11-26 15:53:58.929636 \n", + "4 4 -0.528075 2025-11-26 15:53:58.930497 2025-11-26 15:53:59.343117 \n", + ".. ... ... ... ... \n", + "195 195 -0.521644 2025-11-26 15:55:14.129881 2025-11-26 15:55:14.449172 \n", + "196 196 -0.521990 2025-11-26 15:55:14.449715 2025-11-26 15:55:14.810118 \n", + "197 197 -0.521118 2025-11-26 15:55:14.810960 2025-11-26 15:55:15.111526 \n", + "198 198 -0.525316 2025-11-26 15:55:15.112415 2025-11-26 15:55:15.543287 \n", + "199 199 -0.521044 2025-11-26 15:55:15.544058 2025-11-26 15:55:15.826366 \n", + "\n", + " duration params_stacking__final_estimator__C \\\n", + "0 0 days 00:00:00.401037 0.037301 \n", + "1 0 days 00:00:00.375897 24.451158 \n", + "2 0 days 00:00:00.332039 0.014914 \n", + "3 0 days 00:00:00.328478 43.646318 \n", + "4 0 days 00:00:00.412620 0.235419 \n", + ".. ... ... \n", + "195 0 days 00:00:00.319291 97.760868 \n", + "196 0 days 00:00:00.360403 99.447375 \n", + "197 0 days 00:00:00.300566 99.675451 \n", + "198 0 days 00:00:00.430872 99.982456 \n", + "199 0 days 00:00:00.282308 80.453189 \n", + "\n", + " params_stacking__lgbm__lambda_l1 params_stacking__lgbm__lambda_l2 \\\n", + "0 0.498575 0.001738 \n", + "1 2.007596 0.013849 \n", + "2 1.540299 0.242604 \n", + "3 7.867187 0.004868 \n", + "4 0.636639 6.249970 \n", + ".. ... ... \n", + "195 7.085697 0.001097 \n", + "196 6.005734 0.001353 \n", + "197 7.589184 0.001779 \n", + "198 0.016786 0.001159 \n", + "199 9.930357 0.001576 \n", + "\n", + " params_stacking__lgbm__learning_rate \\\n", + "0 0.060706 \n", + "1 0.065453 \n", + "2 0.030858 \n", + "3 0.010726 \n", + "4 0.014593 \n", + ".. ... \n", + "195 0.001008 \n", + "196 0.001181 \n", + "197 0.001080 \n", + "198 0.001184 \n", + "199 0.001073 \n", + "\n", + " params_stacking__lgbm__min_child_samples state \n", + "0 30 COMPLETE \n", + "1 50 COMPLETE \n", + "2 40 COMPLETE \n", + "3 20 COMPLETE \n", + "4 30 COMPLETE \n", + ".. ... ... \n", + "195 30 COMPLETE \n", + "196 30 COMPLETE \n", + "197 30 COMPLETE \n", + "198 30 COMPLETE \n", + "199 30 COMPLETE \n", + "\n", + "[200 rows x 11 columns]" ] }, "execution_count": 26, @@ -2705,109 +2666,309 @@ 96, 97, 98, - 99 + 99, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110, + 111, + 112, + 113, + 114, + 115, + 116, + 117, + 118, + 119, + 120, + 121, + 122, + 123, + 124, + 125, + 126, + 127, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 136, + 137, + 138, + 139, + 140, + 141, + 142, + 143, + 144, + 145, + 146, + 147, + 148, + 149, + 150, + 151, + 152, + 153, + 154, + 155, + 156, + 157, + 158, + 159, + 160, + 161, + 162, + 163, + 164, + 165, + 166, + 167, + 168, + 169, + 170, + 171, + 172, + 173, + 174, + 175, + 176, + 177, + 178, + 179, + 180, + 181, + 182, + 183, + 184, + 185, + 186, + 187, + 188, + 189, + 190, + 191, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199 ], "y": [ - -0.5246673792552463, - -0.5268557512025864, - -0.5229927690785134, - -0.5237855161338375, - -0.5252981901140042, - -0.52273244792942, - -0.524666782331119, - -0.5245695457469202, - -0.5251540646395005, - -0.5251291178426823, - -0.5289710502109296, - -0.5247921143255782, - -0.5253549457494395, - -0.5275932520217148, - -0.5239638780338305, - -0.5246703771705652, - -0.5283636662189845, - -0.523633950914645, - -0.524324698647204, - -0.5245380821586376, - -0.5247429081812913, - -0.5222458364643957, - -0.5221720017824713, - -0.5231919904716036, - -0.526542949858886, - -0.5240146874498702, - -0.5225719878462962, - -0.5219445246243672, - -0.5232228643862769, - -0.5219073270749999, - -0.5248065280576014, - -0.5205904731684051, - -0.5209872436975156, - -0.5219058138779911, - -0.5229868716795648, - -0.5266601887482448, - -0.5237710125218932, - -0.5223226611171666, - -0.5239149971092769, - -0.5210712896803376, - -0.5239851871691985, - -0.5212414018980125, - -0.5208471000119077, - -0.5233034524317859, - -0.5217054917158865, - -0.5200200362819768, - -0.5216847823588252, - -0.5225869673883817, - -0.5289771585191569, - -0.5216173176341884, - -0.5230319899849978, - -0.5217108288796505, - -0.524490866846455, - -0.5218549982101606, - -0.5285759551382639, - -0.5208436772168876, - -0.5217138803252707, - -0.5232781200269747, - -0.5208976669236429, - -0.5225290041827534, - -0.5236160997160445, - -0.5208989670677509, - -0.5208086561618462, - -0.5217746628708194, - -0.5213591864255526, - -0.5209341456336978, - -0.5226477164481265, - -0.5221191321911459, - -0.5290288935695759, - -0.5232951192077749, - -0.5238254695720768, - -0.5208550686378427, - -0.5207623106736918, - -0.5206276068811675, - -0.5222679788575139, - -0.5206002008520167, - -0.5219491896185355, - -0.5219366099099083, - -0.5239426947051072, - -0.5214153923793081, - -0.5263994832506056, - -0.5207983641258609, - -0.5203119996283405, - -0.5213196189246586, - -0.521705856325633, - -0.5202261605920173, - -0.520254335467055, - -0.5221153250156328, - -0.5203676037858227, - -0.5221132005388393, - -0.5218054433411432, - -0.5208801838819099, - -0.5202943658437768, - -0.520559132754211, - -0.5215889774753224, - -0.5213734798442939, - -0.5219021344169802, - -0.5211875129780074, - -0.5281831879435094, - -0.5218354361227235 + -0.5285533485050931, + -0.5234530668488695, + -0.5289909251122416, + -0.5219937268019332, + -0.5280748025960298, + -0.5247511460603084, + -0.5233214137141129, + -0.5220375732865283, + -0.5247813848560081, + -0.525607889744429, + -0.521793167139381, + -0.52393449917208, + -0.5298415565612141, + -0.5220455269882187, + -0.5276474146430548, + -0.5211422010586271, + -0.5234576734117896, + -0.5250917115953776, + -0.5250459972012218, + -0.5282228598898202, + -0.5286311804687133, + -0.5236289553218089, + -0.5278280671703078, + -0.5214534923277736, + -0.52333337223033, + -0.5266448206550504, + -0.5287432505873271, + -0.5216159770110647, + -0.5231285226559483, + -0.5252325946633133, + -0.5246742907506108, + -0.5212396228009438, + -0.5215788071674636, + -0.5227829570708368, + -0.5238941790594186, + -0.5221730257565227, + -0.5211825412229547, + -0.529038145700957, + -0.5211873756002623, + -0.5255312743119468, + -0.5283849099629242, + -0.5212260637508805, + -0.5220110516231451, + -0.5243179511231577, + -0.5211868227445543, + -0.5239550045078102, + -0.5211038183747249, + -0.5245986747710893, + -0.5260468805287009, + -0.523581622748035, + -0.528929594330532, + -0.5211632204501271, + -0.5228882185475336, + -0.5243646096018659, + -0.5213680427544362, + -0.5214083051906739, + -0.5275319940416372, + -0.5290532240159138, + -0.5234568612226449, + -0.5215587395876351, + -0.5267350163473619, + -0.5220388977232652, + -0.521138524589729, + -0.5223215756901927, + -0.5220351872327159, + -0.5217445102620349, + -0.5216155030981015, + -0.5216599008112297, + -0.526674366479631, + -0.5265681628732654, + -0.5264127625718814, + -0.5214203050441409, + -0.5210925736706045, + -0.5221850923191912, + -0.5230542089481144, + -0.5226203638565847, + -0.5216952956820158, + -0.5211353530107499, + -0.5210862027236057, + -0.5221826773706424, + -0.5242012491840791, + -0.521049709425719, + -0.5210562002466338, + -0.5217631654403333, + -0.5226823461083122, + -0.5262873202598376, + -0.5222101770259606, + -0.524000195350726, + -0.5210408867514058, + -0.528209156527186, + -0.528938906838646, + -0.5211111322450857, + -0.5211257729697464, + -0.5212051574033424, + -0.5217351269684029, + -0.5210749594779168, + -0.5211064760917907, + -0.5255552939962225, + -0.5246290064701352, + -0.5219718941997751, + -0.521120623531767, + -0.5211157279849528, + -0.5245660174712901, + -0.5210837426239671, + -0.5243798463210467, + -0.5217587721342211, + -0.5210761611559112, + -0.5224955422583203, + -0.5228915290060185, + -0.5211089220703624, + -0.5215180088987477, + -0.521080876295949, + -0.5222140446779496, + -0.522531270439395, + -0.5214297184900827, + -0.5245020594282019, + -0.5211829173788083, + -0.5220518585052518, + -0.5210734007415885, + -0.5214676555545281, + -0.5211515144484844, + -0.5211050851709785, + -0.5210625470079859, + -0.5210604114901434, + -0.5234712251894624, + -0.521593032601775, + -0.525234558823649, + -0.5210804260125815, + -0.5210785424739072, + -0.525505371052851, + -0.5221445235887108, + -0.5210593879073832, + -0.5210737023669363, + -0.521083761853172, + -0.5215853405268017, + -0.5227768063008479, + -0.5211065140705554, + -0.5215101602536663, + -0.5288199238810922, + -0.5273214638606539, + -0.5257277842329631, + -0.5210695412795339, + -0.5210753071327717, + -0.5210703536387976, + -0.5218009417179299, + -0.5211164503065419, + -0.5226296090871653, + -0.5218783527595913, + -0.5210395304903896, + -0.5210700655263808, + -0.521145559792451, + -0.5217375844208683, + -0.5210457209511343, + -0.5210895780964436, + -0.5216443499814831, + -0.5228431433329648, + -0.5210832218278626, + -0.5274268727732995, + -0.5211216755913307, + -0.5219205044901309, + -0.524766867769203, + -0.5251195052420332, + -0.5210758044384366, + -0.521089097440652, + -0.521749878026454, + -0.5210958011908401, + -0.5274189971923838, + -0.521237938312581, + -0.5236942419543406, + -0.521062418359218, + -0.5210373652682448, + -0.5210387651008384, + -0.5210721524878251, + -0.5210426125489409, + -0.5210217893863571, + -0.5210228318027557, + -0.5210260738428435, + -0.5210216027586888, + -0.5210252358628062, + -0.5210313416300331, + -0.5210345712133734, + -0.5210229672517228, + -0.521783480697217, + -0.5210361216790312, + -0.5210267851893767, + -0.5210368512770732, + -0.521031021928863, + -0.5217844559373256, + -0.5210215656500876, + -0.5210279207137334, + -0.5218414039206085, + -0.5217026562163004, + -0.5210235606243971, + -0.5210222268319301, + -0.5210315702789767, + -0.5216440218826598, + -0.5219900384499969, + -0.521118206357774, + -0.525315872071635, + -0.5210436227523191 ] }, { @@ -2914,109 +3075,309 @@ 96, 97, 98, - 99 + 99, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110, + 111, + 112, + 113, + 114, + 115, + 116, + 117, + 118, + 119, + 120, + 121, + 122, + 123, + 124, + 125, + 126, + 127, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 136, + 137, + 138, + 139, + 140, + 141, + 142, + 143, + 144, + 145, + 146, + 147, + 148, + 149, + 150, + 151, + 152, + 153, + 154, + 155, + 156, + 157, + 158, + 159, + 160, + 161, + 162, + 163, + 164, + 165, + 166, + 167, + 168, + 169, + 170, + 171, + 172, + 173, + 174, + 175, + 176, + 177, + 178, + 179, + 180, + 181, + 182, + 183, + 184, + 185, + 186, + 187, + 188, + 189, + 190, + 191, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199 ], "y": [ - -0.5246673792552463, - -0.5246673792552463, - -0.5229927690785134, - -0.5229927690785134, - -0.5229927690785134, - -0.52273244792942, - -0.52273244792942, - -0.52273244792942, - -0.52273244792942, - -0.52273244792942, - -0.52273244792942, - -0.52273244792942, - -0.52273244792942, - -0.52273244792942, - -0.52273244792942, - -0.52273244792942, - -0.52273244792942, - -0.52273244792942, - -0.52273244792942, - -0.52273244792942, - -0.52273244792942, - -0.5222458364643957, - -0.5221720017824713, - -0.5221720017824713, - -0.5221720017824713, - -0.5221720017824713, - -0.5221720017824713, - -0.5219445246243672, - -0.5219445246243672, - -0.5219073270749999, - -0.5219073270749999, - -0.5205904731684051, - -0.5205904731684051, - -0.5205904731684051, - -0.5205904731684051, - -0.5205904731684051, - -0.5205904731684051, - -0.5205904731684051, - -0.5205904731684051, - -0.5205904731684051, - -0.5205904731684051, - -0.5205904731684051, - -0.5205904731684051, - -0.5205904731684051, - -0.5205904731684051, - -0.5200200362819768, - -0.5200200362819768, - -0.5200200362819768, - -0.5200200362819768, - -0.5200200362819768, - -0.5200200362819768, - -0.5200200362819768, - -0.5200200362819768, - -0.5200200362819768, - -0.5200200362819768, - -0.5200200362819768, - -0.5200200362819768, - -0.5200200362819768, - -0.5200200362819768, - -0.5200200362819768, - -0.5200200362819768, - -0.5200200362819768, - -0.5200200362819768, - -0.5200200362819768, - -0.5200200362819768, - -0.5200200362819768, - -0.5200200362819768, - -0.5200200362819768, - -0.5200200362819768, - -0.5200200362819768, - -0.5200200362819768, - -0.5200200362819768, - -0.5200200362819768, - -0.5200200362819768, - -0.5200200362819768, - -0.5200200362819768, - -0.5200200362819768, - -0.5200200362819768, - -0.5200200362819768, - -0.5200200362819768, - -0.5200200362819768, - -0.5200200362819768, - -0.5200200362819768, - -0.5200200362819768, - -0.5200200362819768, - -0.5200200362819768, - -0.5200200362819768, - -0.5200200362819768, - -0.5200200362819768, - -0.5200200362819768, - -0.5200200362819768, - -0.5200200362819768, - -0.5200200362819768, - -0.5200200362819768, - -0.5200200362819768, - -0.5200200362819768, - -0.5200200362819768, - -0.5200200362819768, - -0.5200200362819768, - -0.5200200362819768 + -0.5285533485050931, + -0.5234530668488695, + -0.5234530668488695, + -0.5219937268019332, + -0.5219937268019332, + -0.5219937268019332, + -0.5219937268019332, + -0.5219937268019332, + -0.5219937268019332, + -0.5219937268019332, + -0.521793167139381, + -0.521793167139381, + -0.521793167139381, + -0.521793167139381, + -0.521793167139381, + -0.5211422010586271, + -0.5211422010586271, + -0.5211422010586271, + -0.5211422010586271, + -0.5211422010586271, + -0.5211422010586271, + -0.5211422010586271, + -0.5211422010586271, + -0.5211422010586271, + -0.5211422010586271, + -0.5211422010586271, + -0.5211422010586271, + -0.5211422010586271, + -0.5211422010586271, + -0.5211422010586271, + -0.5211422010586271, + -0.5211422010586271, + -0.5211422010586271, + -0.5211422010586271, + -0.5211422010586271, + -0.5211422010586271, + -0.5211422010586271, + -0.5211422010586271, + -0.5211422010586271, + -0.5211422010586271, + -0.5211422010586271, + -0.5211422010586271, + -0.5211422010586271, + -0.5211422010586271, + -0.5211422010586271, + -0.5211422010586271, + -0.5211038183747249, + -0.5211038183747249, + -0.5211038183747249, + -0.5211038183747249, + -0.5211038183747249, + -0.5211038183747249, + -0.5211038183747249, + -0.5211038183747249, + -0.5211038183747249, + -0.5211038183747249, + -0.5211038183747249, + -0.5211038183747249, + -0.5211038183747249, + -0.5211038183747249, + -0.5211038183747249, + -0.5211038183747249, + -0.5211038183747249, + -0.5211038183747249, + -0.5211038183747249, + -0.5211038183747249, + -0.5211038183747249, + -0.5211038183747249, + -0.5211038183747249, + -0.5211038183747249, + -0.5211038183747249, + -0.5211038183747249, + -0.5210925736706045, + -0.5210925736706045, + -0.5210925736706045, + -0.5210925736706045, + -0.5210925736706045, + -0.5210925736706045, + -0.5210862027236057, + -0.5210862027236057, + -0.5210862027236057, + -0.521049709425719, + -0.521049709425719, + -0.521049709425719, + -0.521049709425719, + -0.521049709425719, + -0.521049709425719, + -0.521049709425719, + -0.5210408867514058, + -0.5210408867514058, + -0.5210408867514058, + -0.5210408867514058, + -0.5210408867514058, + -0.5210408867514058, + -0.5210408867514058, + -0.5210408867514058, + -0.5210408867514058, + -0.5210408867514058, + -0.5210408867514058, + -0.5210408867514058, + -0.5210408867514058, + -0.5210408867514058, + -0.5210408867514058, + -0.5210408867514058, + -0.5210408867514058, + -0.5210408867514058, + -0.5210408867514058, + -0.5210408867514058, + -0.5210408867514058, + -0.5210408867514058, + -0.5210408867514058, + -0.5210408867514058, + -0.5210408867514058, + -0.5210408867514058, + -0.5210408867514058, + -0.5210408867514058, + -0.5210408867514058, + -0.5210408867514058, + -0.5210408867514058, + -0.5210408867514058, + -0.5210408867514058, + -0.5210408867514058, + -0.5210408867514058, + -0.5210408867514058, + -0.5210408867514058, + -0.5210408867514058, + -0.5210408867514058, + -0.5210408867514058, + -0.5210408867514058, + -0.5210408867514058, + -0.5210408867514058, + -0.5210408867514058, + -0.5210408867514058, + -0.5210408867514058, + -0.5210408867514058, + -0.5210408867514058, + -0.5210408867514058, + -0.5210408867514058, + -0.5210408867514058, + -0.5210408867514058, + -0.5210408867514058, + -0.5210408867514058, + -0.5210408867514058, + -0.5210408867514058, + -0.5210408867514058, + -0.5210408867514058, + -0.5210408867514058, + -0.5210408867514058, + -0.5210395304903896, + -0.5210395304903896, + -0.5210395304903896, + -0.5210395304903896, + -0.5210395304903896, + -0.5210395304903896, + -0.5210395304903896, + -0.5210395304903896, + -0.5210395304903896, + -0.5210395304903896, + -0.5210395304903896, + -0.5210395304903896, + -0.5210395304903896, + -0.5210395304903896, + -0.5210395304903896, + -0.5210395304903896, + -0.5210395304903896, + -0.5210395304903896, + -0.5210395304903896, + -0.5210395304903896, + -0.5210395304903896, + -0.5210395304903896, + -0.5210373652682448, + -0.5210373652682448, + -0.5210373652682448, + -0.5210373652682448, + -0.5210217893863571, + -0.5210217893863571, + -0.5210217893863571, + -0.5210216027586888, + -0.5210216027586888, + -0.5210216027586888, + -0.5210216027586888, + -0.5210216027586888, + -0.5210216027586888, + -0.5210216027586888, + -0.5210216027586888, + -0.5210216027586888, + -0.5210216027586888, + -0.5210216027586888, + -0.5210215656500876, + -0.5210215656500876, + -0.5210215656500876, + -0.5210215656500876, + -0.5210215656500876, + -0.5210215656500876, + -0.5210215656500876, + -0.5210215656500876, + -0.5210215656500876, + -0.5210215656500876, + -0.5210215656500876, + -0.5210215656500876 ] }, { @@ -3864,9 +4225,9 @@ } }, "text/html": [ - "