diff --git a/master/_images/parameter_types_11_0.png b/master/_images/parameter_types_11_0.png new file mode 100644 index 00000000..4bea406c Binary files /dev/null and b/master/_images/parameter_types_11_0.png differ diff --git a/master/_images/parameter_types_17_0.png b/master/_images/parameter_types_17_0.png new file mode 100644 index 00000000..111c7dd9 Binary files /dev/null and b/master/_images/parameter_types_17_0.png differ diff --git a/master/_images/parameter_types_3_0.png b/master/_images/parameter_types_3_0.png new file mode 100644 index 00000000..e7a4b21e Binary files /dev/null and b/master/_images/parameter_types_3_0.png differ diff --git a/master/_sources/advanced-tour.ipynb.txt b/master/_sources/advanced-tour.ipynb.txt index dc72e40e..9e93d09d 100644 --- a/master/_sources/advanced-tour.ipynb.txt +++ b/master/_sources/advanced-tour.ipynb.txt @@ -96,7 +96,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Next point to probe is: {'x': -0.331911981189704, 'y': 1.3219469606529486}\n" + "Next point to probe is: {'x': np.float64(-0.331911981189704), 'y': np.float64(1.3219469606529486)}\n" ] } ], @@ -167,12 +167,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "-18.503835804889988 {'x': 1.953072105336, 'y': -2.9609778030491904}\n", - "-1.0819533157901717 {'x': 0.22703572807626315, 'y': 2.4249238905875123}\n", - "-6.50219704520679 {'x': -1.9991881984624875, 'y': 2.872282989383577}\n", - "-5.747604713731052 {'x': -1.994467585936897, 'y': -0.664242699361514}\n", - "-2.9682431497650823 {'x': 1.9737252084307952, 'y': 1.269540259274744}\n", - "{'target': 0.7861845912690544, 'params': {'x': -0.331911981189704, 'y': 1.3219469606529486}}\n" + "-18.707136686093495 {'x': np.float64(1.9261486197444082), 'y': np.float64(-2.9996360060323246)}\n", + "0.750594563473972 {'x': np.float64(-0.3763326769822668), 'y': np.float64(1.328297354179696)}\n", + "-6.559031075654336 {'x': np.float64(1.979183535803597), 'y': np.float64(2.9083667381450318)}\n", + "-6.915481333972961 {'x': np.float64(-1.9686133847781613), 'y': np.float64(-1.009985740060171)}\n", + "-6.8600832617014085 {'x': np.float64(-1.9763198875239296), 'y': np.float64(2.9885278383464513)}\n", + "{'target': np.float64(0.7861845912690544), 'params': {'x': np.float64(-0.331911981189704), 'y': np.float64(1.3219469606529486)}}\n" ] } ], @@ -190,112 +190,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## 2. Dealing with discrete parameters\n", - "\n", - "**There is no principled way of dealing with discrete parameters using this package.**\n", - "\n", - "Ok, now that we got that out of the way, how do you do it? You're bound to be in a situation where some of your function's parameters may only take on discrete values. Unfortunately, the nature of bayesian optimization with gaussian processes doesn't allow for an easy/intuitive way of dealing with discrete parameters - but that doesn't mean it is impossible. The example below showcases a simple, yet reasonably adequate, way to dealing with discrete parameters." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "def func_with_discrete_params(x, y, d):\n", - " # Simulate necessity of having d being discrete.\n", - " assert type(d) == int\n", - " \n", - " return ((x + y + d) // (1 + d)) / (1 + (x + y) ** 2)" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [], - "source": [ - "def function_to_be_optimized(x, y, w):\n", - " d = int(w)\n", - " return func_with_discrete_params(x, y, d)" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [], - "source": [ - "optimizer = BayesianOptimization(\n", - " f=function_to_be_optimized,\n", - " pbounds={'x': (-10, 10), 'y': (-10, 10), 'w': (0, 5)},\n", - " verbose=2,\n", - " random_state=1,\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "| iter | target | w | x | y |\n", - "-------------------------------------------------------------\n", - "| \u001b[30m1 | \u001b[30m-0.06199 | \u001b[30m2.085 | \u001b[30m4.406 | \u001b[30m-9.998 |\n", - "| \u001b[35m2 | \u001b[35m-0.0344 | \u001b[35m1.512 | \u001b[35m-7.065 | \u001b[35m-8.153 |\n", - "| \u001b[30m3 | \u001b[30m-0.2177 | \u001b[30m0.9313 | \u001b[30m-3.089 | \u001b[30m-2.065 |\n", - "| \u001b[35m4 | \u001b[35m0.1865 | \u001b[35m2.694 | \u001b[35m-1.616 | \u001b[35m3.704 |\n", - "| \u001b[30m5 | \u001b[30m-0.2187 | \u001b[30m1.022 | \u001b[30m7.562 | \u001b[30m-9.452 |\n", - "| \u001b[35m6 | \u001b[35m0.2488 | \u001b[35m2.684 | \u001b[35m-2.188 | \u001b[35m3.925 |\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "| \u001b[35m7 | \u001b[35m0.2948 | \u001b[35m2.683 | \u001b[35m-2.534 | \u001b[35m4.08 |\n", - "| \u001b[35m8 | \u001b[35m0.3202 | \u001b[35m2.514 | \u001b[35m-3.83 | \u001b[35m5.287 |\n", - "| \u001b[30m9 | \u001b[30m0.0 | \u001b[30m4.057 | \u001b[30m-4.458 | \u001b[30m3.928 |\n", - "| \u001b[35m10 | \u001b[35m0.4802 | \u001b[35m2.296 | \u001b[35m-3.518 | \u001b[35m4.558 |\n", - "| \u001b[30m11 | \u001b[30m0.0 | \u001b[30m1.084 | \u001b[30m-3.737 | \u001b[30m4.472 |\n", - "| \u001b[30m12 | \u001b[30m0.0 | \u001b[30m2.649 | \u001b[30m-3.861 | \u001b[30m4.353 |\n", - "| \u001b[30m13 | \u001b[30m0.0 | \u001b[30m2.442 | \u001b[30m-3.658 | \u001b[30m4.599 |\n", - "| \u001b[30m14 | \u001b[30m-0.05801 | \u001b[30m1.935 | \u001b[30m-0.4758 | \u001b[30m-8.755 |\n", - "| \u001b[30m15 | \u001b[30m0.0 | \u001b[30m2.337 | \u001b[30m7.973 | \u001b[30m-8.96 |\n", - "| \u001b[30m16 | \u001b[30m0.07699 | \u001b[30m0.6926 | \u001b[30m5.59 | \u001b[30m6.854 |\n", - "| \u001b[30m17 | \u001b[30m-0.02025 | \u001b[30m3.534 | \u001b[30m-8.943 | \u001b[30m1.987 |\n", - "| \u001b[30m18 | \u001b[30m0.0 | \u001b[30m2.59 | \u001b[30m-7.339 | \u001b[30m5.941 |\n", - "| \u001b[30m19 | \u001b[30m0.0929 | \u001b[30m2.237 | \u001b[30m-4.535 | \u001b[30m9.065 |\n", - "| \u001b[30m20 | \u001b[30m0.1538 | \u001b[30m0.477 | \u001b[30m2.931 | \u001b[30m2.683 |\n", - "| \u001b[30m21 | \u001b[30m0.0 | \u001b[30m0.9999 | \u001b[30m4.397 | \u001b[30m-3.971 |\n", - "| \u001b[30m22 | \u001b[30m-0.01894 | \u001b[30m3.764 | \u001b[30m-7.043 | \u001b[30m-3.184 |\n", - "| \u001b[30m23 | \u001b[30m0.03683 | \u001b[30m1.851 | \u001b[30m5.783 | \u001b[30m7.966 |\n", - "| \u001b[30m24 | \u001b[30m-0.04359 | \u001b[30m1.615 | \u001b[30m-5.133 | \u001b[30m-6.556 |\n", - "| \u001b[30m25 | \u001b[30m0.02617 | \u001b[30m3.863 | \u001b[30m0.1052 | \u001b[30m8.579 |\n", - "| \u001b[30m26 | \u001b[30m-0.1071 | \u001b[30m0.8131 | \u001b[30m-0.7949 | \u001b[30m-9.292 |\n", - "| \u001b[30m27 | \u001b[30m0.0 | \u001b[30m4.969 | \u001b[30m8.778 | \u001b[30m-8.467 |\n", - "| \u001b[30m28 | \u001b[30m-0.1372 | \u001b[30m0.9475 | \u001b[30m-1.019 | \u001b[30m-7.018 |\n", - "| \u001b[30m29 | \u001b[30m0.08078 | \u001b[30m1.917 | \u001b[30m-0.2606 | \u001b[30m6.272 |\n", - "| \u001b[30m30 | \u001b[30m0.02003 | \u001b[30m4.278 | \u001b[30m3.8 | \u001b[30m8.398 |\n", - "=============================================================\n" - ] - } - ], - "source": [ - "optimizer.set_gp_params(alpha=1e-3)\n", - "optimizer.maximize()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 3. Tuning the underlying Gaussian Process\n", + "## 2. Tuning the underlying Gaussian Process\n", "\n", "The bayesian optimization algorithm works by performing a gaussian process regression of the observed combination of parameters and their associated target values. The predicted parameter $\\rightarrow$ target hyper-surface (and its uncertainty) is then used to guide the next best point to probe." ] @@ -304,14 +199,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### 3.1 Passing parameter to the GP\n", + "### 2.1 Passing parameter to the GP\n", "\n", "Depending on the problem it could be beneficial to change the default parameters of the underlying GP. You can use the `optimizer.set_gp_params` method to do this:" ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -320,12 +215,12 @@ "text": [ "| iter | target | x | y |\n", "-------------------------------------------------\n", - "| \u001b[30m1 | \u001b[30m0.7862 | \u001b[30m-0.3319 | \u001b[30m1.322 |\n", - "| \u001b[30m2 | \u001b[30m-18.19 | \u001b[30m1.957 | \u001b[30m-2.919 |\n", - "| \u001b[30m3 | \u001b[30m-12.05 | \u001b[30m-1.969 | \u001b[30m-2.029 |\n", - "| \u001b[30m4 | \u001b[30m-7.463 | \u001b[30m0.6032 | \u001b[30m-1.846 |\n", - "| \u001b[30m5 | \u001b[30m-1.093 | \u001b[30m1.444 | \u001b[30m1.096 |\n", - "| \u001b[35m6 | \u001b[35m0.8586 | \u001b[35m-0.2165 | \u001b[35m1.307 |\n", + "| \u001b[39m1 \u001b[39m | \u001b[39m0.7862 \u001b[39m | \u001b[39m-0.331911\u001b[39m | \u001b[39m1.3219469\u001b[39m |\n", + "| \u001b[39m2 \u001b[39m | \u001b[39m-18.34 \u001b[39m | \u001b[39m1.9021640\u001b[39m | \u001b[39m-2.965222\u001b[39m |\n", + "| \u001b[35m3 \u001b[39m | \u001b[35m0.8731 \u001b[39m | \u001b[35m-0.298167\u001b[39m | \u001b[35m1.1948749\u001b[39m |\n", + "| \u001b[39m4 \u001b[39m | \u001b[39m-6.497 \u001b[39m | \u001b[39m1.9876938\u001b[39m | \u001b[39m2.8830942\u001b[39m |\n", + "| \u001b[39m5 \u001b[39m | \u001b[39m-4.286 \u001b[39m | \u001b[39m-1.995643\u001b[39m | \u001b[39m-0.141769\u001b[39m |\n", + "| \u001b[39m6 \u001b[39m | \u001b[39m-6.781 \u001b[39m | \u001b[39m-1.953302\u001b[39m | \u001b[39m2.9913127\u001b[39m |\n", "=================================================\n" ] } @@ -348,7 +243,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### 3.2 Tuning the `alpha` parameter\n", + "### 2.2 Tuning the `alpha` parameter\n", "\n", "When dealing with functions with discrete parameters,or particularly erratic target space it might be beneficial to increase the value of the `alpha` parameter. This parameters controls how much noise the GP can handle, so increase it whenever you think that extra flexibility is needed." ] @@ -358,7 +253,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### 3.3 Changing kernels\n", + "### 2.3 Changing kernels\n", "\n", "By default this package uses the Matern 2.5 kernel. Depending on your use case you may find that tuning the GP kernel could be beneficial. You're on your own here since these are very specific solutions to very specific problems. You should start with the [scikit learn docs](https://scikit-learn.org/stable/modules/gaussian_process.html#kernels-for-gaussian-processes)." ] @@ -376,7 +271,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -385,7 +280,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -399,7 +294,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -411,7 +306,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -433,7 +328,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -449,7 +344,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -476,7 +371,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 16, "metadata": {}, "outputs": [ { @@ -485,7 +380,7 @@ "['optimization:start', 'optimization:step', 'optimization:end']" ] }, - "execution_count": 20, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } @@ -497,7 +392,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "bayesian-optimization-t6LLJ9me-py3.10", "language": "python", "name": "python3" }, @@ -511,7 +406,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.1.undefined" + "version": "3.10.13" }, "nbdime-conflicts": { "local_diff": [ diff --git a/master/_sources/basic-tour.ipynb.txt b/master/_sources/basic-tour.ipynb.txt index 3cbcbd40..4ecd8329 100644 --- a/master/_sources/basic-tour.ipynb.txt +++ b/master/_sources/basic-tour.ipynb.txt @@ -252,7 +252,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Or as an iterable. Beware that the order has to be alphabetical. You can usee `optimizer.space.keys` for guidance" + "Or as an iterable. Beware that the order has to match the order of the initial `pbounds` dictionary. You can usee `optimizer.space.keys` for guidance" ] }, { diff --git a/master/_sources/index.rst.txt b/master/_sources/index.rst.txt index ac664a58..5c198c6f 100644 --- a/master/_sources/index.rst.txt +++ b/master/_sources/index.rst.txt @@ -11,6 +11,7 @@ Basic Tour Advanced Tour Constrained Bayesian Optimization + Parameter Types Sequential Domain Reduction Acquisition Functions Exploration vs. Exploitation @@ -26,6 +27,7 @@ reference/constraint reference/domain_reduction reference/target_space + reference/parameter reference/exception reference/other @@ -121,11 +123,13 @@ section. We suggest that you: to learn how to use the package's most important features. - Take a look at the `advanced tour notebook `__ - to learn how to make the package more flexible, how to deal with - categorical parameters, how to use observers, and more. + to learn how to make the package more flexible or how to use observers. - To learn more about acquisition functions, a central building block of bayesian optimization, see the `acquisition functions notebook `__ +- If you want to optimize over integer-valued or categorical + parameters, see the `parameter types + notebook `__. - Check out this `notebook `__ with a step by step visualization of how this method works. @@ -195,6 +199,20 @@ For constrained optimization: year={2014} } +For optimization over non-float parameters: + +:: + + @article{garrido2020dealing, + title={Dealing with categorical and integer-valued variables in bayesian optimization with gaussian processes}, + author={Garrido-Merch{\'a}n, Eduardo C and Hern{\'a}ndez-Lobato, Daniel}, + journal={Neurocomputing}, + volume={380}, + pages={20--35}, + year={2020}, + publisher={Elsevier} + } + .. |tests| image:: https://github.com/bayesian-optimization/BayesianOptimization/actions/workflows/run_tests.yml/badge.svg .. |Codecov| image:: https://codecov.io/github/bayesian-optimization/BayesianOptimization/badge.svg?branch=master&service=github :target: https://codecov.io/github/bayesian-optimization/BayesianOptimization?branch=master diff --git a/master/_sources/parameter_types.ipynb.txt b/master/_sources/parameter_types.ipynb.txt new file mode 100644 index 00000000..3d668300 --- /dev/null +++ b/master/_sources/parameter_types.ipynb.txt @@ -0,0 +1,756 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Optimizing over non-float Parameters\n", + "\n", + "Sometimes, you need to optimize a target that is not just a function of floating-point values, but relies on integer or categorical parameters. This notebook shows how such problems are handled by following an approach from [\"Dealing with categorical and integer-valued variables in Bayesian Optimization with Gaussian processes\" by Garrido-Merchán and Hernández-Lobato](https://arxiv.org/abs/1805.03463). One simple way of handling an integer-valued parameter is to run the optimization as normal, but then round to the nearest integer after a point has been suggested. This method is similar, except that the rounding is performed in the _kernel_. Why does this matter? It means that the kernel is aware that two parameters, that map the to same point but are potentially distinct before this transformation are the same." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import warnings\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from bayes_opt import BayesianOptimization\n", + "from bayes_opt import acquisition\n", + "\n", + "from sklearn.gaussian_process.kernels import Matern\n", + "\n", + "# suppress warnings about this being an experimental feature\n", + "warnings.filterwarnings(action=\"ignore\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. Simple integer-valued function\n", + "Let's look at a simple, one-dimensional, integer-valued target function and compare a typed optimizer and a continuous optimizer." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def target_function_1d(x):\n", + " return np.sin(np.round(x)) - np.abs(np.round(x) / 5)\n", + "\n", + "c_pbounds = {'x': (-10, 10)}\n", + "bo_cont = BayesianOptimization(target_function_1d, c_pbounds, verbose=0, random_state=1)\n", + "\n", + "# one way of constructing an integer-valued parameter is to add a third element to the tuple\n", + "d_pbounds = {'x': (-10, 10, int)}\n", + "bo_disc = BayesianOptimization(target_function_1d, d_pbounds, verbose=0, random_state=1)\n", + "\n", + "fig, axs = plt.subplots(2, 1, figsize=(10, 6), sharex=True, sharey=True)\n", + "\n", + "bo_cont.maximize(init_points=2, n_iter=10)\n", + "bo_cont.acquisition_function._fit_gp(bo_cont._gp, bo_cont.space)\n", + "\n", + "y_mean, y_std = bo_cont._gp.predict(np.linspace(-10, 10, 1000).reshape(-1, 1), return_std=True)\n", + "axs[0].set_title('Continuous')\n", + "axs[0].plot(np.linspace(-10, 10, 1000), target_function_1d(np.linspace(-10, 10, 1000)), 'k--', label='True function')\n", + "axs[0].plot(np.linspace(-10, 10, 1000), y_mean, label='Predicted mean')\n", + "axs[0].fill_between(np.linspace(-10, 10, 1000), y_mean - y_std, y_mean + y_std, alpha=0.3, label='Predicted std')\n", + "axs[0].plot(bo_cont.space.params, bo_cont.space.target, 'ro')\n", + "\n", + "bo_disc.maximize(init_points=2, n_iter=10)\n", + "bo_disc.acquisition_function._fit_gp(bo_disc._gp, bo_disc.space)\n", + "\n", + "y_mean, y_std = bo_disc._gp.predict(np.linspace(-10, 10, 1000).reshape(-1, 1), return_std=True)\n", + "axs[1].set_title('Discrete')\n", + "axs[1].plot(np.linspace(-10, 10, 1000), target_function_1d(np.linspace(-10, 10, 1000)), 'k--', label='True function')\n", + "axs[1].plot(np.linspace(-10, 10, 1000), y_mean, label='Predicted mean')\n", + "axs[1].fill_between(np.linspace(-10, 10, 1000), y_mean - y_std, y_mean + y_std, alpha=0.3, label='Predicted std')\n", + "axs[1].plot(bo_disc.space.params, bo_disc.space.target, 'ro')\n", + "\n", + "for ax in axs:\n", + " ax.grid(True)\n", + "fig.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can see, that the discrete optimizer is aware that the function is discrete and does not try to predict values between the integers. The continuous optimizer tries to predict values between the integers, despite the fact that these are known.\n", + "We can also see that the discrete optimizer predicts blocky mean and standard deviations, which is a result of the discrete nature of the function." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. Mixed-parameter optimization" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def discretized_function(x, y):\n", + " y = np.round(y)\n", + " return (-1*np.cos(x)**np.abs(y) + -1*np.cos(y)) + 0.1 * (x + y) - 0.01 * (x**2 + y**2)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# Bounded region of parameter space\n", + "c_pbounds = {'x': (-5, 5), 'y': (-5, 5)}" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "labels = [\"All-float Optimizer\", \"Typed Optimizer\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "continuous_optimizer = BayesianOptimization(\n", + " f=discretized_function,\n", + " acquisition_function=acquisition.ExpectedImprovement(xi=0.01, random_state=1),\n", + " pbounds=c_pbounds,\n", + " verbose=2,\n", + " random_state=1,\n", + ")\n", + "\n", + "continuous_optimizer.set_gp_params(kernel=Matern(nu=2.5, length_scale=np.ones(2)))\n", + "\n", + "d_pbounds = {'x': (-5, 5), 'y': (-5, 5, int)}\n", + "discrete_optimizer = BayesianOptimization(\n", + " f=discretized_function,\n", + " acquisition_function=acquisition.ExpectedImprovement(xi=0.01, random_state=1),\n", + " pbounds=d_pbounds,\n", + " verbose=2,\n", + " random_state=1,\n", + ")\n", + "\n", + "discrete_optimizer.set_gp_params(kernel=Matern(nu=2.5, length_scale=np.ones(2)));" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "==================== All-float Optimizer ====================\n", + "\n", + "| iter | target | x | y |\n", + "-------------------------------------------------\n", + "| \u001b[39m1 \u001b[39m | \u001b[39m0.03061 \u001b[39m | \u001b[39m-0.829779\u001b[39m | \u001b[39m2.2032449\u001b[39m |\n", + "| \u001b[39m2 \u001b[39m | \u001b[39m-0.6535 \u001b[39m | \u001b[39m-4.998856\u001b[39m | \u001b[39m-1.976674\u001b[39m |\n", + "| \u001b[35m3 \u001b[39m | \u001b[35m0.8025 \u001b[39m | \u001b[35m-0.829779\u001b[39m | \u001b[35m2.6549696\u001b[39m |\n", + "| \u001b[35m4 \u001b[39m | \u001b[35m0.9203 \u001b[39m | \u001b[35m-0.981065\u001b[39m | \u001b[35m2.6644394\u001b[39m |\n", + "| \u001b[35m5 \u001b[39m | \u001b[35m1.008 \u001b[39m | \u001b[35m-1.652553\u001b[39m | \u001b[35m2.7133425\u001b[39m |\n", + "| \u001b[39m6 \u001b[39m | \u001b[39m0.9926 \u001b[39m | \u001b[39m-1.119714\u001b[39m | \u001b[39m2.8358733\u001b[39m |\n", + "| \u001b[35m7 \u001b[39m | \u001b[35m1.322 \u001b[39m | \u001b[35m-2.418942\u001b[39m | \u001b[35m3.4600371\u001b[39m |\n", + "| \u001b[39m8 \u001b[39m | \u001b[39m-0.5063 \u001b[39m | \u001b[39m-3.092074\u001b[39m | \u001b[39m3.7368226\u001b[39m |\n", + "| \u001b[39m9 \u001b[39m | \u001b[39m-0.6432 \u001b[39m | \u001b[39m-4.089558\u001b[39m | \u001b[39m-0.560384\u001b[39m |\n", + "| \u001b[39m10 \u001b[39m | \u001b[39m1.267 \u001b[39m | \u001b[39m-2.360726\u001b[39m | \u001b[39m3.3725022\u001b[39m |\n", + "| \u001b[39m11 \u001b[39m | \u001b[39m0.4649 \u001b[39m | \u001b[39m-2.247113\u001b[39m | \u001b[39m3.7419056\u001b[39m |\n", + "| \u001b[39m12 \u001b[39m | \u001b[39m1.0 \u001b[39m | \u001b[39m-1.740988\u001b[39m | \u001b[39m3.4854116\u001b[39m |\n", + "| \u001b[39m13 \u001b[39m | \u001b[39m0.986 \u001b[39m | \u001b[39m1.2164322\u001b[39m | \u001b[39m4.4938459\u001b[39m |\n", + "| \u001b[39m14 \u001b[39m | \u001b[39m-2.27 \u001b[39m | \u001b[39m-2.213867\u001b[39m | \u001b[39m0.3585570\u001b[39m |\n", + "| \u001b[39m15 \u001b[39m | \u001b[39m-1.853 \u001b[39m | \u001b[39m1.7935035\u001b[39m | \u001b[39m-0.377351\u001b[39m |\n", + "=================================================\n", + "Max: 1.321554535694256\n", + "\n", + "\n", + "==================== Typed Optimizer ====================\n", + "\n", + "| iter | target | x | y |\n", + "-------------------------------------------------\n", + "| \u001b[39m1 \u001b[39m | \u001b[39m0.8025 \u001b[39m | \u001b[39m-0.829779\u001b[39m | \u001b[39m3 \u001b[39m |\n", + "| \u001b[39m2 \u001b[39m | \u001b[39m-2.75 \u001b[39m | \u001b[39m-4.998856\u001b[39m | \u001b[39m0 \u001b[39m |\n", + "| \u001b[39m3 \u001b[39m | \u001b[39m0.8007 \u001b[39m | \u001b[39m-0.827713\u001b[39m | \u001b[39m3 \u001b[39m |\n", + "| \u001b[39m4 \u001b[39m | \u001b[39m-0.749 \u001b[39m | \u001b[39m2.2682240\u001b[39m | \u001b[39m-5 \u001b[39m |\n", + "| \u001b[39m5 \u001b[39m | \u001b[39m0.3718 \u001b[39m | \u001b[39m-2.339072\u001b[39m | \u001b[39m4 \u001b[39m |\n", + "| \u001b[39m6 \u001b[39m | \u001b[39m0.2146 \u001b[39m | \u001b[39m4.9971028\u001b[39m | \u001b[39m5 \u001b[39m |\n", + "| \u001b[39m7 \u001b[39m | \u001b[39m0.7473 \u001b[39m | \u001b[39m4.9970839\u001b[39m | \u001b[39m2 \u001b[39m |\n", + "| \u001b[35m8 \u001b[39m | \u001b[35m0.8275 \u001b[39m | \u001b[35m4.9986856\u001b[39m | \u001b[35m-3 \u001b[39m |\n", + "| \u001b[39m9 \u001b[39m | \u001b[39m0.3464 \u001b[39m | \u001b[39m4.9987136\u001b[39m | \u001b[39m-2 \u001b[39m |\n", + "| \u001b[39m10 \u001b[39m | \u001b[39m-0.7852 \u001b[39m | \u001b[39m4.9892216\u001b[39m | \u001b[39m-5 \u001b[39m |\n", + "| \u001b[39m11 \u001b[39m | \u001b[39m-0.6627 \u001b[39m | \u001b[39m-4.999635\u001b[39m | \u001b[39m-4 \u001b[39m |\n", + "| \u001b[39m12 \u001b[39m | \u001b[39m-0.1697 \u001b[39m | \u001b[39m-4.992664\u001b[39m | \u001b[39m-3 \u001b[39m |\n", + "| \u001b[35m13 \u001b[39m | \u001b[35m1.428 \u001b[39m | \u001b[35m4.9950290\u001b[39m | \u001b[35m3 \u001b[39m |\n", + "| \u001b[39m14 \u001b[39m | \u001b[39m1.137 \u001b[39m | \u001b[39m4.9970984\u001b[39m | \u001b[39m4 \u001b[39m |\n", + "| \u001b[35m15 \u001b[39m | \u001b[35m1.641 \u001b[39m | \u001b[35m4.0889271\u001b[39m | \u001b[35m3 \u001b[39m |\n", + "=================================================\n", + "Max: 1.6407143853831352\n", + "\n", + "\n" + ] + } + ], + "source": [ + "for lbl, optimizer in zip(labels, [continuous_optimizer, discrete_optimizer]):\n", + " print(f\"==================== {lbl} ====================\\n\")\n", + " optimizer.maximize(\n", + " init_points=2,\n", + " n_iter=13\n", + " )\n", + " print(f\"Max: {optimizer.max['target']}\\n\\n\")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "x = np.linspace(c_pbounds['x'][0], c_pbounds['x'][1], 1000)\n", + "y = np.linspace(c_pbounds['y'][0], c_pbounds['y'][1], 1000)\n", + "\n", + "X, Y = np.meshgrid(x, y)\n", + "\n", + "Z = discretized_function(X, Y)\n", + "\n", + "params = [{'x': x_i, 'y': y_j} for y_j in y for x_i in x]\n", + "array_params = [continuous_optimizer._space.params_to_array(p) for p in params]\n", + "c_pred = continuous_optimizer._gp.predict(array_params).reshape(X.shape)\n", + "d_pred = discrete_optimizer._gp.predict(array_params).reshape(X.shape)\n", + "\n", + "vmin = np.min([np.min(Z), np.min(c_pred), np.min(d_pred)])\n", + "vmax = np.max([np.max(Z), np.max(c_pred), np.max(d_pred)])\n", + "\n", + "fig, axs = plt.subplots(1, 3)\n", + "\n", + "axs[0].set_title('Actual function')\n", + "axs[0].contourf(X, Y, Z, cmap=plt.cm.coolwarm, vmin=vmin, vmax=vmax)\n", + "\n", + "\n", + "axs[1].set_title(labels[0])\n", + "axs[1].contourf(X, Y, c_pred, cmap=plt.cm.coolwarm, vmin=vmin, vmax=vmax)\n", + "axs[1].scatter(continuous_optimizer._space.params[:,0], continuous_optimizer._space.params[:,1], c='k')\n", + "\n", + "axs[2].set_title(labels[1])\n", + "axs[2].contourf(X, Y, d_pred, cmap=plt.cm.coolwarm, vmin=vmin, vmax=vmax)\n", + "axs[2].scatter(discrete_optimizer._space.params[:,0], discrete_optimizer._space.params[:,1], c='k')\n", + "\n", + "def make_plot_fancy(ax: plt.Axes):\n", + " ax.set_aspect(\"equal\")\n", + " ax.set_xlabel('x (float)')\n", + " ax.set_xticks([-5.0, -2.5, 0., 2.5, 5.0])\n", + " ax.set_ylabel('y (int)')\n", + " ax.set_yticks([-4, -2, 0, 2, 4])\n", + "\n", + "for ax in axs:\n", + " make_plot_fancy(ax)\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3. Categorical variables\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can also handle categorical variables! This is done under-the-hood by constructing parameters in a one-hot-encoding representation, with a transformation in the kernel rounding to the nearest one-hot representation. If you want to use this, you can specify a collection of strings as options.\n", + "\n", + "NB: As internally, the categorical variables are within a range of `[0, 1]` and the GP used for BO is by default isotropic, you might want to ensure your other features are similarly scaled to a range of `[0, 1]` or use an anisotropic GP." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "def f1(x1, x2):\n", + " return -1*(x1 - np.sqrt(x1**2 + x2**2) * np.cos(np.sqrt(x1**2 + x2**2))**2 + 0.5 * np.sqrt(x1**2 + x2**2))\n", + "\n", + "def f2(x1, x2):\n", + " return -1*(x2 - np.sqrt(x1**2 + x2**2) * np.sin(np.sqrt(x1**2 + x2**2))**2 + 0.5 * np.sqrt(x1**2 + x2**2))\n", + "\n", + "def SPIRAL(x1, x2, k):\n", + " \"\"\"cf Ladislav-Luksan\n", + " \"\"\"\n", + " if k=='1':\n", + " return f1(10 * x1, 10 * x2)\n", + " elif k=='2':\n", + " return f2(10 * x1, 10 * x2)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "| iter | target | x1 | x2 | k |\n", + "-------------------------------------------------------------\n", + "| \u001b[39m1 \u001b[39m | \u001b[39m-2.052 \u001b[39m | \u001b[39m-0.165955\u001b[39m | \u001b[39m0.4406489\u001b[39m | \u001b[39m2 \u001b[39m |\n", + "| \u001b[35m2 \u001b[39m | \u001b[35m13.49 \u001b[39m | \u001b[35m-0.743751\u001b[39m | \u001b[35m0.9980810\u001b[39m | \u001b[35m1 \u001b[39m |\n", + "| \u001b[39m3 \u001b[39m | \u001b[39m-14.49 \u001b[39m | \u001b[39m-0.743433\u001b[39m | \u001b[39m0.9709879\u001b[39m | \u001b[39m2 \u001b[39m |\n", + "| \u001b[39m4 \u001b[39m | \u001b[39m-13.33 \u001b[39m | \u001b[39m0.9950794\u001b[39m | \u001b[39m-0.352913\u001b[39m | \u001b[39m1 \u001b[39m |\n", + "| \u001b[39m5 \u001b[39m | \u001b[39m9.674 \u001b[39m | \u001b[39m0.5436849\u001b[39m | \u001b[39m-0.574376\u001b[39m | \u001b[39m2 \u001b[39m |\n", + "| \u001b[39m6 \u001b[39m | \u001b[39m9.498 \u001b[39m | \u001b[39m-0.218693\u001b[39m | \u001b[39m-0.709177\u001b[39m | \u001b[39m2 \u001b[39m |\n", + "| \u001b[39m7 \u001b[39m | \u001b[39m11.43 \u001b[39m | \u001b[39m-0.918642\u001b[39m | \u001b[39m-0.648372\u001b[39m | \u001b[39m2 \u001b[39m |\n", + "| \u001b[39m8 \u001b[39m | \u001b[39m0.4882 \u001b[39m | \u001b[39m-0.218182\u001b[39m | \u001b[39m-0.012177\u001b[39m | \u001b[39m2 \u001b[39m |\n", + "| \u001b[39m9 \u001b[39m | \u001b[39m7.542 \u001b[39m | \u001b[39m-0.787692\u001b[39m | \u001b[39m0.3452580\u001b[39m | \u001b[39m1 \u001b[39m |\n", + "| \u001b[39m10 \u001b[39m | \u001b[39m-2.161 \u001b[39m | \u001b[39m0.1392349\u001b[39m | \u001b[39m-0.125728\u001b[39m | \u001b[39m1 \u001b[39m |\n", + "| \u001b[39m11 \u001b[39m | \u001b[39m-0.8336 \u001b[39m | \u001b[39m0.1206357\u001b[39m | \u001b[39m-0.543264\u001b[39m | \u001b[39m1 \u001b[39m |\n", + "| \u001b[39m12 \u001b[39m | \u001b[39m-8.413 \u001b[39m | \u001b[39m0.4981209\u001b[39m | \u001b[39m0.6434939\u001b[39m | \u001b[39m1 \u001b[39m |\n", + "| \u001b[39m13 \u001b[39m | \u001b[39m6.372 \u001b[39m | \u001b[39m0.0587256\u001b[39m | \u001b[39m-0.892371\u001b[39m | \u001b[39m2 \u001b[39m |\n", + "| \u001b[39m14 \u001b[39m | \u001b[39m-12.71 \u001b[39m | \u001b[39m0.7529885\u001b[39m | \u001b[39m-0.780621\u001b[39m | \u001b[39m1 \u001b[39m |\n", + "| \u001b[39m15 \u001b[39m | \u001b[39m-1.521 \u001b[39m | \u001b[39m0.4118274\u001b[39m | \u001b[39m-0.517960\u001b[39m | \u001b[39m1 \u001b[39m |\n", + "| \u001b[39m16 \u001b[39m | \u001b[39m11.88 \u001b[39m | \u001b[39m-0.755390\u001b[39m | \u001b[39m-0.533137\u001b[39m | \u001b[39m1 \u001b[39m |\n", + "| \u001b[39m17 \u001b[39m | \u001b[39m0.6373 \u001b[39m | \u001b[39m0.2249733\u001b[39m | \u001b[39m-0.053787\u001b[39m | \u001b[39m2 \u001b[39m |\n", + "| \u001b[39m18 \u001b[39m | \u001b[39m2.154 \u001b[39m | \u001b[39m0.0583506\u001b[39m | \u001b[39m0.6550869\u001b[39m | \u001b[39m1 \u001b[39m |\n", + "| \u001b[35m19 \u001b[39m | \u001b[35m13.69 \u001b[39m | \u001b[35m-0.741717\u001b[39m | \u001b[35m-0.820073\u001b[39m | \u001b[35m2 \u001b[39m |\n", + "| \u001b[39m20 \u001b[39m | \u001b[39m1.615 \u001b[39m | \u001b[39m-0.663312\u001b[39m | \u001b[39m-0.905925\u001b[39m | \u001b[39m1 \u001b[39m |\n", + "=============================================================\n" + ] + } + ], + "source": [ + "pbounds = {'x1': (-1, 1), 'x2': (-1, 1), 'k': ('1', '2')}\n", + "\n", + "categorical_optimizer = BayesianOptimization(\n", + " f=SPIRAL,\n", + " acquisition_function=acquisition.ExpectedImprovement(1e-2),\n", + " pbounds=pbounds,\n", + " verbose=2,\n", + " random_state=1,\n", + ")\n", + "discrete_optimizer.set_gp_params(alpha=1e-3)\n", + "\n", + "categorical_optimizer.maximize(\n", + " init_points=2,\n", + " n_iter=18,\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "res = categorical_optimizer._space.res()\n", + "k1 = np.array([[p['params']['x1'], p['params']['x2']] for p in res if p['params']['k']=='1'])\n", + "k2 = np.array([[p['params']['x1'], p['params']['x2']] for p in res if p['params']['k']=='2'])" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "x1 = np.linspace(pbounds['x1'][0], pbounds['x1'][1], 1000)\n", + "x2 = np.linspace(pbounds['x2'][0], pbounds['x2'][1], 1000)\n", + "\n", + "X1, X2 = np.meshgrid(x1, x2)\n", + "Z1 = SPIRAL(X1, X2, '1')\n", + "Z2 = SPIRAL(X1, X2, '2')\n", + "\n", + "fig, axs = plt.subplots(1, 2)\n", + "\n", + "vmin = np.min([np.min(Z1), np.min(Z2)])\n", + "vmax = np.max([np.max(Z1), np.max(Z2)])\n", + "\n", + "axs[0].contourf(X1, X2, Z1, vmin=vmin, vmax=vmax)\n", + "axs[0].set_aspect(\"equal\")\n", + "axs[0].scatter(k1[:,0], k1[:,1], c='k')\n", + "axs[1].contourf(X1, X2, Z2, vmin=vmin, vmax=vmax)\n", + "axs[1].scatter(k2[:,0], k2[:,1], c='k')\n", + "axs[1].set_aspect(\"equal\")\n", + "axs[0].set_title('k=1')\n", + "axs[1].set_title('k=2')\n", + "fig.tight_layout()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4. Use in ML" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A typical usecase for integer and categorical parameters is optimizing the hyperparameters of a machine learning model. Below you can find an example where the hyperparameters of an SVM are optimized." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "| iter | target | kernel | log10_C |\n", + "-------------------------------------------------\n", + "| \u001b[39m1 \u001b[39m | \u001b[39m-0.2361 \u001b[39m | \u001b[39mpoly2 \u001b[39m | \u001b[39m0.9943696\u001b[39m |\n", + "| \u001b[39m2 \u001b[39m | \u001b[39m-0.2864 \u001b[39m | \u001b[39mrbf \u001b[39m | \u001b[39m-0.999771\u001b[39m |\n", + "| \u001b[39m3 \u001b[39m | \u001b[39m-0.2625 \u001b[39m | \u001b[39mpoly3 \u001b[39m | \u001b[39m0.7449728\u001b[39m |\n", + "| \u001b[35m4 \u001b[39m | \u001b[35m-0.2361 \u001b[39m | \u001b[35mpoly2 \u001b[39m | \u001b[35m0.9944598\u001b[39m |\n", + "| \u001b[39m5 \u001b[39m | \u001b[39m-0.298 \u001b[39m | \u001b[39mpoly3 \u001b[39m | \u001b[39m-0.999625\u001b[39m |\n", + "| \u001b[35m6 \u001b[39m | \u001b[35m-0.2361 \u001b[39m | \u001b[35mpoly2 \u001b[39m | \u001b[35m0.9945010\u001b[39m |\n", + "| \u001b[35m7 \u001b[39m | \u001b[35m-0.2152 \u001b[39m | \u001b[35mrbf \u001b[39m | \u001b[35m0.9928960\u001b[39m |\n", + "| \u001b[39m8 \u001b[39m | \u001b[39m-0.2153 \u001b[39m | \u001b[39mrbf \u001b[39m | \u001b[39m0.9917667\u001b[39m |\n", + "| \u001b[39m9 \u001b[39m | \u001b[39m-0.2362 \u001b[39m | \u001b[39mpoly2 \u001b[39m | \u001b[39m0.9897298\u001b[39m |\n", + "| \u001b[39m10 \u001b[39m | \u001b[39m-0.2362 \u001b[39m | \u001b[39mpoly2 \u001b[39m | \u001b[39m0.9874217\u001b[39m |\n", + "=================================================\n" + ] + } + ], + "source": [ + "from sklearn.datasets import load_breast_cancer\n", + "from sklearn.svm import SVC\n", + "from sklearn.metrics import log_loss\n", + "from sklearn.model_selection import train_test_split\n", + "from bayes_opt import BayesianOptimization\n", + "\n", + "data = load_breast_cancer()\n", + "X_train, y_train = data['data'], data['target']\n", + "X_train, X_val, y_train, y_val = train_test_split(X_train, y_train, test_size=0.2, random_state=1)\n", + "kernels = ['rbf', 'poly']\n", + "\n", + "def f_target(kernel, log10_C):\n", + " if kernel == 'poly2':\n", + " kernel = 'poly'\n", + " degree = 2\n", + " elif kernel == 'poly3':\n", + " kernel = 'poly'\n", + " degree = 3\n", + " elif kernel == 'rbf':\n", + " degree = 3 # not used, equal to default\n", + "\n", + " C = 10**log10_C\n", + "\n", + " model = SVC(C=C, kernel=kernel, degree=degree, probability=True, random_state=1)\n", + " model.fit(X_train, y_train)\n", + "\n", + " # Package looks for maximum, so we return -1 * log_loss\n", + " loss = -1 * log_loss(y_val, model.predict_proba(X_val))\n", + " return loss\n", + "\n", + "\n", + "params_svm ={\n", + " 'kernel': ['rbf', 'poly2', 'poly3'],\n", + " 'log10_C':(-1, +1),\n", + "}\n", + "\n", + "optimizer = BayesianOptimization(\n", + " f_target,\n", + " params_svm,\n", + " random_state=1,\n", + " verbose=2\n", + ")\n", + "\n", + "kernel = Matern(nu=2.5, length_scale=np.ones(optimizer.space.dim))\n", + "discrete_optimizer.set_gp_params(kernel=kernel)\n", + "optimizer.maximize(init_points=2, n_iter=8)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5. Defining your own Parameter\n", + "\n", + "Maybe you want to optimize over another form of parameters, which does not align with `float`, `int` or categorical. For this purpose, you can create your own, custom parameter. A simple example is a parameter that is discrete, but still admits a distance representation (like an integer) while not being uniformly spaced.\n", + "\n", + "However, you can go further even and encode constraints and even symmetries in your parameter. Let's consider the problem of finding a triangle which maximizes an area given its sides $a, b, c$ with a constraint that the perimeter is fixed, i.e. $a + b + c=s$.\n", + "\n", + "We will create a parameter that encodes such a triangle, and via it's kernel transform ensures that the sides sum to the required length $s$. As you might expect, the solution to this problem is an equilateral triangle, i.e. $a=b=c=s/3$.\n", + "\n", + "To define the parameter, we need to subclass `BayesParameter` and define a few important functions/properties.\n", + "\n", + "- `is_continuous` is a property which denotes whether a parameter is continuous. When optimizing the acquisition function, non-continuous parameters will not be optimized using gradient-based methods, but only via random sampling.\n", + "- `random_sample` is a function that samples randomly from the space of the parameter.\n", + "- `to_float` transforms the canonical representation of a parameter into float values for the target space to store. There is a one-to-one correspondence between valid float representations produced by this function and canonical representations of the parameter. This function is most important when working with parameters that use a non-numeric canonical representation, such as categorical parameters.\n", + "- `to_param` performs the inverse of `to_float`: Given a float-based representation, it creates a canonical representation. This function should perform binning whenever appropriate, e.g. in the case of the `IntParameter`, this function would round any float values supplied to it.\n", + "- `kernel_transform` is the most important function of the Parameter and defines how to represent a value in the kernel space. In contrast to `to_float`, this function expects both the input, as well as the output to be float-representations of the value.\n", + "- `to_string` produces a stringified version of the parameter, which allows users to define custom pretty-print rules for ththe ScreenLogger use.\n", + "- `dim` is a property which defines the dimensionality of the parameter. In most cases, this will be 1, but e.g. for categorical parameters it is equivalent to the cardinality of the category space. " + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "from bayes_opt.logger import ScreenLogger\n", + "from bayes_opt.parameter import BayesParameter\n", + "from bayes_opt.event import Events\n", + "from bayes_opt.util import ensure_rng\n", + "\n", + "\n", + "class FixedPerimeterTriangleParameter(BayesParameter):\n", + " def __init__(self, name: str, bounds, perimeter) -> None:\n", + " super().__init__(name, bounds)\n", + " self.perimeter = perimeter\n", + "\n", + " @property\n", + " def is_continuous(self):\n", + " return True\n", + " \n", + " def random_sample(self, n_samples: int, random_state):\n", + " random_state = ensure_rng(random_state)\n", + " samples = []\n", + " while len(samples) < n_samples:\n", + " samples_ = random_state.dirichlet(np.ones(3), n_samples)\n", + " samples_ = samples_ * self.perimeter # scale samples by perimeter\n", + "\n", + " samples_ = samples_[np.all((self.bounds[:, 0] <= samples_) & (samples_ <= self.bounds[:, 1]), axis=-1)]\n", + " samples.extend(np.atleast_2d(samples_))\n", + " samples = np.array(samples[:n_samples])\n", + " return samples\n", + " \n", + " def to_float(self, value):\n", + " return value\n", + " \n", + " def to_param(self, value):\n", + " return value * self.perimeter / sum(value)\n", + "\n", + " def kernel_transform(self, value):\n", + " return value * self.perimeter / np.sum(value, axis=-1, keepdims=True)\n", + "\n", + " def to_string(self, value, str_len: int) -> str:\n", + " len_each = (str_len - 2) // 3\n", + " str_ = '|'.join([f\"{float(np.round(value[i], 4))}\"[:len_each] for i in range(3)])\n", + " return str_.ljust(str_len)\n", + "\n", + " @property\n", + " def dim(self):\n", + " return 3 # as we have three float values, each representing the length of one side.\n", + "\n", + "def area_of_triangle(sides):\n", + " a, b, c = sides\n", + " s = np.sum(sides, axis=-1) # perimeter\n", + " A = np.sqrt(s * (s-a) * (s-b) * (s-c))\n", + " return A\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "| iter | target | sides |\n", + "-------------------------------------------------------\n", + "| \u001b[39m1 \u001b[39m | \u001b[39m0.4572 \u001b[39m | \u001b[39m0.29|0.70|0.00 \u001b[39m |\n", + "| \u001b[35m2 \u001b[39m | \u001b[35m0.5096 \u001b[39m | \u001b[35m0.58|0.25|0.15 \u001b[39m |\n", + "| \u001b[39m3 \u001b[39m | \u001b[39m0.5081 \u001b[39m | \u001b[39m0.58|0.25|0.15 \u001b[39m |\n", + "| \u001b[35m4 \u001b[39m | \u001b[35m0.5386 \u001b[39m | \u001b[35m0.44|0.28|0.26 \u001b[39m |\n", + "| \u001b[39m5 \u001b[39m | \u001b[39m0.5279 \u001b[39m | \u001b[39m0.38|0.14|0.47 \u001b[39m |\n", + "| \u001b[39m6 \u001b[39m | \u001b[39m0.5328 \u001b[39m | \u001b[39m0.18|0.36|0.45 \u001b[39m |\n", + "| \u001b[39m7 \u001b[39m | \u001b[39m0.4366 \u001b[39m | \u001b[39m0.02|0.22|0.74 \u001b[39m |\n", + "| \u001b[39m8 \u001b[39m | \u001b[39m0.4868 \u001b[39m | \u001b[39m0.00|0.61|0.37 \u001b[39m |\n", + "| \u001b[39m9 \u001b[39m | \u001b[39m0.4977 \u001b[39m | \u001b[39m0.56|0.01|0.42 \u001b[39m |\n", + "| \u001b[35m10 \u001b[39m | \u001b[35m0.5418 \u001b[39m | \u001b[35m0.29|0.40|0.30 \u001b[39m |\n", + "| \u001b[39m11 \u001b[39m | \u001b[39m0.3361 \u001b[39m | \u001b[39m0.06|0.87|0.06 \u001b[39m |\n", + "| \u001b[39m12 \u001b[39m | \u001b[39m0.06468 \u001b[39m | \u001b[39m0.99|0.00|0.00 \u001b[39m |\n", + "| \u001b[39m13 \u001b[39m | \u001b[39m0.01589 \u001b[39m | \u001b[39m0.0|0.00|0.99 \u001b[39m |\n", + "| \u001b[39m14 \u001b[39m | \u001b[39m0.4999 \u001b[39m | \u001b[39m0.21|0.16|0.61 \u001b[39m |\n", + "| \u001b[39m15 \u001b[39m | \u001b[39m0.499 \u001b[39m | \u001b[39m0.53|0.46|0.00 \u001b[39m |\n", + "| \u001b[39m16 \u001b[39m | \u001b[39m0.4937 \u001b[39m | \u001b[39m0.00|0.41|0.58 \u001b[39m |\n", + "| \u001b[39m17 \u001b[39m | \u001b[39m0.5233 \u001b[39m | \u001b[39m0.33|0.51|0.14 \u001b[39m |\n", + "| \u001b[39m18 \u001b[39m | \u001b[39m0.5204 \u001b[39m | \u001b[39m0.17|0.54|0.28 \u001b[39m |\n", + "| \u001b[39m19 \u001b[39m | \u001b[39m0.5235 \u001b[39m | \u001b[39m0.51|0.15|0.32 \u001b[39m |\n", + "| \u001b[39m20 \u001b[39m | \u001b[39m0.5412 \u001b[39m | \u001b[39m0.31|0.27|0.41 \u001b[39m |\n", + "| \u001b[39m21 \u001b[39m | \u001b[39m0.4946 \u001b[39m | \u001b[39m0.41|0.00|0.57 \u001b[39m |\n", + "| \u001b[39m22 \u001b[39m | \u001b[39m0.5355 \u001b[39m | \u001b[39m0.41|0.39|0.19 \u001b[39m |\n", + "| \u001b[35m23 \u001b[39m | \u001b[35m0.5442 \u001b[39m | \u001b[35m0.35|0.32|0.32 \u001b[39m |\n", + "| \u001b[39m24 \u001b[39m | \u001b[39m0.5192 \u001b[39m | \u001b[39m0.16|0.28|0.54 \u001b[39m |\n", + "| \u001b[39m25 \u001b[39m | \u001b[39m0.5401 \u001b[39m | \u001b[39m0.39|0.23|0.36 \u001b[39m |\n", + "=======================================================\n" + ] + } + ], + "source": [ + "param = FixedPerimeterTriangleParameter(\n", + " name='sides',\n", + " bounds=np.array([[0., 1.], [0., 1.], [0., 1.]]),\n", + " perimeter=1.\n", + ")\n", + "\n", + "pbounds = {'sides': param}\n", + "optimizer = BayesianOptimization(\n", + " area_of_triangle,\n", + " pbounds,\n", + " random_state=1,\n", + ")\n", + "\n", + "# Increase the cell size to accommodate the three float values\n", + "logger = ScreenLogger(verbose=2, is_constrained=False)\n", + "logger._default_cell_size = 15\n", + "\n", + "for e in [Events.OPTIMIZATION_START, Events.OPTIMIZATION_STEP, Events.OPTIMIZATION_END]:\n", + " optimizer.subscribe(e, logger)\n", + "\n", + "optimizer.maximize(init_points=2, n_iter=23)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This seems to work decently well, but we can improve it significantly if we consider the symmetries inherent in the problem: This problem is permutation invariant, i.e. we do not care which side specifically is denoted as $a$, $b$ or $c$. Instead, we can, without loss of generality, decide that the shortest side will always be denoted as $a$, and the longest always as $c$. If we enhance our kernel transform with this symmetry, the performance improves significantly. This can be easily done by sub-classing the previously created triangle parameter." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "| iter | target | sides |\n", + "-------------------------------------------------------\n", + "| \u001b[39m1 \u001b[39m | \u001b[39m0.4572 \u001b[39m | \u001b[39m0.00|0.29|0.70 \u001b[39m |\n", + "| \u001b[35m2 \u001b[39m | \u001b[35m0.5096 \u001b[39m | \u001b[35m0.15|0.25|0.58 \u001b[39m |\n", + "| \u001b[39m3 \u001b[39m | \u001b[39m0.498 \u001b[39m | \u001b[39m0.06|0.33|0.60 \u001b[39m |\n", + "| \u001b[35m4 \u001b[39m | \u001b[35m0.5097 \u001b[39m | \u001b[35m0.13|0.27|0.58 \u001b[39m |\n", + "| \u001b[35m5 \u001b[39m | \u001b[35m0.5358 \u001b[39m | \u001b[35m0.19|0.36|0.43 \u001b[39m |\n", + "| \u001b[35m6 \u001b[39m | \u001b[35m0.5443 \u001b[39m | \u001b[35m0.33|0.33|0.33 \u001b[39m |\n", + "| \u001b[39m7 \u001b[39m | \u001b[39m0.5405 \u001b[39m | \u001b[39m0.28|0.28|0.42 \u001b[39m |\n", + "| \u001b[39m8 \u001b[39m | \u001b[39m0.5034 \u001b[39m | \u001b[39m0.01|0.49|0.49 \u001b[39m |\n", + "| \u001b[39m9 \u001b[39m | \u001b[39m0.4977 \u001b[39m | \u001b[39m0.01|0.42|0.56 \u001b[39m |\n", + "| \u001b[39m10 \u001b[39m | \u001b[39m0.5427 \u001b[39m | \u001b[39m0.27|0.36|0.36 \u001b[39m |\n", + "=======================================================\n" + ] + } + ], + "source": [ + "class SortingFixedPerimeterTriangleParameter(FixedPerimeterTriangleParameter):\n", + " def __init__(self, name: str, bounds, perimeter) -> None:\n", + " super().__init__(name, bounds, perimeter)\n", + "\n", + " def to_param(self, value):\n", + " value = np.sort(value, axis=-1)\n", + " return super().to_param(value)\n", + "\n", + " def kernel_transform(self, value):\n", + " value = np.sort(value, axis=-1)\n", + " return super().kernel_transform(value)\n", + "\n", + "param = SortingFixedPerimeterTriangleParameter(\n", + " name='sides',\n", + " bounds=np.array([[0., 1.], [0., 1.], [0., 1.]]),\n", + " perimeter=1.\n", + ")\n", + "\n", + "pbounds = {'sides': param}\n", + "optimizer = BayesianOptimization(\n", + " area_of_triangle,\n", + " pbounds,\n", + " random_state=1,\n", + ")\n", + "\n", + "logger = ScreenLogger(verbose=2, is_constrained=False)\n", + "logger._default_cell_size = 15\n", + "\n", + "for e in [Events.OPTIMIZATION_START, Events.OPTIMIZATION_STEP, Events.OPTIMIZATION_END]:\n", + " optimizer.subscribe(e, logger)\n", + "\n", + "optimizer.maximize(init_points=2, n_iter=8)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "bayesian-optimization-tb9vsVm6-py3.9", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.6" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/master/_sources/reference/parameter.rst.txt b/master/_sources/reference/parameter.rst.txt new file mode 100644 index 00000000..91b8f2e9 --- /dev/null +++ b/master/_sources/reference/parameter.rst.txt @@ -0,0 +1,5 @@ +:py:mod:`bayes_opt.parameter` +-------------------------------- + +.. automodule:: bayes_opt.parameter + :members: diff --git a/master/acquisition_functions.html b/master/acquisition_functions.html index 997614cf..d7f1ccca 100644 --- a/master/acquisition_functions.html +++ b/master/acquisition_functions.html @@ -321,6 +321,21 @@ +
  • + + Parameter Types + +
  • + + + + + + + + + +
  • Sequential Domain Reduction @@ -500,6 +515,21 @@ +
  • + + bayes_opt.parameter + +
  • + + + + + + + + + +
  • bayes_opt.exception @@ -698,8 +728,12 @@

    Acquisition functionsmean and std? In that case, we can intervene at a deeper level, and overwrite the ._get_acq function. The built-in version of ._get_acq is a higher-order function which returns a function accepting an array-like x and performing the following: 1. Evaluate the GP mean \(\mu\) and std \(\sigma\) at points x. 2. If applicapable, evaluate the constraint fulfilment probability \(p_c\) at x. 3. Return --1 * base_acq(mean, std) or -1 * base_acq(mean, std) * p_c

    +

    What if our acquisition function does not depend solely on mean and std? In that case, we can intervene at a deeper level, and overwrite the ._get_acq function. The built-in version of ._get_acq is a higher-order function which returns a function accepting an array-like x and performing the following:

    +
      +
    1. Evaluate the GP mean \(\mu\) and std \(\sigma\) at points x.

    2. +
    3. If applicapable, evaluate the constraint fulfilment probability \(p_c\) at x.

    4. +
    5. Return -1 * base_acq(mean, std) or -1 * base_acq(mean, std) * p_c

    6. +

    An example of such an acquisition function is Thompson Sampling. If you consider a Gaussian Process as a prior over functions, Thompson Sampling works by sampling a function from this prior and then selecting the argmax as next point of interest. This is a somewhat noisy version of the greedy acquisition, which will encourage some exploration.

    While we usually find the argmax of the acquisition function through a combination of random sampling and gradient-based optimization, we will skip the gradient-based optimization here, as it is quite expensive and would require us to fix the multivariate normal. We can do this by additionally overwriting .suggest, specifically by changing the default argument of n_l_bfgs_b to 0.

    diff --git a/master/advanced-tour.html b/master/advanced-tour.html index 060b2aad..e679801f 100644 --- a/master/advanced-tour.html +++ b/master/advanced-tour.html @@ -350,37 +350,30 @@

  • - - 2. Dealing with discrete parameters + + 2. Tuning the underlying Gaussian Process -
  • - -
  • - - 3. Tuning the underlying Gaussian Process - - -
  • + +
  • + + Mcalculate_bounds + + + +
  • @@ -675,6 +710,26 @@ +
  • + +
  • + + Pcontinuous_dimensions + + + +
  • @@ -715,6 +770,46 @@ +
  • + +
  • + + Mkernel_transform + + + +
  • @@ -735,6 +830,80 @@ +
  • + +
  • + + Mmake_masks + + + + +
  • + +
  • + + Mmake_params + + + +
  • @@ -755,6 +924,26 @@ +
  • + +
  • + + Pmasks + + + +
  • @@ -802,6 +991,13 @@ +
  • + +
  • + + Pparams_config + +
  • @@ -906,6 +1102,33 @@ +
  • + +
  • + + Mcalculate_bounds + + + +
  • @@ -1310,6 +1568,26 @@ +
  • + +
  • + + Pcontinuous_dimensions + + + +
  • @@ -1350,6 +1628,46 @@ +
  • + +
  • + + Mkernel_transform + + + +
  • @@ -1370,6 +1688,80 @@ +
  • + +
  • + + Mmake_masks + + + + +
  • + +
  • + + Mmake_params + + + +
  • @@ -1390,6 +1782,26 @@ +
  • + +
  • + + Pmasks + + + +
  • @@ -1437,6 +1849,13 @@ +
  • + +
  • + + Pparams_config + +
  • @@ -1541,6 +1960,33 @@