tutorials/composite_mtbo.ipynb

{
  "cells": [
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "originalKey": "2c421274-e807-4d93-8b0e-d23afdb49a2d",
        "showInput": false
      },
      "source": [
        "## Composite Bayesian Optimization with Multi-Task Gaussian Processes\n",
        "\n",
        "In this tutorial, we'll be describing how to perform multi-task Bayesian optimization over composite functions. In these types of problems, there are several related outputs, and an overall easy to evaluate objective function that we wish to maximize.\n",
        "\n",
        "**Multi-task Bayesian Optimization** was first proposed by [Swersky et al, NeurIPS, '13](https://papers.neurips.cc/paper/2013/hash/f33ba15effa5c10e873bf3842afb46a6-Abstract.html) in the context of fast hyper-parameter tuning for neural network models; however, we demonstrate a more advanced use-case of **[composite Bayesian optimization](https://proceedings.mlr.press/v97/astudillo19a.html)** where the overall function that we wish to optimize is a cheap-to-evaluate (and known) function of the outputs. In general, we expect that using more information about the function should yield improved performance when attempting to optimize it, particularly if the metric function itself is quickly varying.\n",
        "\n",
        "See [the composite BO tutorial w/ HOGP](https://github.com/pytorch/botorch/blob/main/tutorials/composite_bo_with_hogp.ipynb) for a more technical introduction. In general, we suggest using MTGPs for unstructured task outputs and the HOGP for matrix / tensor structured outputs.\n",
        "\n",
        "\n",
        "We will use a Multi-Task Gaussian process ([MTGP](https://papers.nips.cc/paper/2007/hash/66368270ffd51418ec58bd793f2d9b1b-Abstract.html)) with an ICM kernel to model all of the outputs in this problem. MTGPs can be easily accessed in Botorch via the `botorch.models.KroneckerMultiTaskGP` model class (for the \"block design\" case of fully observed outputs at all inputs). Given $T$ tasks (outputs) and $n$ data points, they assume that the responses, $Y \\sim \\mathbb{R}^{n \\times T},$ are distributed as $\\text{vec}(Y) \\sim \\mathcal{N}(f, D)$ and $f \\sim \\mathcal{GP}(\\mu_{\\theta}, K_{XX} \\otimes K_{T}),$ where $D$ is a (diagonal) noise term."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "collapsed": false,
        "customOutput": null,
        "executionStartTime": 1678932909107,
        "executionStopTime": 1678932912073,
        "originalKey": "8871a990-f29b-45c2-b378-ac2befef0a1f",
        "requestMsgId": "e32e501e-2fe4-4b41-b1fd-4a3cf218833e"
      },
      "outputs": [],
      "source": [
        "import os\n",
        "import time\n",
        "\n",
        "import torch\n",
        "from botorch.acquisition.logei import qLogExpectedImprovement\n",
        "from botorch.acquisition.objective import GenericMCObjective\n",
        "from botorch.models import KroneckerMultiTaskGP\n",
        "from botorch.optim import optimize_acqf\n",
        "from botorch.sampling.normal import IIDNormalSampler\n",
        "\n",
        "from botorch.test_functions import Hartmann\n",
        "from gpytorch.mlls import ExactMarginalLogLikelihood\n",
        "\n",
        "import warnings\n",
        "warnings.filterwarnings(\"ignore\")\n",
        "\n",
        "SMOKE_TEST = os.environ.get(\"SMOKE_TEST\")"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "originalKey": "de394597-4088-4f32-94c7-7c611876eebc",
        "showInput": false
      },
      "source": [
        "### Set device, dtype and random seed"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "collapsed": false,
        "customOutput": null,
        "executionStartTime": 1678932914757,
        "executionStopTime": 1678932914766,
        "originalKey": "015a9aab-e3a5-4d09-bd5d-209f9b41cbdb",
        "requestMsgId": "00e96c89-1a35-4c00-852c-1f5dda614d9a"
      },
      "outputs": [],
      "source": [
        "torch.random.manual_seed(10)\n",
        "\n",
        "tkwargs = {\n",
        "    \"dtype\": torch.double,\n",
        "    \"device\": torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\"),\n",
        "}"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "originalKey": "f151402e-238e-4c5c-be43-55a73f07664e",
        "showInput": false
      },
      "source": [
        "### Problem Definition\n",
        "\n",
        "The function that we wish to optimize is based off of a contextual version of the Hartmann-6 test function, where following [Feng et al, NeurIPS, '20](https://proceedings.neurips.cc/paper/2020/hash/faff959d885ec0ecf70741a846c34d1d-Abstract.html) we convert the sixth task dimension into a task indicator. Here we assume that we evaluate all contexts at once."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "collapsed": false,
        "customOutput": null,
        "executionStartTime": 1678932917176,
        "executionStopTime": 1678932917215,
        "originalKey": "48fabc12-b1ee-4b88-aa97-9ce4bfe83fd4",
        "requestMsgId": "0429d2a2-cc39-4838-9b87-f3eebd49e140"
      },
      "outputs": [],
      "source": [
        "from torch import Tensor\n",
        "\n",
        "\n",
        "class ContextualHartmann6(Hartmann):\n",
        "    def __init__(self, num_tasks: int = 20, noise_std=None, negate=False):\n",
        "        super().__init__(dim=6, noise_std=noise_std, negate=negate)\n",
        "        self.task_range = torch.linspace(0, 1, num_tasks).unsqueeze(-1)\n",
        "        self._bounds = [(0.0, 1.0) for _ in range(self.dim - 1)]\n",
        "        self.bounds = torch.tensor(self._bounds).t()\n",
        "\n",
        "    def evaluate_true(self, X: Tensor) -> Tensor:\n",
        "        batch_X = X.unsqueeze(-2)\n",
        "        batch_dims = X.ndim - 1\n",
        "\n",
        "        expanded_task_range = self.task_range\n",
        "        for _ in range(batch_dims):\n",
        "            expanded_task_range = expanded_task_range.unsqueeze(0)\n",
        "        task_range = expanded_task_range.repeat(*X.shape[:-1], 1, 1).to(X)\n",
        "        concatenated_X = torch.cat(\n",
        "            (\n",
        "                batch_X.repeat(*[1] * batch_dims, self.task_range.shape[0], 1),\n",
        "                task_range,\n",
        "            ),\n",
        "            dim=-1,\n",
        "        )\n",
        "        return super().evaluate_true(concatenated_X)"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "originalKey": "a2fbe3e8-98cf-49e0-9891-8d6009790955",
        "showInput": false
      },
      "source": [
        "We use `GenericMCObjective` to define the differentiable function that we are optimizing. Here, it is defined as \n",
        "$$g(f) = \\sum_{i=1}^T \\cos(f_i^2 + f_i w_i)$$\n",
        "where $w$ is a weight vector (drawn randomly once at the start of the optimization). As this function is a non-linear function of the outputs $f,$ we cannot compute acquisition functions via computation of the posterior mean and variance, but rather have to compute posterior samples and evaluate acquisitions with Monte Carlo sampling. \n",
        "\n",
        "For greater than $10$ or so tasks, it is computationally challenging to sample the posterior over all tasks jointly using conventional approaches, except that [Maddox et al, '21](https://arxiv.org/abs/2106.12997) have devised an efficient method for exploiting the structure in the posterior distribution of the MTGP, enabling efficient MC based optimization of objectives using MTGPs. In this tutorial, we choose 6  contexts/tasks for demostration. "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "collapsed": false,
        "customOutput": null,
        "executionStartTime": 1678932920811,
        "executionStopTime": 1678932929399,
        "originalKey": "5938fb26-f773-4f68-a389-c0630e0687eb",
        "requestMsgId": "80cec36b-8b73-4c09-9511-f79f59df0af8"
      },
      "outputs": [],
      "source": [
        "num_tasks = 6\n",
        "problem = ContextualHartmann6(num_tasks=num_tasks, noise_std=0.001, negate=True).to(**tkwargs)\n",
        "\n",
        "# we choose num_tasks random weights\n",
        "weights = torch.randn(num_tasks, **tkwargs)\n",
        "\n",
        "\n",
        "def callable_func(samples, X=None):\n",
        "    res = -torch.cos((samples**2) + samples * weights)\n",
        "    return res.sum(dim=-1)\n",
        "\n",
        "\n",
        "objective = GenericMCObjective(callable_func)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "collapsed": false,
        "customOutput": null,
        "executionStartTime": 1678932929407,
        "executionStopTime": 1678932929411,
        "originalKey": "5a85661a-3668-4128-b5f4-8150dbcdce7d",
        "requestMsgId": "d1742d93-d229-4400-b3d9-55e5fee5eed6"
      },
      "outputs": [],
      "source": [
        "bounds = problem.bounds"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "originalKey": "eff2dc86-0797-40a7-962d-04e8c539c21a",
        "showInput": false
      },
      "source": [
        "## BO Loop"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "originalKey": "53414433-e097-4556-90e9-e99e35cdb390",
        "showInput": false
      },
      "source": [
        "Set environmental parameters, we use 20 initial data points and optimize for 20 steps with a batch size of 3 candidate points at each evaluation."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "collapsed": false,
        "customOutput": null,
        "executionStartTime": 1678932929437,
        "executionStopTime": 1678932929440,
        "originalKey": "51f24269-b5de-4dd8-b2b4-18d269f3f3c2",
        "requestMsgId": "63c971a6-7e24-4b8a-8ec8-15d0ef21f6ff"
      },
      "outputs": [],
      "source": [
        "if SMOKE_TEST:\n",
        "    n_init = 5\n",
        "    n_steps = 1\n",
        "    batch_size = 2\n",
        "    num_samples = 4\n",
        "    # For L-BFGS inner optimization loop\n",
        "    MAXITER = 10\n",
        "else:\n",
        "    n_init = 10\n",
        "    n_steps = 10\n",
        "    batch_size = 3\n",
        "    num_samples = 64\n",
        "    MAXITER = 200"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "collapsed": false,
        "customOutput": null,
        "executionStartTime": 1678932930875,
        "executionStopTime": 1678934072848,
        "originalKey": "de8d4079-6c17-4041-9ec4-9ebd09d46cd7",
        "requestMsgId": "34279809-d637-4ea5-99c2-aaa3957c37ba"
      },
      "outputs": [],
      "source": [
        "from botorch.fit import fit_gpytorch_mll"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Finally, run the optimization loop.\n",
        "\n",
        "Warning... this optimization loop can take a while, especially on the CPU. We compare to random sampling. "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "originalKey": "b567ab22-f3b4-41e3-aaae-75e6fe820cfc",
        "showInput": false
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "Batch  0: best_value (random, mtgp) = (-4.76, -4.76, mtgp time = 15.64\n",
            "Batch  1: best_value (random, mtgp) = (-4.76, -4.76, mtgp time = 36.96\n",
            "Batch  2: best_value (random, mtgp) = (-4.39, -4.76, mtgp time = 23.20\n",
            "Batch  3: best_value (random, mtgp) = (-4.39, -4.76, mtgp time = 23.07\n",
            "Batch  4: best_value (random, mtgp) = (-4.39, -4.76, mtgp time = 35.79\n",
            "Batch  5: best_value (random, mtgp) = (-4.22, -4.76, mtgp time = 50.71\n",
            "Batch  6: best_value (random, mtgp) = (-4.22, -2.88, mtgp time = 61.87\n",
            "Batch  7: best_value (random, mtgp) = (-4.22, -2.88, mtgp time = 115.77\n",
            "Batch  8: best_value (random, mtgp) = (-4.22, -1.91, mtgp time = 67.89\n",
            "Batch  9: best_value (random, mtgp) = (-4.22, -1.91, mtgp time = 48.66"
          ]
        }
      ],
      "source": [
        "# New version\n",
        "torch.manual_seed(0)\n",
        "\n",
        "init_x = (bounds[1] - bounds[0]) * torch.rand(\n",
        "    n_init, bounds.shape[1], **tkwargs\n",
        ") + bounds[0]\n",
        "\n",
        "init_y = problem(init_x)\n",
        "\n",
        "mtgp_train_x, mtgp_train_y = init_x, init_y\n",
        "rand_x, rand_y = init_x, init_y\n",
        "\n",
        "best_value_mtgp = objective(init_y).max()\n",
        "best_random = best_value_mtgp\n",
        "\n",
        "for iteration in range(n_steps):\n",
        "    # we empty the cache to clear memory out\n",
        "    torch.cuda.empty_cache()\n",
        "\n",
        "    # MTGP\n",
        "    mtgp_t0 = time.monotonic()\n",
        "    mtgp = KroneckerMultiTaskGP(mtgp_train_x, mtgp_train_y)\n",
        "    mtgp_mll = ExactMarginalLogLikelihood(mtgp.likelihood, mtgp)\n",
        "    fit_gpytorch_mll(mll=mtgp_mll, optimizer_kwargs={\"options\": {\"maxiter\": 50}})\n",
        "\n",
        "    sampler = IIDNormalSampler(sample_shape=torch.Size([num_samples]))\n",
        "    mtgp_acqf = qLogExpectedImprovement(\n",
        "        model=mtgp,\n",
        "        best_f=best_value_mtgp,\n",
        "        sampler=sampler,\n",
        "        objective=objective,\n",
        "    )\n",
        "    new_mtgp_x, _ = optimize_acqf(\n",
        "        acq_function=mtgp_acqf,\n",
        "        bounds=bounds,\n",
        "        q=batch_size,\n",
        "        num_restarts=10,\n",
        "        raw_samples=512,  # used for intialization heuristic\n",
        "        options={\"batch_limit\": 5, \"maxiter\": MAXITER, \"init_batch_limit\": 5},\n",
        "    )\n",
        "    mtgp_train_x = torch.cat((mtgp_train_x, new_mtgp_x), dim=0)\n",
        "    mtgp_train_y = torch.cat((mtgp_train_y, problem(new_mtgp_x)), dim=0)\n",
        "    best_value_mtgp = objective(mtgp_train_y).max()\n",
        "    mtgp_t1 = time.monotonic()\n",
        "\n",
        "    # rand\n",
        "    new_rand_x = (bounds[1] - bounds[0]) * torch.rand(\n",
        "        batch_size, bounds.shape[1], **tkwargs\n",
        "    ) + bounds[0]\n",
        "    rand_x = torch.cat((rand_x, new_rand_x))\n",
        "    rand_y = torch.cat((rand_y, problem(new_rand_x)))\n",
        "    best_random = objective(rand_y).max()\n",
        "\n",
        "    print(\n",
        "        f\"\\nBatch {iteration:>2}: best_value (random, mtgp) = \"\n",
        "        f\"({best_random:>4.2f}, {best_value_mtgp:>4.2f}, \"\n",
        "        f\"mtgp time = {mtgp_t1-mtgp_t0:>4.2f}\",\n",
        "        end=\"\",\n",
        "    )\n",
        "\n",
        "objectives = {\n",
        "    \"MGTP\": objective(mtgp_train_y).detach().cpu(),\n",
        "    \"Random\": objective(rand_y).detach().cpu(),\n",
        "}"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "originalKey": "b567ab22-f3b4-41e3-aaae-75e6fe820cfc",
        "showInput": false
      },
      "source": [
        "### Plot Results"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "collapsed": false,
        "customOutput": null,
        "executionStartTime": 1678934072894,
        "executionStopTime": 1678934073463,
        "originalKey": "8ec120a6-bc85-42cc-9c59-9963964a0da3",
        "requestMsgId": "b1f7777e-e686-4325-a0e0-d0c8578ec106"
      },
      "outputs": [],
      "source": [
        "import matplotlib.pyplot as plt"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "originalKey": "3585efc5-bcb5-49f0-9fe1-e50d2deccfd2",
        "showInput": false
      },
      "source": [
        "Finally, we plot the results. MTGP will outperform the random baseline."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {},
      "outputs": [],
      "source": [
        "results = {\n",
        "    k: t[n_init:].cummax(0).values for k, t in objectives.items()\n",
        "}"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<matplotlib.legend.Legend at 0x7f26b3d3b010>"
            ]
          },
          "execution_count": 29,
          "metadata": {},
          "output_type": "execute_result"
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1500x1000 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "for name, vals in results.items():\n",
        "    plt.plot(vals, label=name)\n",
        "plt.legend()"
      ]
    }
  ],
  "metadata": {
    "custom": {
      "cells": [],
      "metadata": {
        "custom": {
          "cells": [],
          "metadata": {
            "fileHeader": "",
            "isAdHoc": false,
            "kernelspec": {
              "display_name": "ae",
              "language": "python",
              "name": "bento_kernel_ae"
            },
            "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.8"
            }
          },
          "nbformat": 4,
          "nbformat_minor": 2
        },
        "fileHeader": "",
        "indentAmount": 2,
        "isAdHoc": false,
        "kernelspec": {
          "display_name": "python3",
          "language": "python",
          "name": "python3"
        },
        "language_info": {
          "name": "plaintext"
        }
      },
      "nbformat": 4,
      "nbformat_minor": 2
    },
    "indentAmount": 2,
    "kernelspec": {
      "name": "python3",
      "display_name": "python3"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 2
}