Feature/optimize over entire discrete search spaces (#86)

Implement the possibility to optimize over entire discrete search spaces

Signed-off-by: tip2rng <petru.tighineanu@de.bosch.com>

Author: ptighin

blackboxopt/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "4.12.0"
+__version__ = "4.13.0"
 
 from parameterspace import ParameterSpace
 

blackboxopt/optimizers/botorch_base.py

@@ -9,6 +9,7 @@
 from typing import Callable, Dict, Iterable, Optional, Tuple, Union
 
 from gpytorch.models import ExactGP
+from parameterspace import ParameterSpace
 
 from blackboxopt.base import (
     Objective,
@@ -44,6 +45,33 @@
     ) from e
 
 
+def _get_numerical_points_from_discrete_space(space: ParameterSpace) -> np.ndarray:
+    """Retrieve all points from a discrete space in the numerical representation"""
+    points_along_dimensions = []
+    for parameter_name in space.get_parameter_names():
+        parameter = space.get_parameter_by_name(parameter_name)[
+            "parameter"
+        ]  # type:ignore
+        if isinstance(parameter, ps.IntegerParameter):
+            bounds = (parameter.bounds[0], parameter.bounds[1] + 1)
+            points_along_dimensions.append(
+                [parameter.val2num(v) for v in range(*bounds)]
+            )
+        elif isinstance(parameter, ps.OrdinalParameter) or isinstance(
+            parameter, ps.CategoricalParameter
+        ):
+            points_along_dimensions.append(
+                [parameter.val2num(v) for v in parameter.values]
+            )
+        else:
+            raise ValueError(
+                f"Only discrete parameters are allowed but got {parameter}"
+            )
+    points = np.meshgrid(*points_along_dimensions)
+    points = [p.reshape((p.size, 1)) for p in points]
+    return np.concatenate(points, axis=-1)
+
+
 def _acquisition_function_optimizer_factory(
     search_space: ps.ParameterSpace,
     af_opt_kwargs: Optional[dict],
@@ -52,7 +80,10 @@ def _acquisition_function_optimizer_factory(
     """Prepare either BoTorch's `optimize_acqf_discrete` or `optimize_acqf` depending
     on whether the search space is fully discrete or not and set required defaults if
     not overridden by `af_opt_kwargs`. If any of the af optimizer specific required
-    kwargs are set, this overrides the automatic discrete space detection.
+    kwargs are set, this overrides the automatic discrete space detection. In case an
+    exclusively discrete space is detected and `num_random_choices` is not specified
+    in `af_opt_kwargs`, the discrete acquisition function optimizer is using all
+    possible combinations in the discrete space.
 
     Args:
         search_space: Search space used for optimization.
@@ -76,6 +107,7 @@ def _acquisition_function_optimizer_factory(
         or "raw_samples" in kwargs
         or space_has_continuous_parameters
     ):
+        # continuous AF optimization
         return functools.partial(
             optimize_acqf,
             q=1,
@@ -86,12 +118,20 @@ def _acquisition_function_optimizer_factory(
             **kwargs,
         )
 
-    choices = torch.Tensor(
-        [
-            search_space.to_numerical(search_space.sample())
-            for _ in range(kwargs.pop("num_random_choices", 5_000))
-        ]
-    ).to(dtype=torch_dtype)
+    if "num_random_choices" not in kwargs and not space_has_continuous_parameters:
+        # Optimize over the entire discrete search space, if the number of random
+        # choices is not specified
+        choices = torch.from_numpy(
+            _get_numerical_points_from_discrete_space(search_space)
+        ).to(torch_dtype)
+    else:
+        # Optimize over the desired number of samples from the discrete search space
+        choices = torch.Tensor(
+            [
+                search_space.to_numerical(search_space.sample())
+                for _ in range(kwargs["num_random_choices"])
+            ]
+        ).to(dtype=torch_dtype)
     return functools.partial(optimize_acqf_discrete, q=1, choices=choices, **kwargs)
 
 

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "blackboxopt"
-version = "4.12.0"
+version = "4.13.0"
 description = "A common interface for blackbox optimization algorithms along with useful helpers like parallel optimization loops, analysis and visualization scripts."
 readme = "README.md"
 repository = "https://github.com/boschresearch/blackboxopt"

tests/optimizers/botorch_base_test.py

@@ -2,7 +2,7 @@
 # see the NOTICE file and/or the repository https://github.com/boschresearch/blackboxopt
 #
 # SPDX-License-Identifier: Apache-2.0
-
+import itertools
 from functools import partial
 
 import parameterspace as ps
@@ -16,6 +16,7 @@
 from blackboxopt.optimizers.botorch_base import (
     SingleObjectiveBOTorchOptimizer,
     _acquisition_function_optimizer_factory,
+    _get_numerical_points_from_discrete_space,
 )
 from blackboxopt.optimizers.testing import (
     ALL_REFERENCE_TESTS,
@@ -78,6 +79,14 @@ def test_acquisition_function_optimizer_factory_with_discrete_space():
 
     assert af_opt.func == optimize_acqf_discrete  # pylint: disable=no-member
 
+    af_opt = _acquisition_function_optimizer_factory(
+        discrete_space,
+        af_opt_kwargs={"num_random_choices": 50},
+        torch_dtype=torch.float64,
+    )
+
+    assert af_opt.func == optimize_acqf_discrete  # pylint: disable=no-member
+
 
 def test_acquisition_function_optimizer_factory_with_mixed_space():
     mixed_space = ps.ParameterSpace()
@@ -155,3 +164,35 @@ def test_find_optimum_in_1d_discrete_space(seed):
     assert (
         sum(l == 0 for l in losses) > 5
     ), "After figuring out the best of the three points, it should only propose that."
+
+
+def test_get_numerical_points_from_discrete_space():
+    p0l, p0h = -5, 10
+    p1 = ("small", "medium", "large")
+    p2 = ("woof", "miaow", "moo")
+    discrete_space = ps.ParameterSpace()
+    p_integ = ps.IntegerParameter("integ", (p0l, p0h))
+    discrete_space.add(p_integ)
+    p_ordin = ps.OrdinalParameter("ordin", p1)
+    discrete_space.add(p_ordin)
+    p_categ = ps.CategoricalParameter("categ", p2)
+    discrete_space.add(p_categ)
+
+    points = _get_numerical_points_from_discrete_space(discrete_space)
+    assert (
+        points.shape[0] == p_integ.num_values * p_ordin.num_values * p_categ.num_values
+    )
+    assert points.shape[-1] == len(discrete_space)
+    for integ, ordin, categ in itertools.product(
+        range(p_integ.bounds[0], p_integ.bounds[1] + 1), p_ordin.values, p_categ.values
+    ):
+        assert (
+            (
+                points
+                == discrete_space.to_numerical(
+                    dict(integ=integ, ordin=ordin, categ=categ)
+                )
+            )
+            .all(axis=1)
+            .any()
+        ), f"Point {integ}, {ordin}, {categ} belongs to the search space but is not returned by `_get_numerical_points_from_discrete_space`"