diff --git a/notebooks_community/clf_constrained_bo.ipynb b/notebooks_community/clf_constrained_bo.ipynb new file mode 100644 index 0000000000..cf33acd6b6 --- /dev/null +++ b/notebooks_community/clf_constrained_bo.ipynb @@ -0,0 +1,718 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# BO with Binary Black-box Constraint\n", + "* Contributors: Fanjin Wang\n", + "* Last updated: Jan 26, 2025\n", + "* BoTorch version: 0.12.1.dev91+g0df552162.d20250124\n", + "\n", + "In this notebook, we show how to implement BO under unknown constraints learned from a classification model trained together with a GP.\n", + "\n", + "To add some context, the recommendations presented by BO to assist laboratory experiments may lead to undesired experiment results, such as failures or infeasible protocols [1]. And in these cases, the underlying feasible region can only be obtained through experimentation. In such cases, these unknown constraints can be treated as an unknown variable modeled by a surrogate classification model. Note that this setting, in which we only obtain binary information about whether or not a proposed candidate is feasible or not, is different from the setting in which we observe numerical values of an outcome that is subject to some constraint.\n", + "\n", + "The present code is also inspired by the implementation in [2].\n", + "\n", + "[1]: [Wang, F., Parhizkar, M., Harker, A., & Edirisinghe, M. (2024). Constrained composite Bayesian optimization for rational synthesis of polymeric particles. ArXiv, abs/2411.10471](https://arxiv.org/abs/2411.10471).\n", + "\n", + "[2]: [Tian, Y., Zuniga, A., Zhang, X., Dürholt, J.P., Das, P., Chen, J., Matusik, W., & Konakovic-Lukovic, M. (2024). Boundary Exploration for Bayesian Optimization With Unknown Physical Constraints. ArXiv, abs/2402.07692](https://arxiv.org/abs/2402.07692).\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Set dtype and device" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import torch\n", + "\n", + "tkwargs = {\n", + " \"dtype\": torch.double,\n", + " \"device\": torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\"),\n", + "}\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Problem setup" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We begin with setting up a classical synthetic problem `Townsend` presented in [3]. The objective to be maximized is:\n", + "\n", + "$$\n", + "\\begin{align*}\n", + "y_{\\text{obj}} &= \\cos\\left((x_1 - 0.1) x_2\\right)^2 + x_1 \\sin(3 x_1 + x_2)\n", + "\\end{align*}\n", + "$$\n", + "\n", + "Subjected to the constraint $c$:\n", + "$$\n", + "c = \\left(2 \\cos(t) - 0.5 \\cos(2t) - 0.25 \\cos(3t) - 0.125 \\cos(4t)\\right)^2 + \\left(2 \\sin(t)\\right)^2 - x_1^2 - x_2^2 )\n", + "$$ \n", + "where $t = \\arctan\\left(\\frac{x_1}{x_2}\\right)$\n", + "\n", + "And the binary feasibility $y_{\\text{con}}$ is defined by:\n", + "$$\n", + "y_{\\text{con}} = \\begin{cases}\n", + "1 & c > 0\\\\\n", + "0 & \\text{otherwise}\n", + "\\end{cases}\n", + "$$\n", + "\n", + "Here, we follow a natural representation where $y_{\\text{con}}=1$ indicates a feasible condition. We will train a classification model to predict the feasibility of the point. Note that in BoTorch's implementation, **negative values** indicate feasibility, thus we need to do conversion later when feeding feasibility into the pipeline.\n", + "\n", + "Note that we essentially 'throw away' information contained in the value of $c$ by applying a binary mask to generate $y_{\\text{con}}$ - this is for illustration purposes as part of this tutorial, in many real-world applications the latent value $c$ is not directly observable and only binary information (experiment success or failure) is available.\n", + "\n", + "[3]: Townsend, A. (2014). Constrained optimization in Chebfun. https://www.chebfun.org/examples/opt/ConstrainedOptimization.html" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "class Townsend():\n", + " def __init__(self):\n", + " self.dim = 2\n", + " self.lb = torch.tensor([-2.25, 2.25], **tkwargs)\n", + " self.ub = torch.tensor([-2.5, 1.75], **tkwargs)\n", + " self.bounds = torch.stack([self.lb, self.ub]).T\n", + " self._optimal_value = 1.660\n", + " self.name = \"Townsend\"\n", + "\n", + " def __call__(self, x):\n", + " return self.objective(x)\n", + "\n", + " def is_feasible(self, x):\n", + " x1, x2 = x[..., 0], x[..., 1]\n", + " t = torch.atan2(x1, x2) \n", + " c = ((2 * torch.cos(t) - 0.5 * torch.cos(2 * t) - 0.25 * torch.cos(3 * t) - 0.125 * torch.cos(4 * t)) ** 2 + (2 * torch.sin(t)) ** 2 - x1 ** 2 - x2 ** 2)\n", + " y_con = (c > 0).float() #binarize the feasibility\n", + " return y_con\n", + " \n", + " def objective(self,x):\n", + " x1, x2 = x[..., 0], x[..., 1]\n", + " return torch.cos((x1 - 0.1) * x2) ** 2 + x1 * torch.sin(3 * x1 + x2)\n", + "\n", + "townsend = Townsend()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We plot the landscape of the Townsend function as a reference. The infeasible region is masked out." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the townsend function and constraint\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "def plot_townsend(ax):\n", + " x = np.linspace(-2.5, 2.5, 100)\n", + " y = np.linspace(-2.5, 2.5, 100)\n", + " X, Y = np.meshgrid(x, y)\n", + "\n", + " obj = townsend(torch.tensor(np.stack([X, Y], axis=-1), **tkwargs)).cpu().numpy()\n", + " con = townsend.is_feasible(torch.tensor(np.stack([X, Y], axis=-1), **tkwargs)).cpu().numpy()\n", + "\n", + " #mask out the constraint region<0\n", + " obj[con==0] = np.nan\n", + "\n", + " c = ax.contourf(X, Y, obj, levels=20,cmap='Blues')\n", + "\n", + " ax.set_xlabel(\"X1\")\n", + " ax.set_ylabel(\"X2\")\n", + " ax.set_title(\"Townsend Problem\")\n", + "\n", + " plt.colorbar(c, ax=ax, orientation='vertical')\n", + " return ax\n", + "\n", + "# Plot the townsend function and constraint\n", + "fig, ax = plt.subplots(1, 1, figsize=(5, 4))\n", + "plot_townsend(ax)\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Generate Training Data" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "from botorch.utils.sampling import draw_sobol_samples\n", + "\n", + "def generate_initial_data(n):\n", + " # generate training data within the problem bounds\n", + " train_x = draw_sobol_samples(bounds=townsend.bounds, n=n, q=1).squeeze(1)\n", + " train_obj = townsend(train_x).unsqueeze(-1)\n", + " train_con = townsend.is_feasible(train_x)\n", + " return train_x, train_obj, train_con" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Define Classification Model\n", + "We use [approximate GP](https://docs.gpytorch.ai/en/stable/examples/04_Variational_and_Approximate_GPs/Non_Gaussian_Likelihoods.html) implemented by GPyTorch as the surrogate for unknown constraint. The latent function is modelled by a GP, and the likelihood is modelled by a Bernoulli distribution. Followed by training, we extract the probability from the Bernoulli distribution as the feasibility prediction." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "import gpytorch\n", + "from gpytorch.models import ApproximateGP\n", + "from gpytorch.variational import CholeskyVariationalDistribution, VariationalStrategy\n", + "from gpytorch.kernels.scale_kernel import ScaleKernel\n", + "from botorch.models.gpytorch import GPyTorchModel\n", + "\n", + "class GP_vi(ApproximateGP, GPyTorchModel):\n", + " def __init__(self, train_x, train_y):\n", + " self.train_inputs = (train_x,)\n", + " self.train_targets = train_y\n", + "\n", + " variational_distribution = CholeskyVariationalDistribution(train_x.size(0))\n", + " variational_strategy = VariationalStrategy(\n", + " self, train_x, variational_distribution\n", + " )\n", + " super(GP_vi, self).__init__(variational_strategy)\n", + "\n", + " self.mean_module = gpytorch.means.ConstantMean()\n", + " self.covar_module = ScaleKernel(gpytorch.kernels.RBFKernel())\n", + " self.likelihood = gpytorch.likelihoods.BernoulliLikelihood()\n", + "\n", + " def forward(self, x):\n", + " mean_x = self.mean_module(x)\n", + " covar_x = self.covar_module(x)\n", + " return gpytorch.distributions.MultivariateNormal(mean_x, covar_x)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Model initialization\n", + "We initialize the model with a `SingleTaskGP` model and the custom `GP_vi` model for the feasibility modeling." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "from gpytorch.mlls import ExactMarginalLogLikelihood\n", + "from botorch.models import SingleTaskGP, ModelListGP\n", + "from botorch.fit import fit_gpytorch_mll\n", + "from botorch.models.transforms.outcome import Standardize\n", + "from botorch.utils.transforms import unnormalize, normalize\n", + "\n", + "from functools import partial\n", + "\n", + "def initialize_model(train_x, train_obj, train_con):\n", + " '''Initialize the model for the problem.'''\n", + " train_x = normalize(train_x, bounds=townsend.bounds)\n", + "\n", + " model_obj = SingleTaskGP(\n", + " train_X=train_x,\n", + " train_Y=train_obj,\n", + " outcome_transform=Standardize(m=1),\n", + " )\n", + " \n", + " mll_obj = ExactMarginalLogLikelihood(model_obj.likelihood, model_obj)\n", + " fit_gpytorch_mll(mll_obj)\n", + "\n", + " model_con = GP_vi(train_x, train_con)\n", + " mll_con = gpytorch.mlls.VariationalELBO(\n", + " model_con.likelihood, model_con, num_data=train_con.size(0)\n", + " )\n", + "\n", + " #make sure the GPyTorch model is in double precision\n", + " model_con.double()\n", + " mll_con.double()\n", + " \n", + " fit_gpytorch_mll(mll_con)\n", + " model = ModelListGP(model_obj, model_con)\n", + " \n", + " return model" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We further set up the acquisition function `qLogExpectedImprovement` and the method to optimize and get observation from Townsend function. The constraint is passed to the acquisition function as a `constraint` argument. See [here](https://botorch.org/api/acquisition.html#botorch.acquisition.monte_carlo.SampleReducingMCAcquisitionFunction) for more details. The helper functions `pass_obj` and `pass_con_unsigmoid` are used to pass the objective and constraint values to the acquisition function." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "from botorch.acquisition import qLogExpectedImprovement\n", + "from botorch.acquisition.objective import GenericMCObjective\n", + "from botorch.sampling.normal import SobolQMCNormalSampler\n", + "from botorch.optim import optimize_acqf\n", + "\n", + "BATCH_SIZE = 1\n", + "NUM_RESTARTS = 10 \n", + "RAW_SAMPLES = 512\n", + "\n", + "def optimize_acqf_and_get_observation(model, train_obj, train_con):\n", + " \"\"\"\n", + " Optimizes the acquisition function, and returns a new candidate and observation.\n", + " \"\"\"\n", + " # best_f is the best feasible objective value observed so far\n", + " best_f = np.ma.masked_array(train_obj, mask=~train_con.bool()).max().item()\n", + " \n", + " # standardize the training data\n", + " standard_bounds = torch.stack([torch.zeros(townsend.dim), torch.ones(townsend.dim)])\n", + " \n", + " acqf = qLogExpectedImprovement(\n", + " model=model,\n", + " best_f=best_f,\n", + " sampler=SobolQMCNormalSampler(sample_shape=torch.Size([1024])), objective=GenericMCObjective(pass_obj),\n", + " constraints=[partial(pass_con_unsigmoid, model_con=model.models[1])],\n", + " )\n", + "\n", + " # run the optimization function\n", + " candidates, _ = optimize_acqf(\n", + " acq_function=acqf,\n", + " bounds=standard_bounds,\n", + " q=BATCH_SIZE,\n", + " num_restarts=NUM_RESTARTS,\n", + " raw_samples=RAW_SAMPLES,\n", + " )\n", + " \n", + " # observe new values\n", + " new_x = unnormalize(candidates.detach(), townsend.bounds)\n", + " new_obj = townsend(new_x)\n", + " new_con = townsend.is_feasible(new_x)\n", + "\n", + " return new_x, new_obj, new_con, acqf\n", + "\n", + "def pass_obj(Z,X=None):\n", + " '''\n", + " directly pass the objective to the acquisition function\n", + " '''\n", + " return Z[...,0]\n", + "\n", + "def pass_con_unsigmoid(Z, model_con, X=None):\n", + " '''\n", + " pass the constraint to the acquisition function\n", + "\n", + " Note: Botorch does sigmoid transformation for the constraint by default, \n", + " therefore we need to unsigmoid our probability (0-1) to (-inf,inf)\n", + " also we need to invert the probability, where -inf means the constraint is satisfied. Finally,we add 1e-8 to avoid log(0).\n", + " '''\n", + " y_con = Z[...,1] #get the constraint\n", + "\n", + " prob = model_con.likelihood(y_con).probs #obtain the probability of y_con(when constraint satisfied)\n", + " prob_unsigmoid_neg = torch.log(1-prob+1e-8)-torch.log(prob+1e-8) #unsigmoid the probability and invert it to adapt to BoTorch's constraint API\n", + " \n", + " return prob_unsigmoid_neg\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We also define some helper functions to visualize the BO process through plotting out the acquisition function value, and the underlying constraint probability and expected improvement value before subjecting to constraints." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "def plot_helper(model, train_x,new_x, acqf,axes):\n", + "\n", + " with torch.no_grad():\n", + " x = np.linspace(-2.5, 2.5, 100)\n", + " y = np.linspace(-2.5, 2.5, 100) \n", + " X, Y = np.meshgrid(x, y)\n", + " Z = torch.tensor(np.stack([X, Y], axis=-1)).to(**tkwargs)\n", + " Z = normalize(Z, bounds=townsend.bounds)\n", + " Z = Z.reshape(-1, 2).unsqueeze(1)\n", + " # get the acquisition function value\n", + " acq_values = acqf(Z).cpu().numpy()\n", + " # get the constraint probability\n", + " model_con = model.models[1]\n", + " prob = model_con.likelihood(model_con(Z)).probs.cpu().numpy()\n", + " # get the expected improvement value\n", + " ei_values = model.models[0](Z).mean.cpu().numpy()\n", + "\n", + " # plot the townsend function\n", + " plot_townsend(axes[0])\n", + "\n", + " c_acqf = axes[1].contourf(X, Y, acq_values.reshape(100,100), levels=20,cmap='Blues')\n", + "\n", + " #plot the constraint probability and set the colorbar to 0-1\n", + " c_prob = axes[2].contourf(X, Y, prob.reshape(100,100), levels=20,cmap='RdYlGn',vmin=0,vmax=1)\n", + "\n", + " c_ei = axes[3].contourf(X, Y, ei_values.reshape(100,100), levels=20,cmap='Oranges')\n", + "\n", + " #plot the current observations\n", + " for ax in axes:\n", + " ax.scatter(train_x[:, 0].cpu(), train_x[:, 1].cpu(), color='grey', label='Observations',alpha=0.5)\n", + " ax.scatter(new_x[:, 0].cpu(), new_x[:, 1].cpu(), marker='*' ,color='red', label='New Point')\n", + " ax.set_xlabel(\"X1\")\n", + " ax.set_ylabel(\"X2\")\n", + "\n", + " axes[1].set_title(\"Acquisition Function\")\n", + " \n", + " axes[2].set_title(\"Constraint Probability\")\n", + "\n", + " axes[3].set_title(\"EI value\")\n", + " \n", + " #add colorbar\n", + " plt.colorbar(c_acqf, ax=axes[1])\n", + " plt.colorbar(c_prob, ax=axes[2])\n", + " plt.colorbar(c_ei, ax=axes[3])\n", + " plt.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Perform BO loop\n", + "We initialize the BO loop with 10 random points from SOBOL sequence. We then perform 50 iterations of BO. The acquisition function value, the underlying constraint probability, and the expected improvement value are plotted at every 10 iterations." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 0: \n", + " log Regret CEI = -0.91 \n", + " log Regret Sobol = -0.91\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 1: \n", + " log Regret CEI = -0.91 \n", + " log Regret Sobol = -0.91\n", + "Iteration 2: \n", + " log Regret CEI = -0.91 \n", + " log Regret Sobol = -1.17\n", + "Iteration 3: \n", + " log Regret CEI = -0.91 \n", + " log Regret Sobol = -1.17\n", + "Iteration 4: \n", + " log Regret CEI = -0.91 \n", + " log Regret Sobol = -1.17\n", + "Iteration 5: \n", + " log Regret CEI = -0.91 \n", + " log Regret Sobol = -1.17\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 6: \n", + " log Regret CEI = -1.86 \n", + " log Regret Sobol = -1.17\n", + "Iteration 7: \n", + " log Regret CEI = -3.15 \n", + " log Regret Sobol = -1.17\n", + "Iteration 8: \n", + " log Regret CEI = -3.15 \n", + " log Regret Sobol = -1.17\n", + "Iteration 9: \n", + " log Regret CEI = -3.15 \n", + " log Regret Sobol = -1.17\n", + "Iteration 10: \n", + " log Regret CEI = -3.15 \n", + " log Regret Sobol = -1.17\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 11: \n", + " log Regret CEI = -3.15 \n", + " log Regret Sobol = -1.17\n", + "Iteration 12: \n", + " log Regret CEI = -3.15 \n", + " log Regret Sobol = -1.17\n", + "Iteration 13: \n", + " log Regret CEI = -3.15 \n", + " log Regret Sobol = -1.17\n", + "Iteration 14: \n", + " log Regret CEI = -3.15 \n", + " log Regret Sobol = -1.17\n", + "Iteration 15: \n", + " log Regret CEI = -4.64 \n", + " log Regret Sobol = -1.17\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 16: \n", + " log Regret CEI = -4.64 \n", + " log Regret Sobol = -1.17\n", + "Iteration 17: \n", + " log Regret CEI = -4.64 \n", + " log Regret Sobol = -1.17\n", + "Iteration 18: \n", + " log Regret CEI = -4.64 \n", + " log Regret Sobol = -1.17\n", + "Iteration 19: \n", + " log Regret CEI = -4.64 \n", + " log Regret Sobol = -2.02\n", + "Iteration 20: \n", + " log Regret CEI = -4.64 \n", + " log Regret Sobol = -2.02\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 21: \n", + " log Regret CEI = -4.64 \n", + " log Regret Sobol = -2.02\n", + "Iteration 22: \n", + " log Regret CEI = -7.49 \n", + " log Regret Sobol = -2.02\n", + "Iteration 23: \n", + " log Regret CEI = -7.49 \n", + " log Regret Sobol = -2.02\n", + "Iteration 24: \n", + " log Regret CEI = -7.49 \n", + " log Regret Sobol = -2.02\n", + "Iteration 25: \n", + " log Regret CEI = -7.49 \n", + " log Regret Sobol = -2.02\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "INIT_DATA_SIZE = 2*(townsend.dim + 1)\n", + "N_BATCH = 25\n", + "VERBOSE = True\n", + "\n", + "# generate initial training data\n", + "train_x, train_obj, train_con = generate_initial_data(n=INIT_DATA_SIZE)\n", + "\n", + "# add random baseline\n", + "train_x_rand, train_obj_rand, train_con_rand = (train_x, train_obj, train_con)\n", + "\n", + "# initialize the model\n", + "model = initialize_model(train_x, train_obj, train_con)\n", + "\n", + "# store a list of regrets at each step\n", + "optimal = torch.tensor(townsend._optimal_value, **tkwargs)\n", + "\n", + "regrets_model = []\n", + "regrets_rand = []\n", + "\n", + "for _ in range(N_BATCH+1): \n", + " # append the regrets\n", + " best_f_model = np.ma.masked_array(train_obj, mask=~train_con.bool()).max().item() \n", + " regrets_model.append(optimal-best_f_model)\n", + "\n", + " best_f_rand = np.ma.masked_array(train_obj_rand, mask=~train_con_rand.bool()).max().item()\n", + " regrets_rand.append(optimal-best_f_rand)\n", + "\n", + " # optimize the acquisition function and get new observation\n", + " new_x, new_obj, new_con,acqf = optimize_acqf_and_get_observation(model, train_obj, train_con)\n", + "\n", + " # print the current model and random regret and iteration, plot the acquisition function every 5 iterations\n", + " if VERBOSE:\n", + " print(f\"Iteration {_}: \\n log Regret CEI = {torch.log(regrets_model[-1]):.2f} \\n log Regret Sobol = {torch.log(regrets_rand[-1]):.2f}\")\n", + " \n", + " if _ % 5 == 0:\n", + " fig, axes = plt.subplots(1, 4, figsize=(15, 3))\n", + " plot_helper(model, train_x, new_x, acqf,axes)\n", + " plt.show()\n", + " #clear the axes\n", + " plt.pause(0.1)\n", + " plt.close(fig)\n", + "\n", + " # include the new observation in the training data\n", + " train_x = torch.cat([train_x, new_x])\n", + " train_obj = torch.cat([train_obj, new_obj.unsqueeze(-1)])\n", + " train_con = torch.cat([train_con, new_con])\n", + " # update the model\n", + " model = initialize_model(train_x, train_obj, train_con)\n", + "\n", + " # execute the random baseline\n", + " new_x_rand, new_obj_rand, new_con_rand = generate_initial_data(n=BATCH_SIZE)\n", + " train_x_rand = torch.cat([train_x_rand, new_x_rand])\n", + " train_obj_rand = torch.cat([train_obj_rand, new_obj_rand])\n", + " train_con_rand = torch.cat([train_con_rand, new_con_rand]) " + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#plot the regret\n", + "plt.plot(regrets_model, label='CEI')\n", + "plt.plot(regrets_rand, label='Sobol')\n", + "plt.yscale(\"log\")\n", + "plt.xlabel(\"Number of Iterations\")\n", + "plt.ylabel(\"Regret\")\n", + "plt.title(\"Regret of CEI and Sobol\")\n", + "plt.legend()\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "botorch", + "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.10.16" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}