From 6cef99940e28eec8244d0637c29b58f95bea2c44 Mon Sep 17 00:00:00 2001 From: Elizabeth Santorella Date: Sun, 11 Aug 2024 12:58:01 -0700 Subject: [PATCH] Speed up Warped GP tutorial by only running one replication and not comparing against other methods (#2462) Summary: Pull Request resolved: https://github.com/pytorch/botorch/pull/2462 Context: This tutorial has been taking too long to run. Also, a tutorial doesn't need to serve both as a demonstration tha the method works better than other methods (in a statistically significant way) and as a demonstration of how to use it. This PR: * Only ones one replication, rather than 3. (Putting a CI on 3 data points is a little silly anyway.) * Removes the comparision methods, Sobol and qNEI with a non-warped GP. * Uses qLogNEI instead of qNEI * Use SingleTaskGP instead of deprecated FixedNoiseGP * No longer manually specifies outcome transform (building on #2458) * Makes copy edits Differential Revision: D61054473 --- tutorials/bo_with_warped_gp.ipynb | 264 +++++++++--------------------- 1 file changed, 77 insertions(+), 187 deletions(-) diff --git a/tutorials/bo_with_warped_gp.ipynb b/tutorials/bo_with_warped_gp.ipynb index 75c4cc83fa..9d2bd2c971 100644 --- a/tutorials/bo_with_warped_gp.ipynb +++ b/tutorials/bo_with_warped_gp.ipynb @@ -6,9 +6,9 @@ "source": [ "## BO with Warped Gaussian Processes\n", "\n", - "In this tutorial, we illustrate how to use learned input warping functions for robust bayesian optimization when the outcome may be non-stationary functions. When the lenglescales are non-stationarity in the raw input space, learning a warping function that maps raw inputs to a warped space where the lengthscales are stationary can be useful because then standard stationary kernels can be used for to effectively model the function.\n", + "In this tutorial, we illustrate how to use learned input warping functions for robust Bayesian Optimization when the outcome may be non-stationary functions. When the lengthscales are non-stationarity in the raw input space, learning a warping function that maps raw inputs to a warped space where the lengthscales are stationary can be useful, because then standard stationary kernels can be used to effectively model the function.\n", "\n", - "In general, we recommend for a relatively simple setup (like this one) to use [Ax](https://ax.dev), since this will simplify your setup (including the amount of code you need to write) considerably. See the [Using BoTorch with Ax](./custom_botorch_model_in_ax) tutorial. To use input warping with `MODULAR_BOTORCH`, we can pass the `warp_tf`, constructed as below, by adding `input_transform=warp_tf` argument to the `Surrogate(...)` call. \n", + "In general, for a relatively simple setup (like this one), we recommend using [Ax](https://ax.dev), since this will simplify your setup (including the amount of code you need to write) considerably. See the [Using BoTorch with Ax](./custom_botorch_model_in_ax) tutorial. To use input warping with `MODULAR_BOTORCH`, we can pass the `warp_tf`, constructed as below, by adding `input_transform=warp_tf` argument to the `Surrogate(...)` call. \n", "\n", "We consider use a Kumaraswamy CDF as the class of input warping function and learn the concentration parameters ($a>0$ and $b>0$). Kumaraswamy CDFs are quite flexible and map inputs in [0, 1] to outputs in [0, 1]. This work follows the Beta CDF input warping proposed by Snoek et al., but replaces the Beta distribution Kumaraswamy distribution, which has a *differentiable* and closed-form CDF. \n", " \n", @@ -16,14 +16,14 @@ " \n", "This enables maximum likelihood (or maximum a posteriori) estimation of the CDF hyperparameters using gradient methods to maximize the likelihood (or posterior probability) jointly with the GP hyperparameters. (Snoek et al. use a fully Bayesian treatment of the CDF parameters). Each input dimension is transformed using a separate warping function.\n", "\n", - "We use the Noisy Expected Improvement (qNEI) acquisition function to optimize a synthetic Hartmann6 test function. The standard problem is\n", + "We use the Log Noisy Expected Improvement (qLogNEI) acquisition function to optimize a synthetic Hartmann6 test function. The standard problem is\n", "\n", "$$f(x) = -\\sum_{i=1}^4 \\alpha_i \\exp \\left( -\\sum_{j=1}^6 A_{ij} (x_j - P_{ij})^2 \\right)$$\n", "\n", "over $x \\in [0,1]^6$ (parameter values can be found in `botorch/test_functions/hartmann6.py`). For this demonstration,\n", "We first warp each input dimension through a different inverse Kumaraswamy CDF.\n", "\n", - "Since botorch assumes a maximization problem, we will attempt to maximize $-f(x)$ to achieve $\\max_{x} -f(x) = 3.32237$.\n", + "Since BoTorch assumes a maximization problem, we will attempt to maximize $-f(x)$ to achieve $\\max_{x} -f(x) = 3.32237$.\n", "\n", "[1] [J. Snoek, K. Swersky, R. S. Zemel, R. P. Adams. Input Warping for Bayesian Optimization of Non-Stationary Functions. Proceedings of the 31st International Conference on Machine Learning, PMLR 32(2):1674-1682, 2014.](http://proceedings.mlr.press/v32/snoek14.pdf)" ] @@ -126,7 +126,7 @@ "\n", "The models are initialized with 14 points in $[0,1]^6$ drawn from a scrambled sobol sequence.\n", "\n", - "We add observe the objectives with additive Gaussian noise with a standard deviation of 0.05." + "We observe the objectives with additive Gaussian noise with a standard deviation of 0.05." ] }, { @@ -135,7 +135,7 @@ "metadata": {}, "outputs": [], "source": [ - "from botorch.models import FixedNoiseGP\n", + "from botorch.models import SingleTaskGP\n", "from gpytorch.mlls.sum_marginal_log_likelihood import ExactMarginalLogLikelihood\n", "from botorch.utils.sampling import draw_sobol_samples\n", "\n", @@ -145,16 +145,15 @@ "bounds = torch.tensor([[0.0] * 6, [1.0] * 6], device=device, dtype=dtype)\n", "\n", "\n", - "def generate_initial_data(n=14):\n", - " # generate training data\n", - " train_x = draw_sobol_samples(\n", - " bounds=bounds, n=n, q=1, seed=torch.randint(0, 10000, (1,)).item()\n", - " ).squeeze(1)\n", - " exact_obj = obj(train_x).unsqueeze(-1) # add output dimension\n", + "n = 14\n", + "# generate initial training data\n", + "train_x = draw_sobol_samples(\n", + " bounds=bounds, n=n, q=1, seed=torch.randint(0, 10000, (1,)).item()\n", + ").squeeze(1)\n", + "exact_obj = obj(train_x).unsqueeze(-1) # add output dimension\n", "\n", - " best_observed_value = exact_obj.max().item()\n", - " train_obj = exact_obj + NOISE_SE * torch.randn_like(exact_obj)\n", - " return train_x, train_obj, best_observed_value" + "best_observed_value = exact_obj.max().item()\n", + "train_obj = exact_obj + NOISE_SE * torch.randn_like(exact_obj)" ] }, { @@ -171,28 +170,24 @@ "metadata": {}, "outputs": [], "source": [ - "from botorch.utils.transforms import standardize\n", "from botorch.models.transforms.input import Warp\n", "from gpytorch.priors.torch_priors import LogNormalPrior\n", "\n", "\n", - "def initialize_model(train_x, train_obj, use_input_warping):\n", - " if use_input_warping:\n", - " # initialize input_warping transformation\n", - " warp_tf = Warp(\n", - " indices=list(range(train_x.shape[-1])),\n", - " # use a prior with median at 1.\n", - " # when a=1 and b=1, the Kumaraswamy CDF is the identity function\n", - " concentration1_prior=LogNormalPrior(0.0, 0.75**0.5),\n", - " concentration0_prior=LogNormalPrior(0.0, 0.75**0.5),\n", - " )\n", - " else:\n", - " warp_tf = None\n", + "def initialize_model(train_x, train_obj):\n", + " # initialize input_warping transformation\n", + " warp_tf = Warp(\n", + " indices=list(range(train_x.shape[-1])),\n", + " # use a prior with median at 1.\n", + " # when a=1 and b=1, the Kumaraswamy CDF is the identity function\n", + " concentration1_prior=LogNormalPrior(0.0, 0.75**0.5),\n", + " concentration0_prior=LogNormalPrior(0.0, 0.75**0.5),\n", + " )\n", " # define the model for objective\n", - " model = FixedNoiseGP(\n", - " train_x,\n", - " standardize(train_obj),\n", - " train_yvar.expand_as(train_obj),\n", + " model = SingleTaskGP(\n", + " train_X=train_x,\n", + " train_Y=train_obj,\n", + " train_Yvar=train_yvar.expand_as(train_obj),\n", " input_transform=warp_tf,\n", " ).to(train_x)\n", " mll = ExactMarginalLogLikelihood(model.likelihood, model)\n", @@ -235,17 +230,20 @@ " new_x = candidates.detach()\n", " exact_obj = obj(new_x).unsqueeze(-1) # add output dimension\n", " train_obj = exact_obj + NOISE_SE * torch.randn_like(exact_obj)\n", - " return new_x, train_obj\n", - "\n", + " return new_x, train_obj\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Perform Bayesian Optimization\n", + "The Bayesian optimization loop iterates the following steps:\n", + "1. given a surrogate model, choose a candidate point $x$\n", + "2. observe $f(x)$\n", + "3. update the surrogate model. \n", "\n", - "def update_random_observations(best_random):\n", - " \"\"\"Simulates a quasi-random policy by taking a the current list of best values observed randomly,\n", - " drawing a new random point, observing its value, and updating the list.\n", - " \"\"\"\n", - " rand_x = draw_sobol_samples(bounds=bounds, n=1, q=1).squeeze(1)\n", - " next_random_best = obj(rand_x).max().item()\n", - " best_random.append(max(best_random[-1], next_random_best))\n", - " return best_random" + "We do `N_BATCH=50` rounds of optimization." ] }, { @@ -257,137 +255,48 @@ "name": "stdout", "output_type": "stream", "text": [ - "\n", - "Trial 1 of 3 ..................................................\n", - "Trial 2 of 3 ..................................................\n", - "Trial 3 of 3 .................................................." + ".................................................." ] } ], "source": [ "from botorch import fit_gpytorch_mll\n", - "from botorch.acquisition.monte_carlo import qNoisyExpectedImprovement\n", + "from botorch.acquisition.logei import qLogNoisyExpectedImprovement\n", "from botorch.exceptions import BadInitialCandidatesWarning\n", "\n", - "import time\n", "import warnings\n", "\n", - "\n", "warnings.filterwarnings(\"ignore\", category=BadInitialCandidatesWarning)\n", "warnings.filterwarnings(\"ignore\", category=RuntimeWarning)\n", "\n", - "\n", - "N_TRIALS = 3 if not SMOKE_TEST else 2\n", "N_BATCH = 50 if not SMOKE_TEST else 5\n", "\n", - "verbose = False\n", - "\n", - "best_observed_all_ei, best_observed_all_warp, best_random_all = [], [], []\n", - "\n", "torch.manual_seed(0)\n", "\n", + "best_observed = [best_observed_value]\n", + "mll, model = initialize_model(train_x, train_obj)\n", "\n", - "# average over multiple trials\n", - "for trial in range(1, N_TRIALS + 1):\n", + "# run N_BATCH rounds of BayesOpt after the initial random batch\n", + "for iteration in range(1, N_BATCH + 1):\n", "\n", - " print(f\"\\nTrial {trial:>2} of {N_TRIALS} \", end=\"\")\n", - " best_observed_ei, best_observed_warp, best_random = [], [], []\n", + " # fit the models\n", + " fit_gpytorch_mll(mll)\n", + " ei = qLogNoisyExpectedImprovement(model=model, X_baseline=train_x)\n", "\n", - " # call helper functions to generate initial training data and initialize model\n", - " train_x_ei, train_obj_ei, best_observed_value_ei = generate_initial_data(n=14)\n", - " mll_ei, model_ei = initialize_model(\n", - " train_x_ei, train_obj_ei, use_input_warping=False\n", - " )\n", + " # optimize and get new observation\n", + " new_x, new_obj = optimize_acqf_and_get_observation(ei)\n", "\n", - " train_x_warp, train_obj_warp, = (\n", - " train_x_ei,\n", - " train_obj_ei,\n", - " )\n", - " best_observed_value_warp = best_observed_value_ei\n", - " # use input warping\n", - " mll_warp, model_warp = initialize_model(\n", - " train_x_warp, train_obj_warp, use_input_warping=True\n", - " )\n", + " # update training points\n", + " train_x = torch.cat([train_x, new_x])\n", + " train_obj = torch.cat([train_obj, new_obj])\n", "\n", - " best_observed_ei.append(best_observed_value_ei)\n", - " best_observed_warp.append(best_observed_value_warp)\n", - " best_random.append(best_observed_value_ei)\n", - "\n", - " # run N_BATCH rounds of BayesOpt after the initial random batch\n", - " for iteration in range(1, N_BATCH + 1):\n", - "\n", - " t0 = time.monotonic()\n", - "\n", - " # fit the models\n", - " fit_gpytorch_mll(mll_ei)\n", - " fit_gpytorch_mll(mll_warp)\n", - "\n", - " ei = qNoisyExpectedImprovement(\n", - " model=model_ei,\n", - " X_baseline=train_x_ei,\n", - " )\n", - "\n", - " ei_warp = qNoisyExpectedImprovement(\n", - " model=model_warp,\n", - " X_baseline=train_x_warp,\n", - " )\n", - "\n", - " # optimize and get new observation\n", - " new_x_ei, new_obj_ei = optimize_acqf_and_get_observation(ei)\n", - " new_x_warp, new_obj_warp = optimize_acqf_and_get_observation(ei_warp)\n", - "\n", - " # update training points\n", - " train_x_ei = torch.cat([train_x_ei, new_x_ei])\n", - " train_obj_ei = torch.cat([train_obj_ei, new_obj_ei])\n", - "\n", - " train_x_warp = torch.cat([train_x_warp, new_x_warp])\n", - " train_obj_warp = torch.cat([train_obj_warp, new_obj_warp])\n", - "\n", - " # update progress\n", - " best_random = update_random_observations(best_random)\n", - " best_value_ei = obj(train_x_ei).max().item()\n", - " best_value_warp = obj(train_x_warp).max().item()\n", - " best_observed_ei.append(best_value_ei)\n", - " best_observed_warp.append(best_value_warp)\n", - "\n", - " mll_ei, model_ei = initialize_model(\n", - " train_x_ei, train_obj_ei, use_input_warping=False\n", - " )\n", - " mll_warp, model_warp = initialize_model(\n", - " train_x_warp, train_obj_warp, use_input_warping=True\n", - " )\n", - "\n", - " t1 = time.monotonic()\n", - "\n", - " if verbose:\n", - " print(\n", - " f\"\\nBatch {iteration:>2}: best_value (random, ei, ei_warp) = \"\n", - " f\"({max(best_random):>4.2f}, {best_value_ei:>4.2f}, {best_value_warp:>4.2f}), \"\n", - " f\"time = {t1-t0:>4.2f}.\",\n", - " end=\"\",\n", - " )\n", - " else:\n", - " print(\".\", end=\"\")\n", - "\n", - " best_observed_all_ei.append(best_observed_ei)\n", - " best_observed_all_warp.append(best_observed_warp)\n", - " best_random_all.append(best_random)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Perform Bayesian Optimization\n", - "The Bayesian optimization \"loop\" simply iterates the following steps:\n", - "1. given a surrogate model, choose a candidate point\n", - "2. observe $f(x)$ for each $x$ in the batch \n", - "3. update the surrogate model. \n", + " # update progress\n", + " best_value = obj(train_x).max().item()\n", + " best_observed.append(best_value)\n", "\n", + " mll, model = initialize_model(train_x, train_obj)\n", "\n", - "Just for illustration purposes, we run three trials each of which do `N_BATCH=50` rounds of optimization.\n", - "\n", - "*Note*: Running this may take a little while." + " print(\".\", end=\"\")" ] }, { @@ -395,7 +304,7 @@ "metadata": {}, "source": [ "#### Plot the results\n", - "The plot below shows the log regret at each step of the optimization for each of the algorithms. The confidence intervals represent the variance at that step in the optimization across the trial runs. In order to get a better estimate of the average performance early on, one would have to run a much larger number of trials `N_TRIALS` (we avoid this here to limit the runtime of this tutorial). " + "The plot below shows the log regret at each step of the optimization for each of the algorithms." ] }, { @@ -409,15 +318,15 @@ "" ] }, - "execution_count": 8, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -433,49 +342,30 @@ "%matplotlib inline\n", "\n", "\n", - "def ci(y):\n", - " return 1.96 * y.std(axis=0) / np.sqrt(N_TRIALS)\n", - "\n", - "\n", "GLOBAL_MAXIMUM = neg_hartmann6.optimal_value\n", "\n", - "\n", "iters = np.arange(N_BATCH + 1)\n", - "y_ei = np.log10(GLOBAL_MAXIMUM - np.asarray(best_observed_all_ei))\n", - "y_ei_warp = np.log10(GLOBAL_MAXIMUM - np.asarray(best_observed_all_warp))\n", - "y_rnd = np.log10(GLOBAL_MAXIMUM - np.asarray(best_random_all))\n", + "y_ei = np.log10(GLOBAL_MAXIMUM - np.asarray(best_observed))\n", "\n", "fig, ax = plt.subplots(1, 1, figsize=(8, 6))\n", - "ax.errorbar(\n", - " iters,\n", - " y_rnd.mean(axis=0),\n", - " yerr=ci(y_rnd),\n", - " label=\"Sobol\",\n", - " linewidth=1.5,\n", - " capsize=3,\n", - " alpha=0.6,\n", - ")\n", - "ax.errorbar(\n", - " iters,\n", - " y_ei.mean(axis=0),\n", - " yerr=ci(y_ei),\n", - " label=\"NEI\",\n", - " linewidth=1.5,\n", - " capsize=3,\n", - " alpha=0.6,\n", - ")\n", - "ax.errorbar(\n", + "\n", + "ax.plot(\n", " iters,\n", - " y_ei_warp.mean(axis=0),\n", - " yerr=ci(y_ei_warp),\n", - " label=\"NEI + Input Warping\",\n", + " y_ei,\n", " linewidth=1.5,\n", - " capsize=3,\n", " alpha=0.6,\n", ")\n", - "ax.set(xlabel=\"number of observations (beyond initial points)\", ylabel=\"Log10 Regret\")\n", - "ax.legend(loc=\"lower left\")" + "\n", + "ax.set_xlabel(\"number of observations (beyond initial points)\")\n", + "ax.set_ylabel(\"Log10 Regret\")" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": {