tutorials/constrained_multi_objective_bo.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "originalKey": "20bce0d3-6ea0-4db3-bc3b-2569027a0e3b",
    "showInput": false
   },
   "source": [
    "## Constrained, Parallel, Multi-Objective BO in BoTorch with qNEHVI, and qParEGO\n",
    "\n",
    "In this tutorial, we illustrate how to implement a constrained multi-objective (MO) Bayesian Optimization (BO) closed loop in BoTorch.\n",
    "\n",
    "In general, we recommend using [Ax](https://ax.dev) for a simple BO setup like this one, since this will simplify your setup (including the amount of code you need to write) considerably. See [here](https://ax.dev/tutorials/multiobjective_optimization.html) for an Ax tutorial on MOBO. If desired, you can use a custom BoTorch model in Ax, following the [Using BoTorch with Ax](./custom_botorch_model_in_ax) tutorial. Given a `MultiObjective`, Ax will default to the $q$NEHVI acquisiton function. If desired, this can also be customized by adding `\"botorch_acqf_class\": <desired_botorch_acquisition_function_class>,` to the `model_kwargs`.\n",
    "\n",
    "We use the parallel ParEGO ($q$ParEGO) [1] and parallel Noisy Expected Hypervolume Improvement ($q$NEHVI) [2]  acquisition functions to optimize a synthetic C2-DTLZ2 test function with $M=2$ objectives, $V=1$ constraint, and $d=4$ parameters. The two objectives are\n",
    "$$f_1(\\mathbf x) = (1+ g(\\mathbf x_M))\\cos\\big(\\frac{\\pi}{2}x_1\\big)$$\n",
    "$$f_2(\\mathbf x) = (1+ g(\\mathbf x_M))\\sin\\big(\\frac{\\pi}{2}x_1\\big)$$\n",
    "where $g(\\mathbf x) = \\sum_{x_i \\in \\mathbf x_M} (x_i - 0.5)^2, \\mathbf x \\in [0,1]^d,$ and $\\mathbf x_M$ represents the last $d - M +1$ elements of $\\mathbf x$. Additionally, the C2-DTLZ2 problem uses the following constraint:\n",
    "\n",
    "$$c(\\mathbf x) = - \\min \\bigg[\\min_{i=1}^M\\bigg((f_i(\\mathbf x) -1 )^2 + \\sum_{j=1, j=i}^M (f_j^2 - r^2) \\bigg), \\bigg(\\sum_{i=1}^M \\big((f_i(\\mathbf x) - \\frac{1}{\\sqrt{M}})^2 - r^2\\big)\\bigg)\\bigg]\\geq 0$$\n",
    "\n",
    "where $\\mathbf x \\in [0,1]^d$ and $r=0.2$. \n",
    "\n",
    "The goal here is to *minimize* both objectives. Since BoTorch assumes maximization, we maximize the negative of each objective. Since there typically is no single best solution in multi-objective optimization problems, we seek to find the pareto frontier, the set of optimal trade-offs where improving one metric means deteriorating another.\n",
    "\n",
    "[1] [S. Daulton, M. Balandat, and E. Bakshy. Differentiable Expected Hypervolume Improvement for Parallel Multi-Objective Bayesian Optimization. Advances in Neural Information Processing Systems 33, 2020.](https://arxiv.org/abs/2006.05078)\n",
    "\n",
    "[2] [S. Daulton, M. Balandat, and E. Bakshy. Parallel Bayesian Optimization of Multiple Noisy Objectives with Expected Hypervolume Improvement. Advances in Neural Information Processing Systems 34, 2021.](https://arxiv.org/abs/2105.08195)\n",
    "\n",
    "**For batch optimization (or in noisy settings), we strongly recommend using $q$NEHVI rather than $q$EHVI [1] because it is far more efficient than $q$EHVI and mathematically equivalent in the noiseless setting.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "originalKey": "00d9f0ef-fab6-463e-a54d-a548581bc7f4"
   },
   "source": [
    "### Set dtype and device\n",
    "Note: $q$EHVI aggressively exploits parallel hardware and is much faster when run on a GPU. See [1] for details."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "executionStartTime": 1648147919827,
    "executionStopTime": 1648147920547,
    "originalKey": "1b948968-e9e7-45cb-9bc6-64c79db6f9f8",
    "requestMsgId": "f27224aa-b567-4a6d-b6b3-74f2ecbfe319"
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import torch\n",
    "\n",
    "\n",
    "tkwargs = {\n",
    "    \"dtype\": torch.double,\n",
    "    \"device\": torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\"),\n",
    "}\n",
    "SMOKE_TEST = os.environ.get(\"SMOKE_TEST\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "originalKey": "89f8b99f-5cb2-45c9-9df6-7e1d18d4f8c6"
   },
   "source": [
    "### Problem setup\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "executionStartTime": 1648147920597,
    "executionStopTime": 1648147921274,
    "originalKey": "7459e7b1-b499-4d80-a0c9-44e0985be876",
    "requestMsgId": "4227f250-60b5-4c97-b04c-3cfe7a1c410a"
   },
   "outputs": [],
   "source": [
    "from botorch.test_functions.multi_objective import C2DTLZ2\n",
    "\n",
    "\n",
    "d = 4\n",
    "M = 2\n",
    "problem = C2DTLZ2(dim=d, num_objectives=M, negate=True).to(**tkwargs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "code_folding": [],
    "hidden_ranges": [],
    "originalKey": "2de9fbab-9d15-4410-8371-d3b1f730e3d7",
    "showInput": false
   },
   "source": [
    "#### Model initialization\n",
    "\n",
    "We use a multi-output `SingleTaskGP` to model the two objectives with a homoskedastic Gaussian likelihood with an inferred noise level.\n",
    "\n",
    "The models are initialized with $2(d+1)=10$ points drawn randomly from $[0,1]^{4}$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "code_folding": [],
    "executionStartTime": 1648147921281,
    "executionStopTime": 1648147921311,
    "hidden_ranges": [],
    "originalKey": "89484dd2-c509-4692-9c81-51fcee30d48b",
    "requestMsgId": "192b8d87-b2e3-4223-b193-6399b8643391"
   },
   "outputs": [],
   "source": [
    "from botorch.models.gp_regression import SingleTaskGP\n",
    "from botorch.models.model_list_gp_regression import ModelListGP\n",
    "from botorch.models.transforms.outcome import Standardize\n",
    "from botorch.utils.sampling import draw_sobol_samples\n",
    "from botorch.utils.transforms import normalize, unnormalize\n",
    "from gpytorch.mlls.sum_marginal_log_likelihood import SumMarginalLogLikelihood\n",
    "\n",
    "\n",
    "def generate_initial_data(n):\n",
    "    # generate training data\n",
    "    train_x = draw_sobol_samples(bounds=problem.bounds, n=n, q=1).squeeze(1)\n",
    "    train_obj = problem(train_x)\n",
    "    # negative values imply feasibility in botorch\n",
    "    train_con = -problem.evaluate_slack(train_x)\n",
    "    return train_x, train_obj, train_con\n",
    "\n",
    "\n",
    "def initialize_model(train_x, train_obj, train_con):\n",
    "    # define models for objective and constraint\n",
    "    train_x = normalize(train_x, problem.bounds)\n",
    "    train_y = torch.cat([train_obj, train_con], dim=-1)\n",
    "    models = []\n",
    "    for i in range(train_y.shape[-1]):\n",
    "        models.append(SingleTaskGP(train_x, train_y[..., i : i + 1], outcome_transform=Standardize(m=1)))\n",
    "    model = ModelListGP(*models)\n",
    "    mll = SumMarginalLogLikelihood(model.likelihood, model)\n",
    "    return mll, model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "code_folding": [],
    "hidden_ranges": [],
    "originalKey": "a0f6fa02-0843-4c45-8a19-8654226c1edc",
    "showInput": false
   },
   "source": [
    "#### Define a helper function that performs the essential BO step for $q$NEHVI\n",
    "The helper function below initializes the $q$NEHVI acquisition function, optimizes it, and returns the batch $\\{x_1, x_2, \\ldots x_q\\}$ along with the observed function values. \n",
    "\n",
    "For this example, we'll use a small batch of $q=2$. Passing the keyword argument `sequential=True` to the function `optimize_acqf`specifies that candidates should be optimized in a sequential greedy fashion (see [1] for details why this is important). A simple initialization heuristic is used to select the 10 restart initial locations from a set of 512 random points. Multi-start optimization of the acquisition function is performed using LBFGS-B with exact gradients computed via auto-differentiation.\n",
    "\n",
    "**Reference Point**\n",
    "\n",
    "$q$NEHVI requires specifying a reference point, which is the lower bound on the objectives used for computing hypervolume. In this tutorial, we assume the reference point is known. In practice the reference point can be set 1) using domain knowledge to be slightly worse than the lower bound of objective values, where the lower bound is the minimum acceptable value of interest for each objective, or 2) using a dynamic reference point selection strategy.\n",
    "\n",
    "**Integrating over function values at in-sample designs**\n",
    "\n",
    "$q$NEHVI integrates over the unknown function values at the previously evaluated designs (see [2] for details). Therefore, we need to provide the previously evaluated designs (`train_x`, *normalized* to be within $[0,1]^d$) to the acquisition function.\n",
    "\n",
    "**Pruning baseline designs**\n",
    "To speed up integration over the function values at the previously evaluated designs, we prune the set of previously evaluated designs (by setting `prune_baseline=True`) to only include those which have positive probability of being on the current in-sample Pareto frontier."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "code_folding": [],
    "executionStartTime": 1648147921346,
    "executionStopTime": 1648147921445,
    "hidden_ranges": [],
    "originalKey": "34d8d62f-8f7a-4d21-8b96-6b8dded4b1fd",
    "requestMsgId": "65dcfbb2-f1e9-40a1-9807-8cdc1cc3fdc8"
   },
   "outputs": [],
   "source": [
    "from botorch.acquisition.multi_objective.monte_carlo import qNoisyExpectedHypervolumeImprovement\n",
    "from botorch.acquisition.multi_objective.objective import IdentityMCMultiOutputObjective\n",
    "from botorch.optim.optimize import optimize_acqf, optimize_acqf_list\n",
    "from botorch.utils.multi_objective.scalarization import get_chebyshev_scalarization\n",
    "from botorch.utils.sampling import sample_simplex\n",
    "\n",
    "\n",
    "BATCH_SIZE = 2\n",
    "NUM_RESTARTS = 10 if not SMOKE_TEST else 2\n",
    "RAW_SAMPLES = 512 if not SMOKE_TEST else 4\n",
    "\n",
    "standard_bounds = torch.zeros(2, problem.dim, **tkwargs)\n",
    "standard_bounds[1] = 1\n",
    "\n",
    "\n",
    "def optimize_qnehvi_and_get_observation(model, train_x, train_obj, train_con, sampler):\n",
    "    \"\"\"Optimizes the qNEHVI acquisition function, and returns a new candidate and observation.\"\"\"\n",
    "    train_x = normalize(train_x, problem.bounds)\n",
    "    acq_func = qNoisyExpectedHypervolumeImprovement(\n",
    "        model=model,\n",
    "        ref_point=problem.ref_point.tolist(),  # use known reference point\n",
    "        X_baseline=train_x,\n",
    "        sampler=sampler,\n",
    "        prune_baseline=True,\n",
    "        # define an objective that specifies which outcomes are the objectives\n",
    "        objective=IdentityMCMultiOutputObjective(outcomes=[0, 1]),\n",
    "        # specify that the constraint is on the last outcome\n",
    "        constraints=[lambda Z: Z[..., -1]],\n",
    "    )\n",
    "    # optimize\n",
    "    candidates, _ = optimize_acqf(\n",
    "        acq_function=acq_func,\n",
    "        bounds=standard_bounds,\n",
    "        q=BATCH_SIZE,\n",
    "        num_restarts=NUM_RESTARTS,\n",
    "        raw_samples=RAW_SAMPLES,  # used for intialization heuristic\n",
    "        options={\"batch_limit\": 5, \"maxiter\": 200},\n",
    "        sequential=True,\n",
    "    )\n",
    "    # observe new values\n",
    "    new_x = unnormalize(candidates.detach(), bounds=problem.bounds)\n",
    "    new_obj = problem(new_x)\n",
    "    # negative values imply feasibility in botorch\n",
    "    new_con = -problem.evaluate_slack(new_x)\n",
    "    return new_x, new_obj, new_con"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "originalKey": "9b4277b1-fc2a-467f-ae21-cb30d6823bd9"
   },
   "source": [
    "#### Define a helper function for creating constrained objectives for $q$ParEGO\n",
    "The helper function below initializes a ConstrainedMCObjective for $q$ParEGO. It creates the `objective` which fetches the outcomes required for the scalarized objective and applies the scalarization and the constraints, which are modeled outcomes.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "executionStartTime": 1648147921477,
    "executionStopTime": 1648147921559,
    "originalKey": "5b09ea9d-026d-4b87-a07d-a96553851061",
    "requestMsgId": "daf2cfd6-47f7-467c-a4d2-e1837a0249b5"
   },
   "outputs": [],
   "source": [
    "from botorch.acquisition.objective import ConstrainedMCObjective\n",
    "\n",
    "\n",
    "def get_constrained_mc_objective(train_obj, train_con, scalarization):\n",
    "    \"\"\"Initialize a ConstrainedMCObjective for qParEGO\"\"\"\n",
    "    n_obj = train_obj.shape[-1]\n",
    "    # assume first outcomes of the model are the objectives, the rest constraints\n",
    "    def objective(Z):\n",
    "        return scalarization(Z[..., :n_obj])\n",
    "\n",
    "    constrained_obj = ConstrainedMCObjective(\n",
    "        objective=objective,\n",
    "        constraints=[lambda Z: Z[..., -1]],  # index the constraint\n",
    "    )\n",
    "    return constrained_obj"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "originalKey": "ae9e19c2-327f-486e-bee3-11f1b71b0dfe"
   },
   "source": [
    "#### Define a helper function that performs the essential BO step for $q$ParEGO\n",
    "The helper function below similarly initializes $q$ParEGO, optimizes it, and returns the batch $\\{x_1, x_2, \\ldots x_q\\}$ along with the observed function values. \n",
    "\n",
    "$q$ParEGO uses random augmented chebyshev scalarization with the `qExpectedImprovement` acquisition function. In the parallel setting ($q>1$), each candidate is optimized in sequential greedy fashion using a different random scalarization (see [1] for details).\n",
    "\n",
    "To do this, we create a list of `qExpectedImprovement` acquisition functions, each with different random scalarization weights. The `optimize_acqf_list` method sequentially generates one candidate per acquisition function and conditions the next candidate (and acquisition function) on the previously selected pending candidates."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "code_folding": [],
    "executionStartTime": 1648147921596,
    "executionStopTime": 1648147921696,
    "hidden_ranges": [],
    "originalKey": "fe116b82-f959-406e-89c7-d5e52c6dc05e",
    "requestMsgId": "a4a23da4-64de-4948-ad92-76b57c023f62"
   },
   "outputs": [],
   "source": [
    "from botorch.acquisition.monte_carlo import qExpectedImprovement\n",
    "\n",
    "\n",
    "def optimize_qparego_and_get_observation(model, train_obj, train_con, sampler):\n",
    "    \"\"\"Samples a set of random weights for each candidate in the batch, performs sequential greedy optimization\n",
    "    of the qParEGO acquisition function, and returns a new candidate and observation.\"\"\"\n",
    "    acq_func_list = []\n",
    "    for _ in range(BATCH_SIZE):\n",
    "        # sample random weights\n",
    "        weights = sample_simplex(problem.num_objectives, **tkwargs).squeeze()\n",
    "        # construct augmented Chebyshev scalarization\n",
    "        scalarization = get_chebyshev_scalarization(weights=weights, Y=train_obj)\n",
    "        # initialize ConstrainedMCObjective\n",
    "        constrained_objective = get_constrained_mc_objective(\n",
    "            train_obj=train_obj,\n",
    "            train_con=train_con,\n",
    "            scalarization=scalarization,\n",
    "        )\n",
    "        train_y = torch.cat([train_obj, train_con], dim=-1)\n",
    "        acq_func = qExpectedImprovement(  # pyre-ignore: [28]\n",
    "            model=model,\n",
    "            objective=constrained_objective,\n",
    "            best_f=constrained_objective(train_y).max(),\n",
    "            sampler=sampler,\n",
    "        )\n",
    "        acq_func_list.append(acq_func)\n",
    "    # optimize\n",
    "    candidates, _ = optimize_acqf_list(\n",
    "        acq_function_list=acq_func_list,\n",
    "        bounds=standard_bounds,\n",
    "        num_restarts=NUM_RESTARTS,\n",
    "        raw_samples=RAW_SAMPLES,  # used for intialization heuristic\n",
    "        options={\"batch_limit\": 5, \"maxiter\": 200},\n",
    "    )\n",
    "    # observe new values\n",
    "    new_x = unnormalize(candidates.detach(), bounds=problem.bounds)\n",
    "    new_obj = problem(new_x)\n",
    "    # negative values imply feasibility in botorch\n",
    "    new_con = -problem.evaluate_slack(new_x)\n",
    "    return new_x, new_obj, new_con"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "originalKey": "d4487ba0-4fad-41dd-a2ae-e0b95094dba1",
    "showInput": false
   },
   "source": [
    "### Perform Bayesian Optimization loop with $q$EHVI and $q$ParEGO\n",
    "The Bayesian optimization \"loop\" for a batch size of $q$ simply iterates the following steps:\n",
    "1. given a surrogate model, choose a batch of points $\\{x_1, x_2, \\ldots x_q\\}$\n",
    "2. observe $f(x)$ for each $x$ in the batch \n",
    "3. update the surrogate model. \n",
    "\n",
    "\n",
    "Just for illustration purposes, we run one trial with `N_BATCH=20` rounds of optimization. The acquisition function is approximated using `MC_SAMPLES=128` samples.\n",
    "\n",
    "*Note*: Running this may take a little while."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "code_folding": [],
    "executionStartTime": 1648147921723,
    "executionStopTime": 1648148617464,
    "hidden_ranges": [],
    "originalKey": "49bd8e2e-5062-498f-8061-bec0045fb4e4",
    "requestMsgId": "4c225d99-6425-4201-ac4a-a042a351c1d3"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Batch  1: Hypervolume (random, qParEGO, qNEHVI) = (0.15, 0.19, 0.15), time = 49.48.\n",
      "\n",
      "Batch  2: Hypervolume (random, qParEGO, qNEHVI) = (0.15, 0.21, 0.16), time = 34.03.\n",
      "\n",
      "Batch  3: Hypervolume (random, qParEGO, qNEHVI) = (0.15, 0.21, 0.19), time = 33.42.\n",
      "\n",
      "Batch  4: Hypervolume (random, qParEGO, qNEHVI) = (0.15, 0.21, 0.19), time = 36.61.\n",
      "\n",
      "Batch  5: Hypervolume (random, qParEGO, qNEHVI) = (0.17, 0.23, 0.19), time = 28.77.\n",
      "\n",
      "Batch  6: Hypervolume (random, qParEGO, qNEHVI) = (0.17, 0.23, 0.24), time = 36.22.\n",
      "\n",
      "Batch  7: Hypervolume (random, qParEGO, qNEHVI) = (0.18, 0.25, 0.27), time = 28.64.\n",
      "\n",
      "Batch  8: Hypervolume (random, qParEGO, qNEHVI) = (0.18, 0.25, 0.29), time = 29.08.\n",
      "\n",
      "Batch  9: Hypervolume (random, qParEGO, qNEHVI) = (0.18, 0.25, 0.30), time = 26.04.\n",
      "\n",
      "Batch 10: Hypervolume (random, qParEGO, qNEHVI) = (0.18, 0.26, 0.31), time = 38.61.\n",
      "\n",
      "Batch 11: Hypervolume (random, qParEGO, qNEHVI) = (0.18, 0.26, 0.31), time = 38.01.\n",
      "\n",
      "Batch 12: Hypervolume (random, qParEGO, qNEHVI) = (0.22, 0.26, 0.31), time = 36.52.\n",
      "\n",
      "Batch 13: Hypervolume (random, qParEGO, qNEHVI) = (0.22, 0.26, 0.32), time = 37.15.\n",
      "\n",
      "Batch 14: Hypervolume (random, qParEGO, qNEHVI) = (0.22, 0.29, 0.32), time = 36.02.\n",
      "\n",
      "Batch 15: Hypervolume (random, qParEGO, qNEHVI) = (0.22, 0.30, 0.33), time = 33.84.\n",
      "\n",
      "Batch 16: Hypervolume (random, qParEGO, qNEHVI) = (0.22, 0.30, 0.38), time = 28.67.\n",
      "\n",
      "Batch 17: Hypervolume (random, qParEGO, qNEHVI) = (0.22, 0.33, 0.38), time = 31.00.\n",
      "\n",
      "Batch 18: Hypervolume (random, qParEGO, qNEHVI) = (0.22, 0.34, 0.38), time = 40.21.\n",
      "\n",
      "Batch 19: Hypervolume (random, qParEGO, qNEHVI) = (0.22, 0.34, 0.38), time = 28.19.\n",
      "\n",
      "Batch 20: Hypervolume (random, qParEGO, qNEHVI) = (0.22, 0.34, 0.38), time = 44.94."
     ]
    }
   ],
   "source": [
    "import time\n",
    "import warnings\n",
    "\n",
    "from botorch import fit_gpytorch_model\n",
    "from botorch.exceptions import BadInitialCandidatesWarning\n",
    "from botorch.sampling.samplers import SobolQMCNormalSampler\n",
    "from botorch.utils.multi_objective.hypervolume import Hypervolume\n",
    "from botorch.utils.multi_objective.pareto import is_non_dominated\n",
    "\n",
    "\n",
    "warnings.filterwarnings(\"ignore\", category=BadInitialCandidatesWarning)\n",
    "warnings.filterwarnings(\"ignore\", category=RuntimeWarning)\n",
    "\n",
    "N_BATCH = 20 if not SMOKE_TEST else 5\n",
    "MC_SAMPLES = 128 if not SMOKE_TEST else 16\n",
    "verbose = True\n",
    "\n",
    "hv = Hypervolume(ref_point=problem.ref_point)\n",
    "hvs_qparego, hvs_qnehvi, hvs_random = [], [], []\n",
    "\n",
    "# call helper functions to generate initial training data and initialize model\n",
    "train_x_qparego, train_obj_qparego, train_con_qparego = generate_initial_data(n=2 * (d + 1))\n",
    "mll_qparego, model_qparego = initialize_model(train_x_qparego, train_obj_qparego, train_con_qparego)\n",
    "\n",
    "train_x_qnehvi, train_obj_qnehvi, train_con_qnehvi = train_x_qparego, train_obj_qparego, train_con_qparego\n",
    "train_x_random, train_obj_random, train_con_random = train_x_qparego, train_obj_qparego, train_con_qparego\n",
    "\n",
    "mll_qnehvi, model_qnehvi = initialize_model(train_x_qnehvi, train_obj_qnehvi, train_con_qnehvi)\n",
    "\n",
    "# compute pareto front\n",
    "is_feas = (train_con_qparego <= 0).all(dim=-1)\n",
    "feas_train_obj = train_obj_qparego[is_feas]\n",
    "if feas_train_obj.shape[0] > 0:\n",
    "    pareto_mask = is_non_dominated(feas_train_obj)\n",
    "    pareto_y = feas_train_obj[pareto_mask]\n",
    "    # compute hypervolume\n",
    "    volume = hv.compute(pareto_y)\n",
    "else:\n",
    "    volume = 0.0\n",
    "\n",
    "hvs_qparego.append(volume)\n",
    "hvs_qnehvi.append(volume)\n",
    "hvs_random.append(volume)\n",
    "\n",
    "# run N_BATCH rounds of BayesOpt after the initial random batch\n",
    "for iteration in range(1, N_BATCH + 1):\n",
    "    t0 = time.time()\n",
    "\n",
    "    # fit the models\n",
    "    fit_gpytorch_model(mll_qparego)\n",
    "    fit_gpytorch_model(mll_qnehvi)\n",
    "\n",
    "    # define the qParEGO and qNEHVI acquisition modules using a QMC sampler\n",
    "    qparego_sampler = SobolQMCNormalSampler(num_samples=MC_SAMPLES)\n",
    "    qnehvi_sampler = SobolQMCNormalSampler(num_samples=MC_SAMPLES)\n",
    "\n",
    "    # optimize acquisition functions and get new observations\n",
    "    new_x_qparego, new_obj_qparego, new_con_qparego = optimize_qparego_and_get_observation(\n",
    "        model_qparego, train_obj_qparego, train_con_qparego, qparego_sampler\n",
    "    )\n",
    "    new_x_qnehvi, new_obj_qnehvi, new_con_qnehvi = optimize_qnehvi_and_get_observation(\n",
    "        model_qnehvi, train_x_qnehvi, train_obj_qnehvi, train_con_qnehvi, qnehvi_sampler\n",
    "    )\n",
    "    new_x_random, new_obj_random, new_con_random = generate_initial_data(n=BATCH_SIZE)\n",
    "\n",
    "    # update training points\n",
    "    train_x_qparego = torch.cat([train_x_qparego, new_x_qparego])\n",
    "    train_obj_qparego = torch.cat([train_obj_qparego, new_obj_qparego])\n",
    "    train_con_qparego = torch.cat([train_con_qparego, new_con_qparego])\n",
    "\n",
    "    train_x_qnehvi = torch.cat([train_x_qnehvi, new_x_qnehvi])\n",
    "    train_obj_qnehvi = torch.cat([train_obj_qnehvi, new_obj_qnehvi])\n",
    "    train_con_qnehvi = torch.cat([train_con_qnehvi, new_con_qnehvi])\n",
    "\n",
    "    train_x_random = torch.cat([train_x_random, new_x_random])\n",
    "    train_obj_random = torch.cat([train_obj_random, new_obj_random])\n",
    "    train_con_random = torch.cat([train_con_random, new_con_random])\n",
    "\n",
    "    # update progress\n",
    "    for hvs_list, train_obj, train_con in zip(\n",
    "        (hvs_random, hvs_qparego, hvs_qnehvi),\n",
    "        (train_obj_random, train_obj_qparego, train_obj_qnehvi),\n",
    "        (train_con_random, train_con_qparego, train_con_qnehvi),\n",
    "    ):\n",
    "        # compute pareto front\n",
    "        is_feas = (train_con <= 0).all(dim=-1)\n",
    "        feas_train_obj = train_obj[is_feas]\n",
    "        if feas_train_obj.shape[0] > 0:\n",
    "            pareto_mask = is_non_dominated(feas_train_obj)\n",
    "            pareto_y = feas_train_obj[pareto_mask]\n",
    "            # compute feasible hypervolume\n",
    "            volume = hv.compute(pareto_y)\n",
    "        else:\n",
    "            volume = 0.0\n",
    "        hvs_list.append(volume)\n",
    "\n",
    "    # reinitialize the models so they are ready for fitting on next iteration\n",
    "    # Note: we find improved performance from not warm starting the model hyperparameters\n",
    "    # using the hyperparameters from the previous iteration\n",
    "    mll_qparego, model_qparego = initialize_model(train_x_qparego, train_obj_qparego, train_con_qparego)\n",
    "    mll_qnehvi, model_qnehvi = initialize_model(train_x_qnehvi, train_obj_qnehvi, train_con_qnehvi)\n",
    "\n",
    "    t1 = time.time()\n",
    "\n",
    "    if verbose:\n",
    "        print(\n",
    "            f\"\\nBatch {iteration:>2}: Hypervolume (random, qParEGO, qNEHVI) = \"\n",
    "            f\"({hvs_random[-1]:>4.2f}, {hvs_qparego[-1]:>4.2f}, {hvs_qnehvi[-1]:>4.2f}), \"\n",
    "            f\"time = {t1-t0:>4.2f}.\",\n",
    "            end=\"\",\n",
    "        )\n",
    "    else:\n",
    "        print(\".\", end=\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "originalKey": "3132af99-128f-41fc-9e6c-d1eaf6083f81"
   },
   "source": [
    "#### Plot the results\n",
    "The plot below shows the log feasible hypervolume difference: the log difference between the hypervolume of the true feasible pareto front and the hypervolume of the observed (feasible) pareto front identified by each algorithm. The log feasible hypervolume difference is plotted at each step of the optimization for each of the algorithms.\n",
    "\n",
    "The plot show that $q$NEHVI vastly outperforms the $q$ParEGO and Sobol baselines."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "code_folding": [],
    "executionStartTime": 1648148617491,
    "executionStopTime": 1648148618333,
    "hidden_ranges": [],
    "originalKey": "a92268cc-117b-4dfc-bccb-1c24c95e6d36",
    "requestMsgId": "38f5ce01-264f-43bd-8bdb-edf756f7c0dc"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f45b8114d00>"
      ]
     },
     "execution_count": 8,
     "metadata": {
      "bento_obj_id": "139937417612544"
     },
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "bento_obj_id": "139937418499840",
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "from matplotlib import pyplot as plt\n",
    "\n",
    "\n",
    "%matplotlib inline\n",
    "\n",
    "\n",
    "iters = np.arange(N_BATCH + 1) * BATCH_SIZE\n",
    "log_hv_difference_qparego = np.log10(problem.max_hv - np.asarray(hvs_qparego))\n",
    "log_hv_difference_qnehvi = np.log10(problem.max_hv - np.asarray(hvs_qnehvi))\n",
    "log_hv_difference_rnd = np.log10(problem.max_hv - np.asarray(hvs_random))\n",
    "\n",
    "fig, ax = plt.subplots(1, 1, figsize=(8, 6))\n",
    "ax.plot(\n",
    "    iters,\n",
    "    log_hv_difference_rnd,\n",
    "    label=\"Sobol\",\n",
    "    linewidth=1.5,\n",
    "    color=\"gray\",\n",
    ")\n",
    "ax.plot(\n",
    "    iters,\n",
    "    log_hv_difference_qparego,\n",
    "    label=\"qParEGO\",\n",
    "    linewidth=1.5,\n",
    "    color=\"red\",\n",
    ")\n",
    "ax.plot(\n",
    "    iters,\n",
    "    log_hv_difference_qnehvi,\n",
    "    label=\"qNEHVI\",\n",
    "    linewidth=1.5,\n",
    "    color=\"blue\",\n",
    ")\n",
    "ax.set(xlabel=\"number of observations (beyond initial points)\", ylabel=\"Log Hypervolume Difference\")\n",
    "ax.legend(loc=\"lower right\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "code_folding": [],
    "collapsed": true,
    "hidden_ranges": [],
    "originalKey": "a926c260-dcc2-4ce9-9c53-7b75456c6c0c",
    "showInput": false
   },
   "source": [
    "#### Plot the observations colored by iteration\n",
    "\n",
    "To examine optimization process from another perspective, we plot the collected observations under each algorithm where the color corresponds to the BO iteration at which the point was collected. The plot on the right for $q$NEHVI shows that the $q$NEHVI quickly identifies the pareto front and most of its evaluations are very close to the pareto front. $q$ParEGO also identifies has many observations close to the pareto front, but relies on optimizing random scalarizations, which is a less principled way of optimizing the pareto front compared to $q$NEHVI, which explicitly attempts focuses on improving the pareto front. Sobol generates random points and has few points close to the pareto front"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "executionStartTime": 1648148618662,
    "executionStopTime": 1648148619362,
    "originalKey": "216d4baf-c640-4d1f-ab80-705bbc380005",
    "requestMsgId": "75cb7f30-5ed2-4a02-bf46-b5c660af6494"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Iteration')"
      ]
     },
     "execution_count": 9,
     "metadata": {
      "bento_obj_id": "139937561887792"
     },
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1224x360 with 4 Axes>"
      ]
     },
     "metadata": {
      "bento_obj_id": "139937403234240",
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib.cm import ScalarMappable\n",
    "\n",
    "\n",
    "fig, axes = plt.subplots(1, 3, figsize=(17, 5))\n",
    "algos = [\"Sobol\", \"qParEGO\", \"qNEHVI\"]\n",
    "cm = plt.cm.get_cmap('viridis')\n",
    "\n",
    "batch_number = torch.cat(\n",
    "    [torch.zeros(2*(d+1)), torch.arange(1, N_BATCH+1).repeat(BATCH_SIZE, 1).t().reshape(-1)]\n",
    ").numpy()\n",
    "\n",
    "for i, train_obj in enumerate((train_obj_random, train_obj_qparego, train_obj_qnehvi)):\n",
    "    sc = axes[i].scatter(train_obj[:, 0].cpu().numpy(), train_obj[:,1].cpu().numpy(), c=batch_number, alpha=0.8)\n",
    "    axes[i].set_title(algos[i])\n",
    "    axes[i].set_xlabel(\"Objective 1\")\n",
    "    axes[i].set_xlim(-2.5, 0)\n",
    "    axes[i].set_ylim(-2.5, 0)\n",
    "axes[0].set_ylabel(\"Objective 2\")\n",
    "norm = plt.Normalize(batch_number.min(), batch_number.max())\n",
    "sm =  ScalarMappable(norm=norm, cmap=cm)\n",
    "sm.set_array([])\n",
    "fig.subplots_adjust(right=0.9)\n",
    "cbar_ax = fig.add_axes([0.93, 0.15, 0.01, 0.7])\n",
    "cbar = fig.colorbar(sm, cax=cbar_ax)\n",
    "cbar.ax.set_title(\"Iteration\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.7.11"
  },
  "last_base_url": "https://devvm7832.prn0.facebook.com:8090/",
  "last_kernel_id": "0b84f7f4-81a8-45c6-b666-c492e27d97a6",
  "last_msg_id": "905ee962-2b33ee429b7e8d68b081da23_80",
  "last_server_session_id": "af01fe08-aee2-47a6-b113-d5ae7c3ae7b1",
  "outputWidgetContext": {}
 },
 "nbformat": 4,
 "nbformat_minor": 2
}