tutorials/bope.ipynb

{
  "metadata": {
    "dataExplorerConfig": {},
    "kernelspec": {
      "display_name": "python3",
      "language": "python",
      "name": "python3",
      "metadata": {}
    },
    "last_server_session_id": "8ae9172e-d1b6-4b08-bee0-0395a9549d6b",
    "last_kernel_id": "74594d10-ddf5-4f99-8f35-7f9d57b7f715",
    "last_base_url": "",
    "last_msg_id": "9cfa893c-a2930f2b65ac1d68ae75388a_107",
    "captumWidgetMessage": {},
    "outputWidgetContext": {}
  },
  "nbformat": 4,
  "nbformat_minor": 2,
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "originalKey": "6778d143-3808-45b3-bcbe-da7c7475280a",
        "showInput": false,
        "customInput": null,
        "code_folding": [],
        "hidden_ranges": []
      },
      "source": [
        "# Bayesian Optimization with Preference Exploration\n",
        "\n",
        "In this tutorial, we demonstrate how to implement a closed loop of Bayesian optimization with preference exploration, or BOPE [1].\n",
        "BOPE is designed for Bayesian optimization of expensive-to-evaluate experiments,\n",
        "where the response surface function of the experiment $f_\\mathrm{true}$ generates vector-valued outcomes over which a decision-maker (DM) has preferences.\n",
        "These preferences are encoded by a utility function $g_\\mathrm{true}$ that is not known in closed form but can be estimated by\n",
        "asking the DM to express preferences over pairs of outcome vectors.\n",
        "\n",
        "In other words, with BOPE, we wish to solve the following optimization problem:\n",
        "\n",
        "$$\n",
        " \\max_{x \\in \\mathcal{X}} g_\\mathrm{true}(f_\\mathrm{true}(x))\n",
        "$$\n",
        "\n",
        "Unlike many other Bayesian optimization setups where multiple consecutive batches of experiments are performed,\n",
        "in BOPE, we alternate between two stages: *preference exploration* and *experimentation*.\n",
        "\n",
        "In the preference exploration stage, we use an acquisition function (i.e., a preference exploratoin strategy, or PE strategy)\n",
        "to adaptively generate pairs of hypothetical outcome and ask the decision-maker’s preference within each pair.\n",
        "In the experimentation stage, we use a batch version of noisy expected improvement that integrates over our uncertainty in the\n",
        "utility function called $\\text{qNEIUU}$ to generate experimental candidates for evaluation.\n",
        "\n",
        "\n",
        "[1] [Z.J. Lin, R. Astudillo, P.I. Frazier, and E. Bakshy, Preference Exploration for Efficient Bayesian Optimization with Multiple Outcomes. AISTATS, 2022.](https://arxiv.org/abs/2203.11382)"
      ],
      "attachments": {}
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": false,
        "originalKey": "a9f7ce4d-a9aa-493a-aa8f-3edbd77b7daa",
        "code_folding": [],
        "hidden_ranges": [],
        "requestMsgId": "a9f7ce4d-a9aa-493a-aa8f-3edbd77b7daa",
        "executionStartTime": 1665422428594,
        "executionStopTime": 1665422432951,
        "customOutput": null
      },
      "source": [
        "import os\n",
        "import warnings\n",
        "\n",
        "import matplotlib as mpl\n",
        "import matplotlib.pylab as plt\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "import torch\n",
        "from botorch.acquisition import GenericMCObjective, LearnedObjective\n",
        "from botorch.acquisition.monte_carlo import qNoisyExpectedImprovement, qSimpleRegret\n",
        "from botorch.acquisition.preference import AnalyticExpectedUtilityOfBestOption\n",
        "from botorch.fit import fit_gpytorch_mll\n",
        "from botorch.models.deterministic import FixedSingleSampleModel\n",
        "from botorch.models.gp_regression import SingleTaskGP\n",
        "from botorch.models.pairwise_gp import PairwiseGP, PairwiseLaplaceMarginalLogLikelihood\n",
        "from botorch.optim.optimize import optimize_acqf\n",
        "from botorch.sampling.samplers import SobolQMCNormalSampler\n",
        "from botorch.test_functions.multi_objective import DTLZ2\n",
        "from botorch.utils.sampling import draw_sobol_samples\n",
        "from gpytorch.mlls.exact_marginal_log_likelihood import ExactMarginalLogLikelihood\n",
        "\n",
        "\n",
        "%matplotlib inline\n",
        "\n",
        "# Suppress potential optimization warnings for cleaner notebook\n",
        "warnings.filterwarnings(\"ignore\")\n",
        "\n",
        "# Set plotting colors\n",
        "colors = [\"tab:blue\", \"tab:orange\", \"tab:green\", \"tab:red\"]\n",
        "mpl.rcParams[\"axes.prop_cycle\"] = mpl.cycler(color=colors)\n",
        "\n",
        "SMOKE_TEST = os.environ.get(\"SMOKE_TEST\")"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "I1010 102029.845 font_manager.py:1349] generated new fontManager\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "I1010 102029.977 _utils_internal.py:179] NCCL_DEBUG env var is set to None\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "I1010 102029.978 _utils_internal.py:197] NCCL_DEBUG is forced to WARN from None\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "originalKey": "7729000d-0661-4689-8f2b-f99e32c52b70",
        "showInput": false,
        "customInput": null,
        "code_folding": [],
        "hidden_ranges": []
      },
      "source": [
        "## Problem Setup\n",
        "\n",
        "In this tutorial, we use the DTLZ2 problem with d=5 inputs and k=4 outcomes as our test problem $f_\\mathrm{true}$.\n",
        "\n",
        "For the utility function $g_\\mathrm{true}$, we use the negative L1 distance from a Pareto-optimal point the outcome space:\n",
        "$Y^* = f(X^*)$ where $X^* = [0.5, 0.5, 0.5, 0.5, 0.5]$. "
      ],
      "attachments": {}
    },
    {
      "cell_type": "code",
      "metadata": {
        "originalKey": "06c206ad-b080-4d58-b225-75cd8d24fe33",
        "showInput": true,
        "customInput": null,
        "collapsed": false,
        "requestMsgId": "06c206ad-b080-4d58-b225-75cd8d24fe33",
        "executionStartTime": 1665422433054,
        "executionStopTime": 1665422433071,
        "code_folding": [],
        "hidden_ranges": [],
        "customOutput": null
      },
      "source": [
        "def neg_l1_dist(Y):\n",
        "    \"\"\"Negative L1 distance from a Pareto optimal points\"\"\"\n",
        "    if len(Y.shape) == 1:\n",
        "        Y = Y.unsqueeze(0)\n",
        "    dist = torch.cdist(Y, torch.full(Y.shape[-1:], fill_value=0.5).unsqueeze(0), p=1).squeeze(-1)\n",
        "    return -dist\n",
        "\n",
        "\n",
        "if SMOKE_TEST:\n",
        "    NUM_RESTARTS = 2\n",
        "    NUM_PREF_SAMPLES = 1\n",
        "    NUM_OUTCOME_SAMPLES = 4\n",
        "    RAW_SAMPLES = 8\n",
        "    BATCH_LIMIT = 2\n",
        "else:\n",
        "    NUM_RESTARTS = 8\n",
        "    NUM_PREF_SAMPLES = 1\n",
        "    NUM_OUTCOME_SAMPLES = 64\n",
        "    RAW_SAMPLES = 64\n",
        "    BATCH_LIMIT = 4\n",
        "\n",
        "X_dim = 5\n",
        "Y_dim = 4\n",
        "problem = DTLZ2(dim=X_dim, num_objectives=Y_dim)\n",
        "util_func = neg_l1_dist"
      ],
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "originalKey": "bf98ebb8-36d5-423a-9eea-5ff99c44975b",
        "showInput": false,
        "customInput": null,
        "code_folding": [],
        "hidden_ranges": []
      },
      "source": [
        "Here we define a collection of helper functions for BOPE:"
      ],
      "attachments": {}
    },
    {
      "cell_type": "code",
      "metadata": {
        "originalKey": "b95bac6c-3f6f-4c1b-a3d4-370855f88625",
        "showInput": true,
        "customInput": null,
        "collapsed": false,
        "requestMsgId": "b95bac6c-3f6f-4c1b-a3d4-370855f88625",
        "executionStopTime": 1665422433207,
        "executionStartTime": 1665422433202,
        "code_folding": [],
        "hidden_ranges": [],
        "customOutput": null
      },
      "source": [
        "def fit_outcome_model(X, Y, X_bounds):\n",
        "    \"\"\"Fit the outcome model f\"\"\"\n",
        "    outcome_model = SingleTaskGP(train_X=X, train_Y=Y)\n",
        "    mll = ExactMarginalLogLikelihood(outcome_model.likelihood, outcome_model)\n",
        "    fit_gpytorch_mll(mll)\n",
        "    return outcome_model\n",
        "\n",
        "\n",
        "def fit_pref_model(Y, comps):\n",
        "    \"\"\"Fit the preference model g\"\"\"\n",
        "    model = PairwiseGP(Y, comps, jitter=1e-4)\n",
        "    mll = PairwiseLaplaceMarginalLogLikelihood(model.likelihood, model)\n",
        "    fit_gpytorch_mll(mll)\n",
        "    return model\n",
        "\n",
        "\n",
        "def gen_rand_X(problem, n):\n",
        "    \"\"\"Generate n quasi-random Sobol points in the design space\"\"\"\n",
        "    return draw_sobol_samples(bounds=problem.bounds, n=1, q=n).squeeze(0)\n",
        "\n",
        "\n",
        "def generate_random_exp_data(problem, n):\n",
        "    \"\"\"Generate n observations of (X, Y) Pairs\"\"\"\n",
        "    X = gen_rand_X(problem, n)\n",
        "    Y = problem(X)\n",
        "    return X, Y\n",
        "\n",
        "\n",
        "def generate_random_pref_data(outcome_model, n):\n",
        "    \"\"\"Generate n pairwise comparison data between 2n points\"\"\"\n",
        "    X = gen_rand_X(problem, 2 * n)\n",
        "    Y = outcome_model.posterior(X).sample().squeeze(0)\n",
        "    util = util_func(Y)\n",
        "    comps = gen_comps(util)\n",
        "    return Y, comps\n",
        "\n",
        "\n",
        "def gen_comps(util):\n",
        "    \"\"\"Given an 1-d tensor of utility, create pairwise comparisons between adjacent items\"\"\"\n",
        "    util = util.reshape(-1, 2)\n",
        "    comps = torch.arange(util.numel()).reshape(-1, 2)\n",
        "    flip = util[:, 0] < util[:, 1]\n",
        "    comps[flip, [0]], comps[flip, [1]] = comps[flip, [1]], comps[flip, [0]]\n",
        "\n",
        "    return comps\n",
        "\n",
        "\n",
        "def run_pref_learn(outcome_model, train_Y, train_comps, n_comps, pe_strategy, verbose=False):\n",
        "    \"\"\"Perform preference exploration with a given PE strategy for n_comps rounds\"\"\"\n",
        "    for i in range(n_comps):\n",
        "        if verbose:\n",
        "            print(f\"Running {i+1}/{n_comps} preference learning using {pe_strategy}\")\n",
        "        pref_model = fit_pref_model(train_Y, train_comps)\n",
        "        if pe_strategy == \"EUBO-zeta\":\n",
        "            # EUBO-zeta\n",
        "            one_sample_outcome_model = FixedSingleSampleModel(model=outcome_model)\n",
        "            acqf = AnalyticExpectedUtilityOfBestOption(pref_model=pref_model, outcome_model=one_sample_outcome_model)\n",
        "            cand_X, acqf_val = optimize_acqf(\n",
        "                acq_function=acqf,\n",
        "                q=2,\n",
        "                bounds=problem.bounds,\n",
        "                num_restarts=NUM_RESTARTS,\n",
        "                raw_samples=RAW_SAMPLES,  # used for intialization heuristic\n",
        "                options={\"batch_limit\": BATCH_LIMIT},\n",
        "            )\n",
        "            cand_Y = one_sample_outcome_model(cand_X)\n",
        "        elif pe_strategy == \"Random-f\":\n",
        "            # Random-f\n",
        "            cand_X = gen_rand_X(problem, n=2)\n",
        "            cand_Y = outcome_model.posterior(cand_X).sample().squeeze(0)\n",
        "        else:\n",
        "            raise RuntimeError(\"Unknown preference exploration strategy!\")\n",
        "\n",
        "        cand_Y = cand_Y.detach().clone()\n",
        "        cand_comps = gen_comps(util_func(cand_Y))\n",
        "\n",
        "        train_comps = torch.cat((train_comps, cand_comps + train_Y.shape[0]))\n",
        "        train_Y = torch.cat((train_Y, cand_Y))\n",
        "\n",
        "    return train_Y, train_comps\n",
        "\n",
        "\n",
        "def gen_exp_cand(outcome_model, objective, q, acqf_name):\n",
        "    \"\"\"Given an outcome model and an objective, generate q experimental candidates\n",
        "    using specified acquisition function.\"\"\"\n",
        "    sampler = SobolQMCNormalSampler(num_samples=NUM_OUTCOME_SAMPLES)\n",
        "    if acqf_name == \"qNEI\":\n",
        "        # generate experimental candidates with qNEI/qNEIUU\n",
        "        acq_func = qNoisyExpectedImprovement(\n",
        "            model=outcome_model,\n",
        "            objective=objective,\n",
        "            X_baseline=X,\n",
        "            sampler=sampler,\n",
        "            prune_baseline=True,\n",
        "        )\n",
        "    elif acqf_name == \"posterior_mean\":\n",
        "        # generate experimental candidates with maximum posterior mean\n",
        "        acq_func = qSimpleRegret(\n",
        "            model=outcome_model,\n",
        "            sampler=sampler,\n",
        "            objective=objective,\n",
        "        )\n",
        "    else:\n",
        "        raise RuntimeError(\"Unknown acquisition function name!\")\n",
        "\n",
        "    # optimize the acquisition function\n",
        "    candidates, _ = optimize_acqf(\n",
        "        acq_function=acq_func,\n",
        "        q=q,\n",
        "        bounds=problem.bounds,\n",
        "        num_restarts=NUM_RESTARTS,\n",
        "        raw_samples=RAW_SAMPLES,\n",
        "        options={\"batch_limit\": BATCH_LIMIT},\n",
        "        sequential=True,\n",
        "    )\n",
        "    return candidates\n",
        "\n",
        "\n",
        "def find_max_posterior_mean(outcome_model, train_Y, train_comps, verbose=False):\n",
        "    \"\"\"Helper function that find the max posterior mean under current outcome and\n",
        "    preference model\"\"\"\n",
        "    pref_model = fit_pref_model(train_Y, train_comps)\n",
        "    sampler = SobolQMCNormalSampler(num_samples=NUM_PREF_SAMPLES)\n",
        "    pref_obj = LearnedObjective(pref_model=pref_model, sampler=sampler)\n",
        "    post_mean_cand_X = gen_exp_cand(outcome_model, pref_obj, q=1, acqf_name=\"posterior_mean\")\n",
        "\n",
        "    post_mean_util = util_func(problem(post_mean_cand_X)).item()\n",
        "    if verbose:\n",
        "        print(f\"Max posterior mean utility: {post_mean_util:.3f}\")\n",
        "    within_result = {\n",
        "        \"n_comps\": train_comps.shape[0],\n",
        "        \"util\": post_mean_util,\n",
        "    }\n",
        "    return within_result"
      ],
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "originalKey": "7d9d4982-ca40-4744-88d5-775a5c306ddd",
        "showInput": false,
        "customInput": null,
        "code_folding": [],
        "hidden_ranges": []
      },
      "source": [
        "## Closed Loop BOPE\n",
        "\n",
        "### Setup\n",
        "The following cell shows the core part of this tutorial.\n",
        "In BOPE, we use two probablistic models (in this case, two Gaussian processes) $f$ and $g$\n",
        "to model $f_\\mathrm{true}$ and $g_\\mathrm{true}$ respectively.\n",
        "\n",
        "We start by initializing the outcome model $f$ with 16 quasi-random points (the initial experimentation stage).\n",
        "\n",
        "Next, we enter the preference exploration (PE) stage.\n",
        "A straightforward strategy of performing PE is to present the decision-maker with comparisons using outcomes estimated\n",
        "by sampling from the outcome model using random design points. We refer this method as $\\text{Random}\\mathrm{-}f$.\n",
        "\n",
        "Alternatively, we could initialize the preference model with $\\text{Random}\\mathrm{-}f$,\n",
        "then perform PE using the $\\text{EUBO}\\mathrm{-}\\zeta$ acquisition function as proposed in [1].\n",
        "<!-- \\tilde{f} somehow is not rendering --> \n",
        "\n",
        "In this tutorial, we examine both strategies by starting with initializating the preference model with 3 comparisons using $\\text{Random}\\mathrm{-}f$.\n",
        "After that, we perform 3 * 4 = 12 pairwise comparisons using either $\\text{EUBO}\\mathrm{-}\\zeta$ or $\\text{Random}\\mathrm{-}f$.\n",
        "Then we move on to the 2nd experimentation stage by generating a candidate using qNEIUU by\n",
        "leveraging both the outcome model and the learned preference model.\n",
        "\n",
        "We additionally examine two other experimental canadidate generation strategies:\n",
        "In the first one, we assume the true utility function is known and generate experiment candidate(s) using qNEI.\n",
        "This represents the performance upper bound of PE strategies.\n",
        "For the second experiment canadidate generation strategy, we use random design points to generate new candidates."
      ],
      "attachments": {}
    },
    {
      "cell_type": "code",
      "metadata": {
        "originalKey": "bfec9691-5175-4eea-89ee-5072a7a08ad8",
        "showInput": true,
        "customInput": null,
        "code_folding": [],
        "hidden_ranges": [],
        "collapsed": false,
        "requestMsgId": "bfec9691-5175-4eea-89ee-5072a7a08ad8",
        "executionStartTime": 1665422433357,
        "executionStopTime": 1665422492003,
        "customOutput": null
      },
      "source": [
        "verbose = False\n",
        "# Number of pairwise comparisons performed before checking posterior mean\n",
        "every_n_comps = 3\n",
        "# Total number of checking the maximum posterior mean\n",
        "n_check_post_mean = 3\n",
        "n_reps = 1\n",
        "within_session_results = []\n",
        "exp_candidate_results = []\n",
        "\n",
        "for i in range(n_reps):\n",
        "    print(f\"Run {i}\")\n",
        "    # Experimentation stage: initial exploration batch\n",
        "    torch.manual_seed(i)\n",
        "    np.random.seed(i)\n",
        "    X, Y = generate_random_exp_data(problem, 16)\n",
        "    outcome_model = fit_outcome_model(X, Y, problem.bounds)\n",
        "\n",
        "    # Preference exploration stage: initialize the preference model with comparsions\n",
        "    # between pairs of outcomes estimated using random design points\n",
        "    init_train_Y, init_train_comps = generate_random_pref_data(outcome_model, n=1)\n",
        "\n",
        "    # Perform preference exploration using either Random-f or EUBO-zeta\n",
        "    for pe_strategy in [\"EUBO-zeta\", \"Random-f\"]:\n",
        "        train_Y, train_comps = init_train_Y.clone(), init_train_comps.clone()\n",
        "        within_result = find_max_posterior_mean(outcome_model, train_Y, train_comps)\n",
        "        within_result.update({\"run_id\": i, \"pe_strategy\": pe_strategy})\n",
        "        within_session_results.append(within_result)\n",
        "\n",
        "        for j in range(n_check_post_mean):\n",
        "            train_Y, train_comps = run_pref_learn(\n",
        "                outcome_model, train_Y, train_comps, n_comps=every_n_comps, pe_strategy=pe_strategy, verbose=verbose\n",
        "            )\n",
        "            if verbose:\n",
        "                print(f\"Checking posterior mean after {(j+1) * every_n_comps} comps using PE strategy {pe_strategy}\")\n",
        "            within_result = find_max_posterior_mean(outcome_model, train_Y, train_comps, verbose=verbose)\n",
        "            within_result.update({\"run_id\": i, \"pe_strategy\": pe_strategy})\n",
        "            within_session_results.append(within_result)\n",
        "\n",
        "        # Going back to the experimentation stage: generate an additional batch of experimental evaluations\n",
        "        # with the learned preference model and qNEIUU\n",
        "        pref_model = fit_pref_model(train_Y, train_comps)\n",
        "        sampler = SobolQMCNormalSampler(num_samples=NUM_PREF_SAMPLES)\n",
        "        pref_obj = LearnedObjective(pref_model=pref_model, sampler=sampler)\n",
        "        exp_cand_X = gen_exp_cand(outcome_model, pref_obj, q=1, acqf_name=\"qNEI\")\n",
        "        qneiuu_util = util_func(problem(exp_cand_X)).item()\n",
        "        print(f\"{pe_strategy} qNEIUU candidate utility: {qneiuu_util:.3f}\")\n",
        "        exp_result = {\n",
        "            \"util\": qneiuu_util,\n",
        "            \"strategy\": pe_strategy,\n",
        "            \"run_id\": i,\n",
        "        }\n",
        "        exp_candidate_results.append(exp_result)\n",
        "\n",
        "    # Generate a batch of experimental evaluations using oracle and random baselines\n",
        "    # True utility\n",
        "    true_obj = GenericMCObjective(util_func)\n",
        "    true_obj_cand_X = gen_exp_cand(outcome_model, true_obj, q=1, acqf_name=\"qNEI\")\n",
        "    true_obj_util = util_func(problem(true_obj_cand_X)).item()\n",
        "    print(f\"True objective utility: {true_obj_util:.3f}\")\n",
        "    exp_result = {\n",
        "        \"util\": true_obj_util,\n",
        "        \"strategy\": \"True Utility\",\n",
        "        \"run_id\": i,\n",
        "    }\n",
        "    exp_candidate_results.append(exp_result)\n",
        "\n",
        "    # Random experiment\n",
        "    _, random_Y = generate_random_exp_data(problem, 1)\n",
        "    random_util = util_func(random_Y).item()\n",
        "    print(f\"Random experiment utility: {random_util:.3f}\")\n",
        "    exp_result = {\n",
        "        \"util\": random_util,\n",
        "        \"strategy\": \"Random Experiment\",\n",
        "        \"run_id\": i,\n",
        "    }\n",
        "    exp_candidate_results.append(exp_result)"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Run 0\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "EUBO-zeta qNEIUU candidate utility: -0.447\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Random-f qNEIUU candidate utility: -0.565\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True objective utility: -0.113\nRandom experiment utility: -1.333\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "originalKey": "64f2fb33-46bc-47ac-b169-ea702e41f6cd",
        "showInput": false,
        "customInput": null,
        "code_folding": [],
        "hidden_ranges": []
      },
      "source": [
        "## Plot the Results\n",
        "\n",
        "We evaluate our results by creating two plots.\n",
        "\n",
        "In the first plot, we focus on comparing how $\\text{EUBO}\\mathrm{-}\\zeta$ can efficiently identify the maximizer \n",
        "of $g_\\mathrm{true}(f_\\mathrm{true}(x))$ within a preference exploration stage.\n",
        "We examine this by estimatig the maximum posterior mean after every 3 pairwise comparisons.\n",
        "\n",
        "Here, we plot the the max utility value identified using $\\text{EUBO}\\mathrm{-}\\zeta$ and $\\text{Random}\\mathrm{-}f$\n",
        "with increasing number of pairwise comparisons.\n",
        "As we can see in this plot, the preference model learned using $\\text{EUBO}\\mathrm{-}\\zeta$ is able to identify the maximum utility more efficiently."
      ],
      "attachments": {}
    },
    {
      "cell_type": "code",
      "metadata": {
        "originalKey": "f414bd4b-b897-4d5b-b621-85e1352bc024",
        "showInput": true,
        "customInput": null,
        "code_folding": [],
        "hidden_ranges": [],
        "collapsed": false,
        "requestMsgId": "f414bd4b-b897-4d5b-b621-85e1352bc024",
        "executionStartTime": 1665422492014,
        "executionStopTime": 1665422492648,
        "customOutput": null
      },
      "source": [
        "# Prepare PE data for plots\n",
        "within_df = pd.DataFrame(within_session_results)\n",
        "within_df[\"pe_strategy\"] = within_df[\"pe_strategy\"].str.replace(\"EUBO-zeta\", r\"$EUBO-\\\\zeta$\")\n",
        "within_df = (\n",
        "    within_df.groupby([\"n_comps\", \"pe_strategy\"])\n",
        "    .agg({\"util\": [\"mean\", \"sem\"]})\n",
        "    .droplevel(level=0, axis=1)\n",
        "    .reset_index()\n",
        ")\n",
        "within_df\n",
        "\n",
        "# Plotting\n",
        "plt.figure(figsize=(8, 6))\n",
        "for name, group in within_df.groupby(\"pe_strategy\", sort=True):\n",
        "    yerr=1.96 * group[\"sem\"]\n",
        "    if np.any(np.isnan(yerr)):\n",
        "        yerr = None\n",
        "    plt.errorbar(\n",
        "        x=group[\"n_comps\"], y=group[\"mean\"], yerr=yerr, label=name, linewidth=1.5, capsize=3, alpha=0.6\n",
        "    )\n",
        "plt.xlabel(\"Number of comparisons\")\n",
        "plt.ylabel(\"Max value identified\")\n",
        "plt.legend(title=\"PE Strategy\")"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": "<matplotlib.legend.Legend at 0x7fa64bd930a0>"
          },
          "metadata": {
            "bento_obj_id": "140352213823648"
          },
          "execution_count": 5
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": "<Figure size 576x432 with 1 Axes>",
            "image/png": "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\n"
          },
          "metadata": {
            "bento_obj_id": "140352213786528",
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "originalKey": "e407a6c3-0cf3-4ec2-886a-4973db669ceb",
        "showInput": false,
        "customInput": null,
        "code_folding": [],
        "hidden_ranges": []
      },
      "source": [
        "In the following cell, we show the average utility values achieved using different methods in the 2nd experimentation stage.\n",
        "\n",
        "We see that $\\text{EUBO}\\mathrm{-}\\zeta$, as a one-step Bayesian optimal PE strategy, performs very similarly to the true utility strategy.\n",
        "\n",
        "On the other hand, despite that $\\text{Random}\\mathrm{-}f$ is a relatively straightforward PE strategy,\n",
        "it is still able to suggest experimental candidates with generally higher utility values than the random experiment baseline."
      ],
      "attachments": {}
    },
    {
      "cell_type": "code",
      "metadata": {
        "originalKey": "309a9641-4a12-4d52-94e7-5701a23f2a79",
        "showInput": true,
        "customInput": null,
        "code_folding": [],
        "hidden_ranges": [],
        "collapsed": false,
        "requestMsgId": "309a9641-4a12-4d52-94e7-5701a23f2a79",
        "executionStartTime": 1665422492662,
        "executionStopTime": 1665422492922,
        "customOutput": null
      },
      "source": [
        "# Prepare the 2nd experimentation batch data for plot\n",
        "exp_df = pd.DataFrame(exp_candidate_results)\n",
        "exp_df[\"strategy\"] = exp_df[\"strategy\"].str.replace(\"EUBO-zeta\", r\"$EUBO-\\\\zeta$\")\n",
        "exp_df[\"strategy\"] = pd.Categorical(\n",
        "    exp_df[\"strategy\"], [\"True Utility\", \"$EUBO-\\zeta$\", \"Random-f\", \"Random Experiment\"]\n",
        ")\n",
        "exp_df = exp_df.groupby([\"strategy\"]).agg({\"util\": [\"mean\", \"sem\"]}).droplevel(level=0, axis=1).reset_index()\n",
        "\n",
        "# Plotting\n",
        "plt.figure(figsize=(8, 6))\n",
        "for name, group in exp_df.groupby(\"strategy\", sort=True):\n",
        "    yerr=1.96 * group[\"sem\"]\n",
        "    if np.any(np.isnan(yerr)):\n",
        "        yerr = None\n",
        "    plt.errorbar(\n",
        "        x=group[\"strategy\"],\n",
        "        y=group[\"mean\"],\n",
        "        yerr=yerr,\n",
        "        fmt=\"o\",\n",
        "        markersize=10,\n",
        "        label=name,\n",
        "        linewidth=1.5,\n",
        "        capsize=3,\n",
        "    )\n",
        "\n",
        "plt.xlabel(\"Experimentation Strategy\")\n",
        "plt.ylabel(\"Utility achieved in the 2nd experiment stage\")\n",
        "plt.legend(title=\"Experimentation Strategy\")"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": "<matplotlib.legend.Legend at 0x7fa64b05b940>"
          },
          "metadata": {
            "bento_obj_id": "140352199964992"
          },
          "execution_count": 6
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": "<Figure size 576x432 with 1 Axes>",
            "image/png": "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\n"
          },
          "metadata": {
            "bento_obj_id": "140352199958240",
            "needs_background": "light"
          }
        }
      ]
    }
  ]
}