diff --git a/tutorials/constraint_active_search.ipynb b/tutorials/constraint_active_search.ipynb
new file mode 100644
index 0000000000..5845546acc
--- /dev/null
+++ b/tutorials/constraint_active_search.ipynb
@@ -0,0 +1,742 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "code_folding": [],
+        "hidden_ranges": [],
+        "originalKey": "c31f62e6-7593-4975-ac72-c8d1a59fe3b7",
+        "showInput": false
+      },
+      "source": [
+        "## Constraint Active Search for Multiobjective Experimental Design\n",
+        "\n",
+        "In this tutorial we show how to implement the Expected Coverage Improvement (ECI) [1] acquisition function in BoTorch. For a number of outcome constraints, ECI tries to efficiently discover the feasible region and simultaneously sample diverse feasible configurations. Given a user-specified punchout radius $r$, we center a sphere with that radius around each evaluated configuration. The total coverage is now given by the volume of the union of these sphere intersected with the feasible region; see the paper and, in particular, Figure 2 for a full description of how ECI works.\n",
+        "\n",
+        "By design, ECI prefers candidates that are in unexplored regions since the candidate's corresponding sphere won't intersect with the spheres around the previously evaluated configurations. On the other hand, ECI also prefers configurations that are likely to satisfy the constraints and to give an improvement in the total coverage. This results in an exploitation-exploration trade-off similar to other acquisition functions.\n",
+        "\n",
+        "ECI may be estimated using the following equation:\n",
+        "$$\n",
+        "\\text{ECI}(x) = \\sum_{x' \\in \\mathbb{N}(x) \\setminus \\mathbb{N}_{r}(X)} p(Z(x') = 1 \\;|\\; \\mathcal{D}_t).\n",
+        "$$\n",
+        "\n",
+        "where $\\mathbb{N}(x) \\setminus \\mathbb{N}_{r}(X)$ a set of points generated via Monte Carlo to be inside a sphere of radius $r$ around $x$, but sufficiently far from the set of known evaluations $X$ (where sufficiently far is defined by the punchout radius $r$). The function $p(Z(x') = 1 \\;|\\; \\mathcal{D}_t)$ is the probability that the GP at $x'$ satisfies a user-specified threshold value, or threshold values in the case of multiple objective functions. \n",
+        "\n",
+        "[1]: [Malkomes et al., Beyond the Pareto Efficient Frontier: Constraint Active Search for Multiobjective Experimental Design, Proceedings of the 38th International Conference on Machine Learning, 2021](http://proceedings.mlr.press/v139/malkomes21a/malkomes21a.pdf)."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "metadata": {
+        "code_folding": [],
+        "executionStartTime": 1638489228284,
+        "executionStopTime": 1638489229640,
+        "hidden_ranges": [],
+        "originalKey": "bec63924-646e-40dd-a97c-ce13cdc2bcaa",
+        "requestMsgId": "9896cb02-0d0e-498f-bdf7-86ea14baaf40"
+      },
+      "outputs": [],
+      "source": [
+        "import os\n",
+        "\n",
+        "import matplotlib.pyplot as plt\n",
+        "import torch\n",
+        "from botorch.acquisition.monte_carlo import MCAcquisitionFunction\n",
+        "from botorch.acquisition.objective import IdentityMCObjective\n",
+        "from botorch.fit import fit_gpytorch_model\n",
+        "from botorch.models import ModelListGP, SingleTaskGP\n",
+        "from botorch.models.transforms.outcome import Standardize\n",
+        "from botorch.optim import optimize_acqf\n",
+        "from botorch.utils.sampling import sample_hypersphere\n",
+        "from botorch.utils.transforms import t_batch_mode_transform\n",
+        "from gpytorch.constraints import Interval\n",
+        "from gpytorch.likelihoods import GaussianLikelihood\n",
+        "from gpytorch.mlls import ExactMarginalLogLikelihood\n",
+        "from torch.quasirandom import SobolEngine"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 2,
+      "metadata": {
+        "code_folding": [],
+        "executionStartTime": 1638489229684,
+        "executionStopTime": 1638489230490,
+        "hidden_ranges": [],
+        "originalKey": "110f7616-b030-4e03-9c6c-b32126d1638f",
+        "requestMsgId": "b4b78cb1-b0d4-4203-a97b-7a293ea418d4"
+      },
+      "outputs": [],
+      "source": [
+        "tkwargs = {\n",
+        "    \"device\": torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\"),\n",
+        "    \"dtype\": torch.double,\n",
+        "}\n",
+        "SMOKE_TEST = os.environ.get(\"SMOKE_TEST\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "code_folding": [],
+        "hidden_ranges": [],
+        "originalKey": "e9cecfd7-f548-4b66-8009-c97809afc144",
+        "showInput": false
+      },
+      "source": [
+        "To start, we need to be able to sample points in $\\mathbb{N}(x) \\setminus \\mathbb{N}_{r}(X)$. We can generate a pool of points and use standard rejection sampling to do so, but this leads to an acquisition function that isn't immediately differentiable; rejection sampling is essentially providing either a binary weight of either 0 or 1 to each point in the sample pool, which is not a differentiable function. \n",
+        "\n",
+        "\n",
+        "In order to make the acquisition function differentiable, we rely on a differentiable approximation of this binary weight function. For example, `smooth_box_mask` is a continuous differentiable approximation of $a < x < b$ (see the plot below for a visualization). A larger value of eps will make the sigmoid less steep and result in a smoother (and easier to optimize) but less accurate acquisition function. "
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 3,
+      "metadata": {
+        "executionStartTime": 1638489230493,
+        "executionStopTime": 1638489230509,
+        "originalKey": "ee47ba8c-e75c-43a8-980f-8a08e5dcf736",
+        "requestMsgId": "63c0a300-c3a1-49bb-a6ba-41cf9dfa9632"
+      },
+      "outputs": [],
+      "source": [
+        "def smooth_mask(x, a, eps=2e-3):\n",
+        "    \"\"\"Returns 0ish for x < a and 1ish for x > a\"\"\"\n",
+        "    return torch.nn.Sigmoid()((x - a) / eps)\n",
+        "\n",
+        "\n",
+        "def smooth_box_mask(x, a, b, eps=2e-3):\n",
+        "    \"\"\"Returns 1ish for a < x < b and 0ish otherwise\"\"\"\n",
+        "    return smooth_mask(x, a, eps) - smooth_mask(x, b, eps)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 4,
+      "metadata": {
+        "code_folding": [],
+        "executionStartTime": 1638489230587,
+        "executionStopTime": 1638489233802,
+        "hidden_ranges": [],
+        "originalKey": "6b64e41e-62fb-4eb2-aaea-859d453a8191",
+        "requestMsgId": "7b49f71b-f131-4600-96fd-5aa581212202"
+      },
+      "outputs": [
+        {
+          "data": {
+            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAekAAAD7CAYAAABOp2yzAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAbRUlEQVR4nO3df6wl5X3f8feFNcsCu5jl7rIghW3sWm5SRF1Ux0Ai10gMtSe1rJFMKwcau3ZRyB+RIMi4ipofdmU2NqGV1QhXkZDluI3rutLUKju1NRaYRsQ2lAZFYXHiKGYlZ33wnt1l+WV29+7d/rGz+N7D/TH33DPPzDzzfklXZ2fOnHOf8/B87veZ58w5zJ05cwZJktQ957XdAEmStDKLtCRJHWWRliSpoyzSkiR1lEVakqSO2tJ2A1aw7uXmRw+P2LlrT5jWyP4ObAP9Pdd8azbFLHeQfR5Wzf5eNcu9PJNePL3YdhMGxf4Oa0j9PaTX2hX2eVib7e9eFmlJkobAIi1JUkdZpCVJ6iiLtCRJHWWRliSpo2p/BCtJs58FvgD8U+BnyyJ/bo1jtwH3A7cCO4BngHvLIn9kZi2XNDXzLPVDrSKdpFkG/Gfg6zWf90HgBuAm4CBwJ7A/SbNryyL//uaa3E/f/S784R/C3/0dLCy03ZqNOXXyct50QdutGI5z/f3Zz8L118/++c3z5pw8CfffD489dvbfi1N8wmZuik+4z+oxa+W5zXatdewNN8DHPw7bt2/8d/Vd3TPpncC7gZ8BfnWtA5M02wncDnywLPID1e4HkjS7rQr3PZtvdr8cOQK//Mtnb/tpa9sNGJiz/X3sWGO/wDxvwn33wSc/2XYrNqN/ef7mN+HwYfj859tuSXi1inRZ5A9xNrA/U+Pw66rnfXJi/xPAuucFRw+P1v3w98LCKcajQzWa0g1/8t+2ceTIZW03Qz1z/OgRxqMTq94/v+eqqZ43VJ5jzPKZM/BHf3QFcH7bTRmcP/7jRf7dvx2xtWdzjDpjfK0sN/G1oLur28nzxjGw7nej1fm6uvHo0NR/oNrw13/TdgvUR5fuvJz59r+9ceo8x5jl55+HH/2o7VYM06uvnseR41dx7bVtt2RjNjvGQ35391yd7/KN0YmJk6Hbb4c77mirNRv3wpExb758vu1mDMa5/r7mmrZbsqZB5nkyy3D2vemNODNFr83yMcePjrl05xvz3Ha7VpIky7dPntz47+u7Jor0qLrdBfxwyf7dS+4blMkLS97zHnj3u9tqzcaNRye7cEY3GB3rb/O8xGSWr766X1mme+NrTe98Jzy55I2WaS7S67smPif9FHCyuhp0qRuBxxv4fZ03ObDO89Pp6g/zvIRZDmuyf4dYpGdyJp2k2T7g6rLIbyuL/HiSZg8B+5I0O1B9ZOMeYG/1UY7BMdjqE/O8OrMclkW6/uek/6oK5bku+6skzc4AXyqL/A7gyur+c+4GPgM8CmwHngZuKYv8YDMvo9sMtrrEPE/PLIdlka7/Eay3r3P/Rya2TwB3VT+DZ7DVJeZ5epMXPZnlZlmk/e7uIAy2FAcn3GFN9u80V5P3nUMsgMlgT/M1epLaZ5bDmuxfz6TVCGffUhzMclgud1ukgzDYUhzMclgWaYt0EAZbioPXl4RlkbZIB2GRluJglsOySFukg3D2LcXBIh2WV3dbpIPwilApDmY5LK/utkgH4exbioNZDsvlbot0EAZbioNZDssibZEOwmBLcfD6krAs0hbpICzSUhzMclgWaYt0EJOzby82kfrJC8fCmuxfr+5WI5x9S3Ewy2F5Jm2RDsJgS3Ewy2FZpC3SQRhsKQ5eOBaWRdoiHYRFWoqDWQ7LIm2RDsJgS3Ewy2FZpC3SQXh1txQHr+4Oy6u7LdJBOPuW4mCWw/JM2iIdhMGW4mCWw7JIW6SDMNhSHLy6OyyLtEU6CIu0FAezHJZF2iIdhMGW4mCWw7JIW6SD8OpuKQ5e3R2WV3dbpINw9i3FwSyH5Zm0RToIgy3FwQvHwrJIW6SDsEhLcTDLYVmkYUudg5I02wbcD9wK7ACeAe4ti/yRVY7/B8BngRuBNwHfAz5VFvn+mb+CHjDY6hLzPD2zHJZFuv6Z9IPAzcBNwDzwZWB/kmZvmzwwSbM54BvAS8Bbq+P/K/A/q7APjhebqGPM85TMcliT/WuRXkGSZjuB24FPlEV+oCzyV8oifwB4FrhzhYfsBq4G/qQs8uNlkZ8CHqrO2v9RMy+j23wfS11hnjfHM+mwJvvXq7tXdl0VyCcn9j8BXD95cFnkzwOPAR9N0mw+SbOtwK8BR4Bvza7p/WGw1SHmeRPMclgud9d7T3p3dXtkYv8Y2LPKY/4F8L+Bw8CZ6tgPVoFf09HDIxZPr/1fYmHhFOPRoRpN74aFU7uXdfUL4+cZbzvdaps2om/93Xd1+3t+z1XTPH2wPMeY5RdfuAh48+vbJ0+8wnh0vNU2bVSf+vy1V7cD21/ffun4i4xHL7fapo2q099rZbnWhWOrmKsCu0ySZhdU72F9D3gf8DLwYeB/JWl2Q1nkf7nWk+7ctdrfiZ8ajw5N+weqHRPvq8zvuYL59V9mZ/Suv3uupf6eeZ5jzPLF25dvX3Txxczvubit5kylT31+yY7l29su3sH8nh2rHd5Jm+3vOkV6VN3uAn64ZP/uJfctdTPwDuB9ZZH/uNr3+STNfh34KPCbU7e2p1wiU4eY500wy2G53F3vPemngJPADRP7bwQeX+Nxk9c9bllppj4EXhGqDjHPm2CWw/Lq7hpn0mWRH0/S7CFgX5JmB4CDwD3A3uqjHCRptg+4uizy24A/q2bkv5+k2V3AK9XVpG+vLjgZHK/uVleY583xTDosr+6u/znpu4GHgUeri0feC9xSFvnB6v4rq5BTFvkLwD8DLgf+ujr+14FbyyL/0+ZeSncZbHWMeZ6SE+6wXO6ueeFYWeQngLuqn5Xu/8jE9l8A/3xWjew7i7S6xDxPzyyHZZH2u7uDMNhSHMxyWBZpi3QQBluKg1kOyyJtkQ7CK0KlOJjlsLy62yIdhBebSHEwy2F5dbdFOgiXyKQ4mOWwXO62SAdhsKU4mOWwLNIW6SB8H0uKg1kOy/ekLdJBTL6PYrClfjLLYU32r+9JKwiDLcXBLDfL/rVIBzHE2Z8UI7PcriH2v0U6AJfIpDiY5bBc7rZIt8JgS3Ewy82yfy3SQQxx9ifFyCy3a4j9b5EOwCUyKQ5mOSyXuy3SQRhsKQ5mOSyLtEW6FQZbioNZbpb9a5GWpNqGeCbXJUPsf4t0w1YaVM4OpX5yuTssl7st0pI0NYt0s+xfi3Tjhjjzk2Jlnts1xP63SDfM5TEpHuY5LJe7LdKNM9RSPMxzWPavRVqS1BOeSWvmnHlL8TDPYbncbZFunKGW4mGew7J/LdLBOeikeJjnsDyT1swNcVBJsTLPYbncbZFunMtjUjzMc1gWaYt0cIZaiod5bpb9C1vqHJSk2TbgfuBWYAfwDHBvWeSPrPGYjwKfAPYCh4D/VBb5f5xp63tgiDM/dZt5np55btcQ+7/umfSDwM3ATcA88GVgf5Jmb1vp4CTN/iXwO8CvApcCvwHcmaTZO2fb/O5zeUwdZJ6nZJ7Dcrm7xpl0kmY7gduBD5ZFfqDa/UCSZrcBdwL3rPCw3wU+Xhb5d6vt/dXP4BhqdYl53hzzHJb9W2+5+7rquCcn9j8BXD95cJJmVwI/B5yfpNn/Bd4O/C3w6bLI//t6v+zo4RGLpxfXPGZh4RTj0aEaTW/fK6/OAVe+vj3HIuPRqNU2bVSf+jsGdft7fs9V0zx9sDzHlmWAn7yyA7jk9e1XXz7OePRKq23aqD71+UsvbAMue337tVdfZTx6odU2bVSd/l4ry3WK9O7q9sjE/jGwZ4Xjr65u7wQ+VL1/9W+AryRp9nxZ5I+t9ct27lrpKSd+8ejQtH+ggrvw5Ykdc+f1pu3n9Km/Y9BwfwfLc2xZBrjwouXbF2+/lPk9l7bVnKn0qc93XLZ8+4ILL2J+z0WrHd5Jm+3vWheOrWIOWOkdgnPP+cmyyL9f/ftz1XLavwbWLNKxcXlMPWGeazDPYdm/9S4cO7c2u2ti/+4l9y01rm6PTez/22XrvgPloFPLzPMMmeewhnjhWJ0i/RRwErhhYv+NwOMrHP83VbDfNbH/7wM/2ERbe2mIg0qdZp43wTyH5dXdNZa7yyI/nqTZQ8C+JM0OAAerK0D3Vh/lIEmzfcDVZZHfVhb56STN/gPwu0ma/TnwF8AdwD+ubgfF5TF1iXneHPMclkW6/nvSdwOfAR4FtgNPA7eURX6wuv/KKuTn/H51lv4/gMuB7wHvL4v8zxt4Db1iqNUB5nlGzLOaVqtIl0V+Arir+lnp/o9MbJ8BPl39DNoQZ37qNvM8PfMclmfSfnd341wek+JhnsOySFukG2eopXiY57DsX4t0cA46KR7mOSzPpDVzQxxUUqzMc1gud1ukG+fymBQP8xyW/WuRDs5BJ8XDPIflmbRmboiDSoqVeQ7L5W6LdONcHpPiYZ7Dsn8t0sE56KR4mOewPJPWzA1xUEmxMs9hudxtkW6cy2NSPMxzWBZpi3TjDLUUD/Mclv1rkQ7OQSfFwzyH5Zm0Zm6Ig0qKlXkOy+Vui3TjXB6T4mGew7J/LdLBOeikeJjnsDyT1swNcVBJsTLPYbncbZFunMtjUjzMc1j2r0W6cYZaiod5bpdn0pIkdYTL3RbpxjnzluJhnsOySFukG2eopXiYZ4VmkQ7MUEvxMM/N8kzaIt24IQ4qKVbmOSyLtEW6cS6PSfEwz2HZvxbp4Bx0UjzMc1ieSWvmhjiopFiZ57Bc7rZIN87lMSke5jks+xe21DkoSbNtwP3ArcAO4Bng3rLIH6nx2F8E/g/w78si/72ZtLpHDLW6xjxPzzy3yzPp1T0I3AzcBMwDXwb2J2n2trUeVP0x+ALw8myaK2kGzLN6weXuGmfSSZrtBG4HPlgW+YFq9wNJmt0G3Ancs8bD7wO+BxyaXZP7xZm3usQ8b455Dsv+rXcmfV1VzJ+c2P8EcP1qD0rS7JeAfwX82uab2V+GWh1jnjfBPLfLM+mV7a5uj0zsHwN7VnpAkmYXVctid5VF/qMkzWo36OjhEYunF9c8ZmHhFONRPybzxw6fD1zx+vbi4gLj0Y9bbdNG9am/Y1C3v+f3XDXN0wfLc2xZBjjx2mXAtte3Xzp+lPHotVbbtFF96vMXj11QvSNz1skTJxiPJodut9Xp77WyXOvCsVXMAavNa+4DDpRF/l82+qQ7d634d2KZ8ejQtH+gghu/sHz7/PO39Kbt5/Spv2PQUn/PPM+xZRnggq3Lt3e8eSfz67/MTulTn7/58uXbW960tTdtP2ez/V2nSI+q213AD5fs373kvtdVy2K/Alw7dasi4vKYOsY8b4J5Dsv+rfee9FPASeCGif03Ao+vcPzHqo91/GWSZuMkzcbALwL3Jmn2/2bU7t5y0Kll5nmGzHNYvie9grLIjydp9hCwL0mzA8DB6grQvdVHOUjSbB9wdVnktwG/Cfz2xNN8Ffg28NnGXklHDXFQqbvM8+aY57D8CFb996TvBj4DPApsB54GbimL/GB1/5VVyCmL/BhwbOmDkzQ7AbxYFvkbltNi5/KYOsg8T8k8h2X/1izSZZGfAO6qfla6/yPrPP490zaw7wy1usY8T888t2uIZ9J+d3dghlqKh3lulsvdFunGDXFQSbEyz2E5CbJIN87lMSke5rldQ5wkWaQDM9RSPMxzs1zutkg3boiDSoqVeQ7LSZBFunEuj0nxMM/tGuIkySIdmKGW4mGem+Vyt0W6cUMcVFKszHNYFmmLdONcHpPiYZ7Dsn8t0o0z1FI8zHO7PJNW4wy1FA/z3CyXuy3SjRvioJJiZZ7DchJkkW6cy2NSPMxzu4Y4SbJIB2aopXiY52a53G2RbtwQB5UUK/MclpMgi3TjXB6T4mGe2zXESZJFumGGWoqHeQ7L5W6LtCSpoyzSFunGOfOW4mGeFZpFumGGWoqHeQ7LM2mLdHCGWoqHeW6WRdoi3bghDiopVuY5LCdBFunGuTwmxcM8t2uIkySLdGCGWoqHeW6Wy90W6cYNcVBJsTLPYTkJskg3zuUxKR7muV1DnCRZpBtmqKV4mOewXO62SEuSOspJkEW6cc68pXiY53YN8Ux6S52DkjTbBtwP3ArsAJ4B7i2L/JFVjr8C+AzwXmBbdfxvlUX+rZm/go4z1Ooa8zw98xyWy931z6QfBG4GbgLmgS8D+5M0e9sqx38NuAJ4R3X7GPBwkmZXzbDtvWSo1QHmeUbMc7Ms0jWKdJJmO4HbgU+URX6gLPJXyiJ/AHgWuHOF48/NzO8ui3xUFvlr1Sz8YuD6xl5JRw1xUKm7zPPmmOewnATVW+6+rjruyYn9T6wU0rLIXwQ+NrH7LdXtofV+2dHDIxZPL655zMLCKcajdZ+qE144ckF1snLWwqkTjEdHWm3TRvWpv2NQt7/n90x1Ihssz7FlGeDkyXnggte3jx8dMx6dbLVNG9WnPj92+Pxq8eashYUFxqMft9qmjarT32tluU6R3l3dTlaWMbBnvQdXM/EvAPvLIv/Oesfv3LXuUzIeHZr2D1Rwl+5cvn3B1q29afs5fervGDTc38HyHFuWAd70puXbl83PM7/+y+yUPvX5sZeWb5933pbetP2czfb3Zq7ungPWXPxJ0mwv8Hj1B+BDm/hdveXymHrCPNdgnsNyubtekR5Vt7sm9u9ect8bJGn2zmoJ7XHgvWWRv7TasTHzalB1jHneBPPcriFOkuosdz8FnARuAL66ZP+NwMMrPSBJs2uArwOfKov8c7Nrbv8YanWMed4E8xyWV3fXKNJlkR9P0uwhYF+SZgeAg8A9wN7qoxwkabYPuLos8tuSNDsf+CLw4NADLXWNeVafOAmq+WUmwN3Vxy4eBbYDTwO3lEV+sLr/yirkVDP064BrkjT7+MTzfKks8jtm2P7Oc+atDjLPUzLP7RrimfTcme696nUb1KerE7/+dXjf+366fcst8I1vtNmijetTf8dgA/3d9RIRVZYBfuEX4MklH177znfgXe9qs0Ub16c+/8EP4C1v+en23r3w3HNttmjjavb3qln2u7sDc+YtxcM8N8v3pC3SjRvioJJiZZ4VmkW6Yb6HJcXDPIflmbRFOjhDLcXDPDfLIm2RbtwQB5UUK/MclpMgi3TjXB6T4mGe2zXESZJFumGGWoqHeQ7L5W6LdHCGWoqHeW6W/WuRbtwQZ35SrMxzu4bY/xbphrk8JsXDPIflcrdFOjhDLcXDPDfL/rVIN26IMz8pVua5XUPsf4t0w1wek+JhnsNyudsiHZyhluJhnptlkbZIN26Ig0qKlXlWaBbphrk8JsXDPIflmbRFunGGWoqHeQ7LIm2RDs5QS/Ewz82yfy3SjRvizE+KlXlu1xD73yLdMJfHpHiY57Bc7rZIB2eopXiY52bZvxbpxg1x5ifFyjy3a4j9b5Fu2OLi8m1nhlJ/meewzpuoUJP9PwQW6Ya99try7W3b2mqJpM0yz2FdeOHy7Z/8pK2WtMci3bBXXlm+ffHFbbVE0maZ57C2bl1+Nn3q1NmfIbFIN+zVV5dvX3RRWy2RtFnmOay5uTf28dDOpi3SDTPUUhxOn4YTJ366PTf3xuVYzd7k38zJ1YzYWaQb5vKYFIeVJtxeONa8yb+Zk/8dYrelzkFJmm0D7gduBXYAzwD3lkX+yCyOj5ln0uoa8zwds9yOoZ9J1yrSwIPADcBNwEHgTmB/kmbXlkX+/Rkcv66FBTh69Oy/j4zPY7EnawDPPbd822CrA1rP8/HjZ5eOzbLWM9nPzz0He/bUf3zbqx1Hxudx/la47LLpHr9ukU7SbCdwO/DBssgPVLsfSNLstiqs92zm+LqefRauvfbc1gb+C3WMy91qU1fy/OEPw9e+hlnWuib7+QMfaKsl09rD9dfDt7893aPrzGGvq4r5kxP7nwCun8Hxg2Kw1TLzPCNmOYyh93Od5e7d1e2Rif3jVabBGz1+maOHRyyefuPXyhwbb1ny1P20ZcsZ3vr3nmc86tfX5iwsnGI8OtR2Mwajbn/P77lqmqcPlufVsgxw8rXLgH5/E8g/ue5lxqMX227GhvUtz9e94xL279/RdjM2ZeHUScaj8ar3r5Xluu9Jr2QO2Mg3qdY6fueulXM/fxR27Tr77zOLp5k77/wN/Or2vfWt8OlPz/Fz1/RveW88OjRtQdAUWurvmed5tSwD7LribJ77mOVt2+D974c/+INLuPDCS9puzob1Lc+/83uwsAhf+Qq89NLGHtuF7/o+s3ia+V0XTN3ndYr0qLrdBfxwyf7dS+7bzPG1/PzPw49/fPbf49HzvRpkUod0Is9f/OLZW7Os9WzZAvfdd/anjzY7xuu8J/0UcLK6unOpG4HHZ3C8pHDMs9Qj655Jl0V+PEmzh4B9SZodqD6CcQ+wt/poBkma7QOuLov8tjrHS2qHeZb6pe4nFO8GHgYeBQ4D7wVuKYv8YHX/lVVo6x4vqT3mWeqJuTNdeGd9uXUb1LcLH/rO/g5rA/3d9S+lNMsdZJ+HVbO/V81yT77rR5Kk4bFIS5LUURZpSZI6qovvSUuSJM+kJUnqLou0JEkdZZGWJKmjLNKSJHWURVqSpI6ySEuS1FEWaUmSOqrO/0+6k5I0uwL4TPVl/9uAZ4DfKov8W223LQZJmm0D7gduBXZU/XtvWeSPtN22GA15PA/5tYdinsOa5Zju85n014ArgHdUt48BDydp5jfHz8aDwM3ATcA88GVgf5Jmb2u7YZEa8nge8msPxTyHNbMx3csinaTZuZng3WWRj8oif62atVwMXN92+/ouSbOdwO3AJ8oiP1AW+StlkT8APAvc2Xb7YjPk8Tzk1x6KeQ5r1mO6l8vdZZG/CHxsYvdbqttDLTQpNtdVY+PJif1P+Idz9oY8nof82gMyzwHNekx3skgnabYFuGS1+8sif2Hi+B3AF4D9ZZF/J0gj47a7uj0ysX8M7GmhPYMS03g2y51gnlu02THd1eXu9wDHVvtJ0uzCcwcmabYXeLwacB9qt9nRmwP8P7I0KMLxbJa7yzw3bBZjupNn0mWRf7MaQGtK0uydwMNADvxGWeSnwrQweqPqdhfwwyX7dy+5TzMW43g2y51gnlswqzHdySJdR5Jm1wBfBz5VFvnn2m5PZJ4CTgI3AF9dsv/GatBpxoY8nof82gMxz4HNckz38v8nnaTZ+dVFD0VZ5L/ddntilKTZg8AtwAeAg8A9wMeBf1gW+cG22xeTIY/nIb/2kMxzOLMe030t0r8E/Gk1O5x8AV8qi/yOlpoWjSTNtlYfG/gVYDvwNHBPWeR/1nbbYjPk8Tzk1x6SeQ5n1mO6l0VakqQh6OrV3ZIkDZ5FWpKkjrJIS5LUURZpSZI6yiItSVJHWaQlSeooi7QkSR1lkZYkqaP+PzuObMl9DAoRAAAAAElFTkSuQmCC\n",
+            "text/plain": [
+              "<Figure size 576x288 with 2 Axes>"
+            ]
+          },
+          "metadata": {
+            "bento_obj_id": "140352605384656",
+            "needs_background": "light"
+          },
+          "output_type": "display_data"
+        }
+      ],
+      "source": [
+        "x = torch.linspace(-2, 2, 500, **tkwargs)\n",
+        "\n",
+        "fig, ax = plt.subplots(1, 2, figsize=(8, 4))\n",
+        "ax[0].plot(x.cpu(), smooth_mask(x, -1).cpu(), \"b\")\n",
+        "ax[1].plot(x.cpu(), smooth_box_mask(x, -1, 1).cpu(), \"b\")\n",
+        "plt.show()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "code_folding": [],
+        "hidden_ranges": [],
+        "originalKey": "7ff5ed82-355b-45b8-91f9-823c41c46efc",
+        "showInput": false
+      },
+      "source": [
+        "## Implementation of ECI\n",
+        "\n",
+        "Once we have defined our smooth mask functions, we can compute a differentiable approximation of ECI in a straightforward manner using Monte Carlo (MC). We use the popular variance reduction technique of Common random numbers (CRN).\n",
+        "\n",
+        "We first use a low discrepancy sequence to generate a set of base samples. We integrate (sum) over these base samples to approximate the ECI acquisition function. Fixing these base samples makes the method deterministic and by using the smooth masks defined earlier, we can filter out infeasible points while still having a differentiable acquisition function.\n",
+        "\n",
+        "This implementation assumes that the GP models for the different outputs are independent and that each constraints only affects one output (simple box-constraints like f(x) <= 0.5)."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 5,
+      "metadata": {
+        "code_folding": [],
+        "executionStartTime": 1638489233910,
+        "executionStopTime": 1638489233950,
+        "hidden_ranges": [],
+        "originalKey": "83bc1247-7bfb-4bfc-a571-76f7daef1d94",
+        "requestMsgId": "5dd0a6af-0bde-4e57-8bdd-d53baea75075"
+      },
+      "outputs": [],
+      "source": [
+        "def identify_samples_which_satisfy_constraints(X, constraints):\n",
+        "    \"\"\"\n",
+        "    Takes in values (a1, ..., ak, o) and returns (a1, ..., ak, o)\n",
+        "    True/False values, where o is the number of outputs.\n",
+        "    \"\"\"\n",
+        "    successful = torch.ones(X.shape).to(X)\n",
+        "    for model_index in range(X.shape[-1]):\n",
+        "        these_X = X[..., model_index]\n",
+        "        direction, value = constraints[model_index]\n",
+        "        successful[..., model_index] = (\n",
+        "            these_X < value if direction == \"lt\" else these_X > value\n",
+        "        )\n",
+        "    return successful\n",
+        "\n",
+        "\n",
+        "class ExpectedCoverageImprovement(MCAcquisitionFunction):\n",
+        "    def __init__(\n",
+        "        self,\n",
+        "        model,\n",
+        "        constraints,\n",
+        "        punchout_radius,\n",
+        "        bounds,\n",
+        "        num_samples=512,\n",
+        "        **kwargs,\n",
+        "    ):\n",
+        "        \"\"\"Expected Coverage Improvement (q=1 required, analytic)\n",
+        "\n",
+        "        Right now, we assume that all the models in the ModelListGP have\n",
+        "        the same training inputs.\n",
+        "\n",
+        "        Args:\n",
+        "            model: A ModelListGP object containing models matching the corresponding constraints.\n",
+        "                All models are assumed to have the same training data.\n",
+        "            constraints: List containing 2-tuples with (direction, value), e.g.,\n",
+        "                [('gt', 3), ('lt', 4)]. It is necessary that\n",
+        "                len(constraints) == model.num_outputs.\n",
+        "            punchout_radius: Positive value defining the desired minimum distance between points\n",
+        "            bounds: torch.tensor whose first row is the lower bounds and second row is the upper bounds\n",
+        "            num_samples: Number of samples for MC integration\n",
+        "        \"\"\"\n",
+        "        super().__init__(model=model, objective=IdentityMCObjective(), **kwargs)\n",
+        "        assert len(constraints) == model.num_outputs\n",
+        "        assert all(direction in (\"gt\", \"lt\") for direction, _ in constraints)\n",
+        "        assert punchout_radius > 0\n",
+        "        self.constraints = constraints\n",
+        "        self.punchout_radius = punchout_radius\n",
+        "        self.bounds = bounds\n",
+        "        self.base_points = self._identify_base_points_from_train_inputs()\n",
+        "        self.ball_of_points = self._generate_ball_of_points(\n",
+        "            num_samples=num_samples,\n",
+        "            radius=punchout_radius,\n",
+        "            device=bounds.device,\n",
+        "            dtype=bounds.dtype,\n",
+        "        )\n",
+        "        self._thresholds = torch.tensor(\n",
+        "            [threshold for _, threshold in self.constraints]\n",
+        "        ).to(bounds)\n",
+        "        assert (\n",
+        "            all(ub > lb for lb, ub in self.bounds.T) and len(self.bounds.T) == self.dim\n",
+        "        )\n",
+        "\n",
+        "    @property\n",
+        "    def num_outputs(self):\n",
+        "        return self.model.num_outputs\n",
+        "\n",
+        "    @property\n",
+        "    def dim(self):\n",
+        "        return self.train_inputs.shape[-1]\n",
+        "\n",
+        "    @property\n",
+        "    def train_inputs(self):\n",
+        "        return self.model.models[0].train_inputs[0]\n",
+        "\n",
+        "    def _identify_base_points_from_train_inputs(self):\n",
+        "        train_targets = [t.unsqueeze(-1) for t in self.model.train_targets]\n",
+        "        untransformed_train_targets = (\n",
+        "            [  # Untransform a potential outcome transform to get raw values\n",
+        "                m.outcome_transform.untransform(t)[0]\n",
+        "                for t, m in zip(train_targets, self.model.models)\n",
+        "                if m.outcome_transform\n",
+        "            ]\n",
+        "        )\n",
+        "        untransformed_train_targets = torch.cat(untransformed_train_targets, dim=-1)\n",
+        "        satisfy_constraints = self._identify_samples_which_satisfy_constraints(\n",
+        "            untransformed_train_targets\n",
+        "        )\n",
+        "        return self.train_inputs[satisfy_constraints.all(axis=-1)]\n",
+        "\n",
+        "    def _generate_ball_of_points(\n",
+        "        self, num_samples, radius, device=None, dtype=torch.double\n",
+        "    ):\n",
+        "        \"\"\"Creates a ball of points to be used for MC.\"\"\"\n",
+        "        tkwargs = {\"device\": device, \"dtype\": dtype}\n",
+        "        z = sample_hypersphere(d=self.dim, n=num_samples, qmc=True, **tkwargs)\n",
+        "        r = torch.rand(num_samples, 1, **tkwargs) ** (1 / self.dim)\n",
+        "        return radius * r * z\n",
+        "\n",
+        "    def _identify_samples_which_satisfy_constraints(self, X):\n",
+        "        return identify_samples_which_satisfy_constraints(X, self.constraints)\n",
+        "\n",
+        "    def _get_base_point_mask(self, X):\n",
+        "        distance_matrix = self.model.models[0].covar_module.base_kernel.covar_dist(\n",
+        "            X, self.base_points\n",
+        "        )\n",
+        "        return smooth_mask(distance_matrix, self.punchout_radius)\n",
+        "\n",
+        "    def _estimate_probabilities_of_satisfaction_at_points(self, points):\n",
+        "        \"\"\"Estimate the probability of satisfying the given constraints.\"\"\"\n",
+        "        posterior = self.model.posterior(X=points)\n",
+        "        mus, sigma2s = posterior.mean, posterior.variance\n",
+        "        dist = torch.distributions.normal.Normal(mus, sigma2s.sqrt())\n",
+        "        norm_cdf = dist.cdf(self._thresholds)\n",
+        "        probs = torch.ones(points.shape[:-1]).to(points)\n",
+        "        for i, (direction, _) in enumerate(self.constraints):\n",
+        "            probs = probs * (\n",
+        "                norm_cdf[..., i] if direction == \"lt\" else 1 - norm_cdf[..., i]\n",
+        "            )\n",
+        "        return probs\n",
+        "\n",
+        "    @t_batch_mode_transform(expected_q=1)\n",
+        "    def forward(self, X):\n",
+        "        \"\"\"Evaluate Expected Improvement on the candidate set X.\"\"\"\n",
+        "        ball_around_X = self.ball_of_points + X\n",
+        "        domain_mask = smooth_box_mask(\n",
+        "            ball_around_X, self.bounds[0, :], self.bounds[1, :]\n",
+        "        ).prod(dim=-1)\n",
+        "        num_points_in_integral = domain_mask.sum(dim=-1)\n",
+        "        base_point_mask = self._get_base_point_mask(ball_around_X).prod(dim=-1)\n",
+        "        prob = self._estimate_probabilities_of_satisfaction_at_points(ball_around_X)\n",
+        "        masked_prob = prob * domain_mask * base_point_mask\n",
+        "        y = masked_prob.sum(dim=-1) / num_points_in_integral\n",
+        "        return y"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 6,
+      "metadata": {
+        "code_folding": [],
+        "executionStartTime": 1638489234035,
+        "executionStopTime": 1638489234089,
+        "hidden_ranges": [],
+        "originalKey": "28d1ba39-4c20-47da-9dd5-4b40fcc70726",
+        "requestMsgId": "b56e4297-9927-4a5e-aa8f-f5e93181e44d"
+      },
+      "outputs": [],
+      "source": [
+        "def get_and_fit_gp(X, Y):\n",
+        "    \"\"\"Simple method for creating a GP with one output dimension.\n",
+        "\n",
+        "    X is assumed to be in [0, 1]^d.\n",
+        "    \"\"\"\n",
+        "    assert Y.ndim == 2 and Y.shape[-1] == 1\n",
+        "    likelihood = GaussianLikelihood(noise_constraint=Interval(1e-6, 1e-3))  # Noise-free\n",
+        "    octf = Standardize(m=Y.shape[-1])\n",
+        "    gp = SingleTaskGP(X, Y, likelihood=likelihood, outcome_transform=octf)\n",
+        "    mll = ExactMarginalLogLikelihood(gp.likelihood, gp)\n",
+        "    fit_gpytorch_model(mll)\n",
+        "    return gp"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "code_folding": [],
+        "hidden_ranges": [],
+        "originalKey": "e7c7c1b3-249f-4e32-b8b7-3c7e737e82b2",
+        "showInput": false
+      },
+      "source": [
+        "### Simple 1D function\n",
+        "\n",
+        "To sanity check things, we consider the ECI acquisition function on a one-dimensional toy problem. "
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 7,
+      "metadata": {
+        "executionStartTime": 1638489234145,
+        "executionStopTime": 1638489234200,
+        "originalKey": "5526f64f-f1c7-4575-bc04-088dee87fe55",
+        "requestMsgId": "cc435c3c-c65f-4446-a33e-fd5cda030962"
+      },
+      "outputs": [],
+      "source": [
+        "def yf(x):\n",
+        "    return (1 - torch.exp(-4 * (x[:, 0] - 0.4) ** 2)).unsqueeze(-1)\n",
+        "\n",
+        "\n",
+        "x = torch.tensor([0, 0.15, 0.25, 0.4, 0.8, 1.0], **tkwargs).unsqueeze(-1)\n",
+        "y = yf(x)\n",
+        "xx = torch.linspace(0, 1, 200, **tkwargs).unsqueeze(-1)\n",
+        "yy = yf(xx)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "originalKey": "8bbfe7b8-b758-424a-b6bc-f2c91f8b1e95",
+        "showInput": false
+      },
+      "source": [
+        "### Create an ECI acquisition function\n",
+        "Our implementation assumes that the GP is passed in as a `ModelListGP` and that the GPs match the corresponding constraints. As an example, assume we have two outputs, represented by `gp1` and `gp2` and two constraints corresponding to output 1 and a third constraint corresponding to output 2. In that case we will create a model list GP as `ModelListGP(gp1, gp1, gp2)` so they match the constraints."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 8,
+      "metadata": {
+        "code_folding": [],
+        "executionStartTime": 1638489234253,
+        "executionStopTime": 1638489235584,
+        "hidden_ranges": [],
+        "originalKey": "c8950892-86cb-4112-8804-8a632bd6fe34",
+        "requestMsgId": "9efe991c-8256-4c7c-b61f-8abb5d258d40"
+      },
+      "outputs": [],
+      "source": [
+        "gp = get_and_fit_gp(x, y)\n",
+        "model_list_gp = ModelListGP(gp, gp)\n",
+        "constraints = [(\"lt\", 0.3), (\"gt\", 0.05)]\n",
+        "punchout_radius = 0.03\n",
+        "bounds = torch.tensor([(0, 1)], **tkwargs).T\n",
+        "eci = ExpectedCoverageImprovement(\n",
+        "    model=model_list_gp,\n",
+        "    constraints=constraints,\n",
+        "    punchout_radius=punchout_radius,\n",
+        "    bounds=bounds,\n",
+        "    num_samples=512 if not SMOKE_TEST else 4,\n",
+        ")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "originalKey": "f1cfa2a0-db3f-49a2-b32f-6fad380b0c3e",
+        "showInput": false
+      },
+      "source": [
+        "### Optimize the acquisition function"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 9,
+      "metadata": {
+        "code_folding": [],
+        "executionStartTime": 1638489235787,
+        "executionStopTime": 1638489236864,
+        "hidden_ranges": [],
+        "originalKey": "720fab8b-ade0-4a7e-b95a-08420c1462eb",
+        "requestMsgId": "1ae10691-8d4e-40e7-8c32-f15a35ddf590",
+        "showInput": true
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Best candidate: 0.617\n"
+          ]
+        }
+      ],
+      "source": [
+        "best_candidate, best_eci_value = optimize_acqf(\n",
+        "    acq_function=eci,\n",
+        "    bounds=torch.tensor([[0.0], [1.0]], **tkwargs),\n",
+        "    q=1,\n",
+        "    num_restarts=10,\n",
+        "    raw_samples=20,  # use a small number here to make sure the optimization works\n",
+        ")\n",
+        "print(f\"Best candidate: {best_candidate.cpu().item():.3f}\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "originalKey": "15a4d7cf-be03-4e52-9792-e3a680f37bb7",
+        "showInput": false
+      },
+      "source": [
+        "### Plot the GP and the ECI acquisition function\n",
+        "The left plot shows the GP posterior with a 95% confidence interval. The two horizontal lines indicate the feasible region defined by $0.05 \\leq f(x) \\leq 0.3$. These inequality constraints implicitly define a feasible region, outside which ECI has value zero. \n",
+        "\n",
+        "We can see in the right plot that ECI indeed has a nonzero value inside the feasible region and a zero value outside. We also optimize the acquisition function and mark its argmax with black star; the argmax is around $x=0.62$. This is reasonable because ECI seeks to select diverse points within the feasible region. $x=0.62$ is far away from other evaluations and thus has the highest diversity. "
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 10,
+      "metadata": {
+        "code_folding": [],
+        "executionStartTime": 1638489236964,
+        "executionStopTime": 1638489237535,
+        "hidden_ranges": [],
+        "originalKey": "798c3132-bee6-454d-9e8f-6250419f2430",
+        "requestMsgId": "5f5b4b6a-4d53-4528-8420-53e4f9358f5c"
+      },
+      "outputs": [
+        {
+          "data": {
+            "image/png": "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\n",
+            "text/plain": [
+              "<Figure size 864x360 with 2 Axes>"
+            ]
+          },
+          "metadata": {
+            "bento_obj_id": "140352575545152",
+            "needs_background": "light"
+          },
+          "output_type": "display_data"
+        }
+      ],
+      "source": [
+        "with torch.no_grad():\n",
+        "    posterior = gp.posterior(X=xx.unsqueeze(1))\n",
+        "ymean, yvar = posterior.mean.squeeze(-1), posterior.variance.squeeze(-1)\n",
+        "eci_vals = eci(xx.unsqueeze(1))\n",
+        "\n",
+        "fig, axes = plt.subplots(1, 2, figsize=(12, 5))\n",
+        "ax = axes[0]\n",
+        "ax.plot(xx[:, 0].cpu(), ymean[:, 0].cpu(), \"b\")\n",
+        "ax.fill_between(\n",
+        "    xx[:, 0].cpu(), \n",
+        "    ymean[:, 0].cpu() - 1.96 * yvar[:, 0].sqrt().cpu(), \n",
+        "    ymean[:, 0].cpu() + 1.96 * yvar[:, 0].sqrt().cpu(), \n",
+        "    alpha=0.1, \n",
+        "    color=\"b\"\n",
+        ")\n",
+        "ax.plot(x[:, 0].cpu(), y[:, 0].cpu(), \"or\")\n",
+        "ax.axhline(0.05, 0, 1)\n",
+        "ax.axhline(0.3, 0, 1)\n",
+        "\n",
+        "ax = axes[1]\n",
+        "ax.plot(xx[:, 0].cpu(), eci_vals.detach().cpu())\n",
+        "ax.plot(x[:, 0].cpu(), torch.zeros(len(x), **tkwargs).cpu(), \"or\")\n",
+        "ax.plot(best_candidate.cpu(), best_eci_value.cpu(), \"*k\", ms=10)\n",
+        "ax.set_title(\"ECI\", fontsize=14)\n",
+        "plt.show()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "code_folding": [],
+        "hidden_ranges": [],
+        "originalKey": "33ea647e-bdaf-4264-ab65-3e6df4ba8c6e",
+        "showInput": false
+      },
+      "source": [
+        "## Full 2D CAS-loop \n",
+        "This creates a simple function with two outputs that we will consider under the two constraints $f_1(x) \\leq 0.75$ and $f_2(x) \\geq 0.55$. In this particular example, the $f_1(x)$ and $f_2(x)$ are same function for simplicity. \n",
+        "\n",
+        "The CAS loop follows the prototypical BO loop: \n",
+        "1. Given a surrogate model, maximize ECI to select the next evaluation x.\n",
+        "2. Observe f(x).\n",
+        "3. Update the surrogate model. "
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 11,
+      "metadata": {
+        "code_folding": [],
+        "executionStartTime": 1638489237543,
+        "executionStopTime": 1638489237685,
+        "hidden_ranges": [],
+        "originalKey": "e284a5bf-4b0d-40a0-8b37-765227dd9ff0",
+        "requestMsgId": "691460ed-a2c8-45b5-8dc9-c6d8c87ee9d7"
+      },
+      "outputs": [],
+      "source": [
+        "def yf2d(x):\n",
+        "    v = torch.exp(-2 * (x[:, 0] - 0.3) ** 2 - 4 * (x[:, 1] - 0.6) ** 2)\n",
+        "    return torch.stack((v, v), dim=-1)\n",
+        "\n",
+        "\n",
+        "bounds = torch.tensor([[0, 0], [1, 1]], **tkwargs)\n",
+        "lb, ub = bounds\n",
+        "dim = len(lb)\n",
+        "constraints = [(\"lt\", 0.75), (\"gt\", 0.55)]\n",
+        "punchout_radius = 0.1"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "originalKey": "6f354b25-8703-4156-908d-d53c1c2bbe4a",
+        "showInput": false
+      },
+      "source": [
+        "### CAS loop using 5 initial Sobol points and 15 ECI iterations"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 12,
+      "metadata": {
+        "code_folding": [],
+        "executionStartTime": 1638489237803,
+        "executionStopTime": 1638489266352,
+        "hidden_ranges": [],
+        "originalKey": "69c4c7ee-2be2-4bb4-9072-83a30a3d7ecc",
+        "requestMsgId": "6d77353b-8dda-4835-9c6a-b0a53fddc67c"
+      },
+      "outputs": [],
+      "source": [
+        "num_init_points = 5\n",
+        "num_total_points = 20 if not SMOKE_TEST else 6\n",
+        "\n",
+        "X = lb + (ub - lb) * SobolEngine(dim, scramble=True).draw(num_init_points).to(**tkwargs)\n",
+        "Y = yf2d(X)\n",
+        "\n",
+        "while len(X) < num_total_points:\n",
+        "    # We don't have to normalize X since the domain is [0, 1]^2. Make sure to\n",
+        "    # appropriately adjust the punchout radius if the domain is normalized.\n",
+        "    gp_models = [get_and_fit_gp(X, Y[:, i : i + 1]) for i in range(Y.shape[-1])]\n",
+        "    model_list_gp = ModelListGP(gp_models[0], gp_models[1])\n",
+        "    eci = ExpectedCoverageImprovement(\n",
+        "        model=model_list_gp,\n",
+        "        constraints=constraints,\n",
+        "        punchout_radius=punchout_radius,\n",
+        "        bounds=bounds,\n",
+        "        num_samples=512 if not SMOKE_TEST else 4,\n",
+        "    )\n",
+        "    x_next, _ = optimize_acqf(\n",
+        "        acq_function=eci,\n",
+        "        bounds=bounds,\n",
+        "        q=1,\n",
+        "        num_restarts=10 if not SMOKE_TEST else 2,\n",
+        "        raw_samples=512 if not SMOKE_TEST else 4,\n",
+        "    )\n",
+        "    y_next = yf2d(x_next)\n",
+        "    X = torch.cat((X, x_next))\n",
+        "    Y = torch.cat((Y, y_next))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "code_folding": [],
+        "hidden_ranges": [],
+        "originalKey": "255bba4f-4d9a-46cc-aa66-16b90287824a",
+        "showInput": false
+      },
+      "source": [
+        "### Plot the selected points\n",
+        "We plot the feasible region and the points selected by ECI below. The feasible region is outlined with a black ring, and points selected by ECI are marked in green (feasible) and red (infeasible). By design, observe that ECI selects a diverse i.e., well-spaced set of points inside the feasible region. "
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 13,
+      "metadata": {
+        "code_folding": [],
+        "customInput": null,
+        "executionStartTime": 1638489266464,
+        "executionStopTime": 1638489266516,
+        "hidden_ranges": [],
+        "originalKey": "7fa98ec0-a63f-4b77-bbbc-12a7c54d81d0",
+        "requestMsgId": "6b62af84-01c0-4971-9122-bd5f01b9f31b",
+        "showInput": true
+      },
+      "outputs": [],
+      "source": [
+        "N1, N2 = 50, 50\n",
+        "Xplt, Yplt = torch.meshgrid(\n",
+        "    torch.linspace(0, 1, N1, **tkwargs), torch.linspace(0, 1, N2, **tkwargs)\n",
+        ")\n",
+        "xplt = torch.stack(\n",
+        "    (\n",
+        "        torch.reshape(Xplt, (Xplt.shape[0] * Xplt.shape[1],)),\n",
+        "        torch.reshape(Yplt, (Yplt.shape[0] * Yplt.shape[1],)),\n",
+        "    ),\n",
+        "    dim=1,\n",
+        ")\n",
+        "yplt = yf2d(xplt)\n",
+        "Zplt = torch.reshape(yplt[:, 0], (N1, N2))  # Since f1(x) = f2(x)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 14,
+      "metadata": {
+        "code_folding": [],
+        "executionStartTime": 1638489266564,
+        "executionStopTime": 1638489267143,
+        "hidden_ranges": [],
+        "originalKey": "49cb15f1-3dea-4e9b-b452-3c13c26d6f8d",
+        "requestMsgId": "a44c258c-0373-4c68-9887-9ae7a57bcccc"
+      },
+      "outputs": [
+        {
+          "data": {
+            "image/png": "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\n",
+            "text/plain": [
+              "<Figure size 576x432 with 2 Axes>"
+            ]
+          },
+          "metadata": {
+            "bento_obj_id": "140352575637488",
+            "needs_background": "light"
+          },
+          "output_type": "display_data"
+        }
+      ],
+      "source": [
+        "fig, ax = plt.subplots(figsize=(8, 6))\n",
+        "h1 = ax.contourf(Xplt.cpu(), Yplt.cpu(), Zplt.cpu(), 20, cmap=\"Blues\", alpha=0.6)\n",
+        "fig.colorbar(h1)\n",
+        "ax.contour(Xplt.cpu(), Yplt.cpu(), Zplt.cpu(), [0.55, 0.75], colors=\"k\")\n",
+        "\n",
+        "feasible_inds = (\n",
+        "    identify_samples_which_satisfy_constraints(Y, constraints)\n",
+        "    .prod(dim=-1)\n",
+        "    .to(torch.bool)\n",
+        ")\n",
+        "ax.plot(X[feasible_inds, 0].cpu(), X[feasible_inds, 1].cpu(), \"sg\", label=\"Feasible\")\n",
+        "ax.plot(\n",
+        "    X[~feasible_inds, 0].cpu(), X[~feasible_inds, 1].cpu(), \"sr\", label=\"Infeasible\"\n",
+        ")\n",
+        "\n",
+        "ax.legend(loc=[0.7, 0.05])\n",
+        "ax.set_title(\"$f_1(x)$\")  # Recall that f1(x) = f2(x)\n",
+        "ax.set_xlabel(\"$x_1$\")\n",
+        "ax.set_ylabel(\"$x_2$\")\n",
+        "ax.set_aspect(\"equal\", \"box\")\n",
+        "ax.set_xlim([-0.05, 1.05])\n",
+        "ax.set_ylim([-0.05, 1.05])\n",
+        "plt.show()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 14,
+      "metadata": {
+        "executionStartTime": 1638489267152,
+        "executionStopTime": 1638489267253,
+        "originalKey": "221f9786-a351-41be-897f-4577da569178",
+        "requestMsgId": "0ff4a95d-b556-4a21-b794-184ba4181a49"
+      },
+      "outputs": [],
+      "source": []
+    }
+  ],
+  "metadata": {
+    "kernelspec": {
+      "display_name": "python3",
+      "language": "python",
+      "name": "python3"
+    },
+    "last_base_url": "https://0282.od.fbinfra.net/",
+    "last_kernel_id": "f0259543-6954-48ef-bf3e-f0b2635fdbec",
+    "last_msg_id": "6ae219b2-bbc621e514740d948f47fa15_79",
+    "last_server_session_id": "e032338a-d916-4be6-a767-bbbe86b9adee",
+    "outputWidgetContext": {}
+  },
+  "nbformat": 4,
+  "nbformat_minor": 4
+}
diff --git a/website/tutorials.json b/website/tutorials.json
index 415aa2b3f9..37535a7059 100644
--- a/website/tutorials.json
+++ b/website/tutorials.json
@@ -81,6 +81,10 @@
     {
       "id": "risk_averse_bo_with_input_perturbations",
       "title": "Risk averse Bayesian optimization with input perturbations"
+    },
+    {
+      "id": "constraint_active_search",
+      "title": "Constraint Active Search for Multiobjective Experimental Design"
     }
   ],
   "Advanced Usage": [
@@ -104,7 +108,7 @@
       "id": "composite_bo_with_hogp",
       "title": "Composite Bayesian optimization with the High Order Gaussian Process"
     },
-    {      
+    {
       "id": "composite_mtbo",
       "title": "Composite Bayesian Optimization with Multi-Task Gaussian Processes"
     }