Merge: Refactor ACQF indicators (#479)

Fixes #467 and #458 

BayBE acquisition functions have been refactored
- Removed `is_mc`
- Added `supports_batching` and `supports_pending_experiments`
indicators
- Changed tests using these properties + some changes to have more
readable output
- Fixed bug with `PSTD` where the direction was negated depending on
target type. However, for `PSTD` the direction is set by the user and
means to change whether points with large or small std are returned - ie
it is fully independent of the target type. So it needs to be exempt
from the overwriting of the `maximize` setting that is done for other
analytical acqfs
- Enabled the new `qPSTD` function which requires a higher botorch
version, conveniently also including the upgrade to support higher scipy
versions, version pins have been adjusted accordingly.

Author: Scienfitz

.lockfiles/py310-dev.lock

@@ -53,7 +53,7 @@ botocore==1.35.68
     # via
     #   boto3
     #   s3transfer
-botorch==0.11.3
+botorch==0.13.0
     # via baybe (pyproject.toml)
 cachecontrol==0.14.0
     # via pip-audit
@@ -196,7 +196,7 @@ googleapis-common-protos==1.63.2
     # via
     #   opentelemetry-exporter-otlp-proto-grpc
     #   opentelemetry-exporter-otlp-proto-http
-gpytorch==1.12
+gpytorch==1.14
     # via
     #   baybe (pyproject.toml)
     #   botorch
@@ -259,7 +259,9 @@ ipywidgets==8.1.3
 isoduration==20.11.0
     # via jsonschema
 jaxtyping==0.2.33
-    # via linear-operator
+    # via
+    #   gpytorch
+    #   linear-operator
 jedi==0.19.1
     # via ipython
 jinja2==3.1.4
@@ -354,7 +356,7 @@ lifelines==0.29.0
     # via ngboost
 lime==0.2.0.1
     # via shap
-linear-operator==0.5.2
+linear-operator==0.6
     # via
     #   botorch
     #   gpytorch
@@ -401,8 +403,8 @@ mordredcommunity==2.0.6
     # via scikit-fingerprints
 mpmath==1.3.0
     # via
-    #   botorch
     #   gpytorch
+    #   linear-operator
     #   sympy
 msgpack==1.0.8
     # via cachecontrol
@@ -411,7 +413,9 @@ multipledispatch==1.0.0
 mypy==1.11.0
     # via baybe (pyproject.toml)
 mypy-extensions==1.0.0
-    # via mypy
+    # via
+    #   mypy
+    #   typing-inspect
 myst-parser==4.0.0
     # via baybe (pyproject.toml)
 nbclient==0.10.0
@@ -452,7 +456,6 @@ numpy==1.26.4
     #   baybe (pyproject.toml)
     #   altair
     #   autograd
-    #   botorch
     #   contourpy
     #   descriptastorus
     #   e3fp
@@ -716,6 +719,8 @@ pyparsing==3.1.2
     #   pip-requirements-parser
 pyproject-api==1.7.1
     # via tox
+pyre-extensions==0.0.32
+    # via botorch
 pyreadline3==3.4.1 ; sys_platform == 'win32'
     # via humanfriendly
 pyro-api==0.1.2
@@ -934,7 +939,9 @@ terminado==0.18.1
     #   jupyter-server
     #   jupyter-server-terminals
 threadpoolctl==3.5.0
-    # via scikit-learn
+    # via
+    #   botorch
+    #   scikit-learn
 tifffile==2024.12.12
     # via scikit-image
 tinycss2==1.3.0
@@ -1010,9 +1017,7 @@ traitlets==5.14.3
 triton==2.3.1 ; python_full_version < '3.12' and platform_machine == 'x86_64' and sys_platform == 'linux'
     # via torch
 typeguard==2.13.3
-    # via
-    #   jaxtyping
-    #   linear-operator
+    # via jaxtyping
 types-python-dateutil==2.9.0.20240316
     # via arrow
 types-pytz==2024.1.0.20240417
@@ -1025,15 +1030,20 @@ typing-extensions==4.12.2
     #   altair
     #   anyio
     #   async-lru
+    #   botorch
     #   cattrs
     #   formulaic
     #   funcy-stubs
     #   huggingface-hub
     #   ipython
     #   mypy
     #   opentelemetry-sdk
+    #   pyre-extensions
     #   streamlit
     #   torch
+    #   typing-inspect
+typing-inspect==0.9.0
+    # via pyre-extensions
 tzdata==2024.1
     # via pandas
 uri-template==1.3.0

CHANGELOG.md

@@ -8,6 +8,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Added
 - `BCUT2D` encoding for `SubstanceParameter`
 - Stored benchmarking results now include the Python environment and version
+- `qPSTD` acquisition function
+
+### Changed
+- Acquisition function indicator `is_mc` has been removed in favor of new indicators 
+  `supports_batching` and `supports_pending_experiments`
+
+### Fixed
+- Incorrect optimization direction with `PSTD` with a single minimization target
 
 ## [0.12.2] - 2025-01-31
 ### Changed

baybe/acquisition/__init__.py

@@ -13,6 +13,7 @@
     qLogNoisyExpectedImprovement,
     qNegIntegratedPosteriorVariance,
     qNoisyExpectedImprovement,
+    qPosteriorStandardDeviation,
     qProbabilityOfImprovement,
     qSimpleRegret,
     qThompsonSampling,
@@ -21,6 +22,7 @@
 
 PM = PosteriorMean
 PSTD = PosteriorStandardDeviation
+qPSTD = qPosteriorStandardDeviation
 qSR = qSimpleRegret
 EI = ExpectedImprovement
 qEI = qExpectedImprovement
@@ -43,6 +45,7 @@
     # Posterior Statistics
     "PosteriorMean",
     "PosteriorStandardDeviation",
+    "qPosteriorStandardDeviation",
     # Simple Regret
     "qSimpleRegret",
     # Expected Improvement
@@ -67,6 +70,7 @@
     # Posterior Statistics
     "PM",
     "PSTD",
+    "qPSTD",
     # Simple Regret
     "qSR",
     # Expected Improvement

baybe/acquisition/acqfs.py

@@ -174,6 +174,13 @@ class PosteriorStandardDeviation(AcquisitionFunction):
     with minimal posterior standard deviation."""
 
 
+@define(frozen=True)
+class qPosteriorStandardDeviation(AcquisitionFunction):
+    """Monte Carlo based posterior standard deviation."""
+
+    abbreviation: ClassVar[str] = "qPSTD"
+
+
 ########################################################################################
 ### Simple Regret
 @define(frozen=True)
@@ -307,6 +314,11 @@ def _non_botorch_attrs(cls) -> tuple[str, ...]:
         flds = fields(qThompsonSampling)
         return (flds.n_mc_samples.name,)
 
+    @override
+    @classproperty
+    def supports_batching(cls) -> bool:
+        return False
+
 
 # Collect leftover original slotted classes processed by `attrs.define`
 gc.collect()

baybe/acquisition/base.py

@@ -44,10 +44,18 @@ class AcquisitionFunction(ABC, SerialMixin):
     """An alternative name for type resolution."""
 
     @classproperty
-    def is_mc(cls) -> bool:
-        """Flag indicating whether this is a Monte-Carlo acquisition function."""
+    def supports_batching(cls) -> bool:
+        """Flag indicating whether batch recommendation is supported."""
         return cls.abbreviation.startswith("q")
 
+    @classproperty
+    def supports_pending_experiments(cls) -> bool:
+        """Flag indicating whether pending experiments are supported.
+
+        This is based on the same mechanism underlying batched recommendations.
+        """
+        return cls.supports_batching
+
     @classproperty
     def _non_botorch_attrs(cls) -> tuple[str, ...]:
         """Names of attributes that are not passed to the BoTorch constructor."""
@@ -95,7 +103,7 @@ def to_botorch(
                 self.get_integration_points(searchspace)  # type: ignore[attr-defined]
             )
         if pending_experiments is not None:
-            if self.is_mc:
+            if self.supports_pending_experiments:
                 pending_x = searchspace.transform(pending_experiments, allow_extra=True)
                 additional_params["X_pending"] = to_tensor(pending_x)
             else:
@@ -107,18 +115,29 @@ def to_botorch(
         # Add acquisition objective / best observed value
         match objective:
             case SingleTargetObjective(NumericalTarget(mode=TargetMode.MIN)):
+                # Adjust best_f
                 if "best_f" in signature_params:
                     additional_params["best_f"] = (
                         bo_surrogate.posterior(train_x).mean.min().item()
                     )
                     if issubclass(acqf_cls, bo_acqf.MCAcquisitionFunction):
                         additional_params["best_f"] *= -1.0
 
-                if issubclass(acqf_cls, bo_acqf.AnalyticAcquisitionFunction):
-                    additional_params["maximize"] = False
-                elif issubclass(acqf_cls, bo_acqf.qNegIntegratedPosteriorVariance):
-                    # qNIPV is valid but does not require any adjusted params
+                # Adjust objective
+                if issubclass(
+                    acqf_cls,
+                    (
+                        bo_acqf.qNegIntegratedPosteriorVariance,
+                        bo_acqf.PosteriorStandardDeviation,
+                        bo_acqf.qPosteriorStandardDeviation,
+                    ),
+                ):
+                    # The active learning acqfs are valid but no changes based on the
+                    # target direction are required.
                     pass
+                elif issubclass(acqf_cls, bo_acqf.AnalyticAcquisitionFunction):
+                    # Minimize acqfs in case the target should be minimized.
+                    additional_params["maximize"] = False
                 elif issubclass(acqf_cls, bo_acqf.MCAcquisitionFunction):
                     additional_params["objective"] = LinearMCObjective(
                         torch.tensor([-1.0])

baybe/recommenders/pure/bayesian/botorch.py

@@ -114,7 +114,7 @@ def _recommend_discrete(
             The dataframe indices of the recommended points in the provided
             experimental representation.
         """
-        if batch_size > 1 and not self.acquisition_function.is_mc:
+        if batch_size > 1 and not self.acquisition_function.supports_batching:
             raise IncompatibleAcquisitionFunctionError(
                 f"The '{self.__class__.__name__}' only works with Monte Carlo "
                 f"acquisition functions for batch sizes > 1."
@@ -168,8 +168,7 @@ def _recommend_continuous(
         Returns:
             A dataframe containing the recommendations as individual rows.
         """
-        # For batch size > 1, this optimizer needs a MC acquisition function
-        if batch_size > 1 and not self.acquisition_function.is_mc:
+        if batch_size > 1 and not self.acquisition_function.supports_batching:
             raise IncompatibleAcquisitionFunctionError(
                 f"The '{self.__class__.__name__}' only works with Monte Carlo "
                 f"acquisition functions for batch sizes > 1."
@@ -234,8 +233,8 @@ def _recommend_hybrid(
         Returns:
             The recommended points.
         """
-        # For batch size > 1, this optimizer needs a MC acquisition function
-        if batch_size > 1 and not self.acquisition_function.is_mc:
+        # For batch size > 1, the acqf needs to support batching
+        if batch_size > 1 and not self.acquisition_function.supports_batching:
             raise IncompatibleAcquisitionFunctionError(
                 f"The '{self.__class__.__name__}' only works with Monte Carlo "
                 f"acquisition functions for batch sizes > 1."

docs/conf.py

@@ -126,7 +126,8 @@
     (r"py:class", "baybe.utils.basic._U"),
     (r"ref:obj", "baybe.surrogates.base.ModelContext"),
     # Ignore custom class properties
-    (r"py:obj", "baybe.acquisition.acqfs.*.is_mc"),
+    (r"py:obj", "baybe.acquisition.acqfs.*.supports_batching"),
+    (r"py:obj", "baybe.acquisition.acqfs.*.supports_pending_experiments"),
     # Other
     (r"py:obj", "baybe.utils.basic.UnspecifiedType.UNSPECIFIED"),
 ]
@@ -301,8 +302,6 @@ def autodoc_process_docstring(app, what, name, obj, options, lines):
 
 
 def autodoc_skip_member(app, what, name, obj, skip, options):
-    """Skip the docstring for the is_mc classproperty."""
-    # Note that we cannot do `return name == "is_mc"` since this messes up other members
-    # that need to be skipped.
-    if name == "is_mc":
+    """Skip the docstring for the acqf classproperties."""
+    if name in ["supports_batching", "supports_pending_experiments"]:
         return True

docs/userguide/active_learning.md

@@ -19,15 +19,16 @@ including a few guidelines.
 ## Local Uncertainty Reduction
 In BayBE, there are two types of acquisition function that can be chosen to search for
 the points with the highest predicted model uncertainty:
-- [`PosteriorStandardDeviation`](baybe.acquisition.acqfs.PosteriorStandardDeviation) (`PSTD`)
+- [`PosteriorStandardDeviation`](baybe.acquisition.acqfs.PosteriorStandardDeviation) (`PSTD`) 
+  / [`qPosteriorStandardDeviation`](baybe.acquisition.acqfs.qPosteriorStandardDeviation) (`qPSTD`) 
 - [`UpperConfidenceBound`](baybe.acquisition.acqfs.UpperConfidenceBound) (`UCB`) / 
   [`qUpperConfidenceBound`](baybe.acquisition.acqfs.qUpperConfidenceBound) (`qUCB`)
   with high `beta`:  
   Increasing values of `beta` effectively eliminate the effect of the posterior mean on
   the acquisition value, yielding a selection of points driven primarily by the
   posterior variance. However, we generally recommend to use this acquisition function
   only if a small exploratory component is desired – otherwise, the
-  [`PosteriorStandardDeviation`](baybe.acquisition.acqfs.PosteriorStandardDeviation) 
+  [`qPosteriorStandardDeviation`](baybe.acquisition.acqfs.qPosteriorStandardDeviation) 
   acquisition function is what you are looking for.
 
 ## Global Uncertainty Reduction

pyproject.toml

@@ -29,7 +29,7 @@ keywords = [
 dynamic = ['version']
 dependencies = [
     "attrs>=24.1.0",
-    "botorch>=0.9.3,<1",
+    "botorch>=0.13.0,<1",
     "cattrs>=24.1.0",
     "exceptiongroup",
     "funcy>=1.17,<2",
@@ -40,7 +40,7 @@ dependencies = [
     "pandas>=1.4.2,<3",
     "scikit-learn>=1.1.1,<2",
     "scikit-learn-extra>=0.3.0,<1",
-    "scipy>=1.10.1,<1.15", # See https://github.com/pytorch/botorch/commit/37f04d11193704f4ece222b029df103edb3e6642
+    "scipy>=1.10.1",
     "setuptools-scm>=7.1.0",
     "torch>=1.13.1,<3",
     "typing_extensions>=4.7.0",

tests/hypothesis_strategies/acquisition.py

@@ -15,6 +15,7 @@
     qLogNoisyExpectedImprovement,
     qNegIntegratedPosteriorVariance,
     qNoisyExpectedImprovement,
+    qPosteriorStandardDeviation,
     qProbabilityOfImprovement,
     qSimpleRegret,
     qUpperConfidenceBound,
@@ -51,6 +52,7 @@ def _qNIPV_strategy(draw: st.DrawFn):
     st.builds(UpperConfidenceBound, beta=finite_floats(min_value=0.0)),
     st.builds(PosteriorMean),
     st.builds(PosteriorStandardDeviation, maximize=st.sampled_from([True, False])),
+    st.builds(qPosteriorStandardDeviation),
     st.builds(LogExpectedImprovement),
     st.builds(qExpectedImprovement),
     st.builds(qProbabilityOfImprovement),

tests/test_iterations.py

@@ -1,12 +1,15 @@
 # TODO: This file needs to be refactored.
 """Tests various configurations for a small number of iterations."""
 
+from contextlib import nullcontext
+
 import pytest
+from botorch.exceptions import UnsupportedError
 from pytest import param
 
 from baybe.acquisition import qKG, qNIPV, qTS, qUCB
 from baybe.acquisition.base import AcquisitionFunction
-from baybe.exceptions import UnusedObjectWarning
+from baybe.exceptions import InvalidSurrogateModelError, UnusedObjectWarning
 from baybe.kernels.base import Kernel
 from baybe.kernels.basic import (
     LinearKernel,
@@ -77,17 +80,19 @@
     in [SearchSpaceType.CONTINUOUS, SearchSpaceType.HYBRID, SearchSpaceType.EITHER]
 ]
 
-valid_active_learning_acqfs = [
+acqfs_extra = [  # Additionally tested acqfs with extra configurations
     qNIPV(sampling_fraction=0.2, sampling_method="Random"),
     qNIPV(sampling_fraction=0.2, sampling_method="FPS"),
     qNIPV(sampling_fraction=1.0, sampling_method="FPS"),
     qNIPV(sampling_n_points=1, sampling_method="Random"),
     qNIPV(sampling_n_points=1, sampling_method="FPS"),
 ]
-valid_mc_acqfs = [
-    a() for a in get_subclasses(AcquisitionFunction) if a.is_mc
-] + valid_active_learning_acqfs
-valid_nonmc_acqfs = [a() for a in get_subclasses(AcquisitionFunction) if not a.is_mc]
+acqfs_batching = [
+    a() for a in get_subclasses(AcquisitionFunction) if a.supports_batching
+] + acqfs_extra
+acqfs_non_batching = [
+    a() for a in get_subclasses(AcquisitionFunction) if not a.supports_batching
+]
 
 # List of all hybrid recommenders with default attributes. Is extended with other lists
 # of hybrid recommenders like naive ones or recommenders not using default arguments
@@ -202,35 +207,40 @@
 ]
 
 test_targets = [
-    ["Target_max"],
-    ["Target_min"],
-    ["Target_match_bell"],
-    ["Target_match_triangular"],
-    ["Target_max_bounded", "Target_min_bounded"],
+    param(["Target_max"], id="Tmax"),
+    param(["Target_min"], id="Tmin"),
+    param(["Target_match_bell"], id="Tmatch_bell"),
+    param(["Target_match_triangular"], id="Tmatch_triang"),
+    param(["Target_max_bounded", "Target_min_bounded"], id="Tmax_bounded_Tmin_bounded"),
 ]
 
 
 @pytest.mark.slow
 @pytest.mark.parametrize(
-    "acqf", valid_mc_acqfs, ids=[a.abbreviation for a in valid_mc_acqfs]
+    "acqf", acqfs_batching, ids=[a.abbreviation for a in acqfs_batching]
 )
 @pytest.mark.parametrize("n_iterations", [3], ids=["i3"])
-def test_mc_acqfs(campaign, n_iterations, batch_size, acqf):
-    if isinstance(acqf, qKG):
-        pytest.skip(f"{acqf.__class__.__name__} only works with continuous spaces.")
-    if isinstance(acqf, qTS) and batch_size > 1:
-        pytest.skip(f"{acqf.__class__.__name__} only works with batch size 1.")
-
-    run_iterations(campaign, n_iterations, batch_size)
+@pytest.mark.parametrize("n_grid_points", [5], ids=["g5"])
+def test_batching_acqfs(campaign, n_iterations, batch_size, acqf):
+    context = nullcontext()
+    if campaign.searchspace.type not in [
+        SearchSpaceType.CONTINUOUS,
+        SearchSpaceType.HYBRID,
+    ] and isinstance(acqf, qKG):
+        # qKG does not work with purely discrete spaces
+        context = pytest.raises(UnsupportedError)
+
+    with context:
+        run_iterations(campaign, n_iterations, batch_size)
 
 
 @pytest.mark.slow
 @pytest.mark.parametrize(
-    "acqf", valid_nonmc_acqfs, ids=[a.abbreviation for a in valid_nonmc_acqfs]
+    "acqf", acqfs_non_batching, ids=[a.abbreviation for a in acqfs_non_batching]
 )
 @pytest.mark.parametrize("n_iterations", [3], ids=["i3"])
 @pytest.mark.parametrize("batch_size", [1], ids=["b1"])
-def test_nonmc_acqfs(campaign, n_iterations, batch_size):
+def test_non_batching_acqfs(campaign, n_iterations, batch_size):
     run_iterations(campaign, n_iterations, batch_size)
 
 
@@ -256,13 +266,20 @@ def test_kernel_factories(campaign, n_iterations, batch_size):
     ids=[c.__class__ for c in valid_surrogate_models],
 )
 def test_surrogate_models(campaign, n_iterations, batch_size, surrogate_model):
+    context = nullcontext()
     if batch_size > 1 and isinstance(surrogate_model, IndependentGaussianSurrogate):
-        pytest.skip("Batch recommendation is not supported.")
-    run_iterations(campaign, n_iterations, batch_size)
+        context = pytest.raises(InvalidSurrogateModelError)
+
+    with context:
+        run_iterations(campaign, n_iterations, batch_size)
 
 
 @pytest.mark.slow
-@pytest.mark.parametrize("recommender", valid_initial_recommenders)
+@pytest.mark.parametrize(
+    "recommender",
+    valid_initial_recommenders,
+    ids=[c.__class__ for c in valid_initial_recommenders],
+)
 def test_initial_recommenders(campaign, n_iterations, batch_size):
     with pytest.warns(UnusedObjectWarning):
         run_iterations(campaign, n_iterations, batch_size)
@@ -275,35 +292,61 @@ def test_targets(campaign, n_iterations, batch_size):
 
 
 @pytest.mark.slow
-@pytest.mark.parametrize("recommender", valid_discrete_recommenders)
+@pytest.mark.parametrize(
+    "recommender",
+    valid_discrete_recommenders,
+    ids=[c.__class__ for c in valid_discrete_recommenders],
+)
 def test_recommenders_discrete(campaign, n_iterations, batch_size):
     run_iterations(campaign, n_iterations, batch_size)
 
 
 @pytest.mark.slow
-@pytest.mark.parametrize("recommender", valid_continuous_recommenders)
-@pytest.mark.parametrize("parameter_names", [["Conti_finite1", "Conti_finite2"]])
+@pytest.mark.parametrize(
+    "recommender",
+    valid_continuous_recommenders,
+    ids=[c.__class__ for c in valid_continuous_recommenders],
+)
+@pytest.mark.parametrize(
+    "parameter_names", [["Conti_finite1", "Conti_finite2"]], ids=["conti_params"]
+)
 def test_recommenders_continuous(campaign, n_iterations, batch_size):
     run_iterations(campaign, n_iterations, batch_size)
 
 
 @pytest.mark.slow
-@pytest.mark.parametrize("recommender", valid_hybrid_recommenders)
+@pytest.mark.parametrize(
+    "recommender",
+    valid_hybrid_recommenders,
+    ids=[c.__class__ for c in valid_hybrid_recommenders],
+)
 @pytest.mark.parametrize(
     "parameter_names",
     [["Categorical_1", "SomeSetting", "Num_disc_1", "Conti_finite1", "Conti_finite2"]],
+    ids=["hybrid_params"],
 )
 def test_recommenders_hybrid(campaign, n_iterations, batch_size):
     run_iterations(campaign, n_iterations, batch_size)
 
 
-@pytest.mark.parametrize("recommender", valid_meta_recommenders, indirect=True)
+@pytest.mark.parametrize(
+    "recommender",
+    valid_meta_recommenders,
+    ids=[c.__class__ for c in valid_meta_recommenders],
+    indirect=True,
+)
 def test_meta_recommenders(campaign, n_iterations, batch_size):
     run_iterations(campaign, n_iterations, batch_size)
 
 
-@pytest.mark.parametrize("acqf", [qTS(), qUCB()])
-@pytest.mark.parametrize("surrogate_model", [BetaBernoulliMultiArmedBanditSurrogate()])
+@pytest.mark.parametrize(
+    "acqf", [qTS(), qUCB()], ids=[qTS.abbreviation, qUCB.abbreviation]
+)
+@pytest.mark.parametrize(
+    "surrogate_model",
+    [BetaBernoulliMultiArmedBanditSurrogate()],
+    ids=["bernoulli_bandit_surrogate"],
+)
 @pytest.mark.parametrize(
     "parameter_names",
     [
@@ -314,7 +357,7 @@ def test_meta_recommenders(campaign, n_iterations, batch_size):
         ["Frame_B"],
     ],
 )
-@pytest.mark.parametrize("batch_size", [1])
-@pytest.mark.parametrize("target_names", [["Target_binary"]])
+@pytest.mark.parametrize("target_names", [["Target_binary"]], ids=["binary_target"])
+@pytest.mark.parametrize("batch_size", [1], ids=["b1"])
 def test_multi_armed_bandit(campaign, n_iterations, batch_size):
     run_iterations(campaign, n_iterations, batch_size, add_noise=False)

tests/test_pending_experiments.py

@@ -125,11 +125,15 @@ def test_pending_points(campaign, batch_size):
     )
 
 
-_non_mc_acqfs = [a() for a in get_subclasses(AcquisitionFunction) if not a.is_mc]
+acqfs_non_pending = [
+    a()
+    for a in get_subclasses(AcquisitionFunction)
+    if (not a.supports_pending_experiments)
+]
 
 
 @pytest.mark.parametrize(
-    "acqf", _non_mc_acqfs, ids=[a.abbreviation for a in _non_mc_acqfs]
+    "acqf", acqfs_non_pending, ids=[a.abbreviation for a in acqfs_non_pending]
 )
 @pytest.mark.parametrize(
     "parameter_names",
@@ -140,7 +144,7 @@ def test_pending_points(campaign, batch_size):
     ],
 )
 @pytest.mark.parametrize("n_grid_points", [5], ids=["g5"])
-@pytest.mark.parametrize("batch_size", [3], ids=["b3"])
+@pytest.mark.parametrize("batch_size", [1], ids=["b1"])
 def test_invalid_acqf(searchspace, recommender, objective, batch_size, acqf):
     """Test exception raised for acqfs that don't support pending experiments."""
     recommender = TwoPhaseMetaRecommender(