Adds bounds to CMA-ES and TuRBO (#33)

* Adds bounds to CMA-ES

* Brings Simon's changes to TuRBO

* Adds default bounds to TuRBO

* Updates the TuRBO to be a step-by-step solver

Author: miguelgondu

src/poli_baselines/solvers/bayesian_optimization/turbo/turbo_wrapper.py

@@ -1,6 +1,9 @@
 # Code taken from https://botorch.org/tutorials/turbo_1
+from __future__ import annotations
+
 import numpy as np
 from poli.core.abstract_black_box import AbstractBlackBox
+from typing import List
 
 from poli_baselines.core.step_by_step_solver import StepByStepSolver
 import math
@@ -29,9 +32,42 @@
 
 
 class TurboWrapper(StepByStepSolver):
-    def __init__(self, black_box: AbstractBlackBox, x0: np.ndarray, y0: np.ndarray):
+    def __init__(
+        self,
+        black_box: AbstractBlackBox,
+        x0: np.ndarray,
+        y0: np.ndarray,
+        bounds: np.ndarray | None = None,
+    ):
+        """
+
+        Parameters
+        ----------
+        black_box
+        x0
+        y0
+        bounds:
+            array of shape Dx2 where D is the dimensionality
+            The first row contains the lower bounds on x, the last row contains the upper bounds.
+        """
         super().__init__(black_box, x0, y0)
-        self.X_turbo = torch.tensor(x0)
+        assert x0.shape[0] > 1
+
+        if bounds is None:
+            bounds = np.array([[x0.min() - 1.0, x0.max() + 1.0]] * x0.shape[1])
+
+        assert bounds.shape[1] == 2
+        assert bounds.shape[0] == x0.shape[1]
+        assert np.all(bounds[:, 1] >= bounds[:, 0])
+        bounds[:, 1] -= bounds[:, 0]
+
+        def make_transforms():
+            to_turbo = lambda X: (X - bounds[:, 0]) / bounds[:, 1]
+            from_turbo = lambda X: X * bounds[:, 1] + bounds[:, 0]
+            return to_turbo, from_turbo
+
+        self.to_turbo, self.from_turbo = make_transforms()
+        self.X_turbo = torch.tensor(self.to_turbo(x0))
         self.Y_turbo = torch.tensor(y0)
         self.batch_size = 1
         dim = x0.shape[1]
@@ -70,14 +106,14 @@ def next_candidate(self) -> np.ndarray:
             raw_samples=RAW_SAMPLES,
             acqf="ts",
         )
-        return X_next
+        return self.from_turbo(X_next.numpy())
 
     def post_update(self, x: np.ndarray, y: np.ndarray) -> None:
         """
         This method is called after the history is updated.
         """
         Y_next = torch.tensor(y)
-        X_next = torch.tensor(x)
+        X_next = torch.tensor(self.to_turbo(x))
 
         # Update state
         self.state = update_state(state=self.state, Y_next=Y_next)

src/poli_baselines/solvers/evolutionary_strategies/cma_es.py

@@ -17,6 +17,7 @@
 
 """
 
+from __future__ import annotations
 from typing import Tuple
 import numpy as np
 from poli.core.abstract_black_box import AbstractBlackBox
@@ -71,6 +72,7 @@ def __init__(
         initial_mean: np.ndarray,
         initial_sigma: float = 1.0,
         population_size: int = 10,
+        bounds: tuple[float, float] | None = None,
     ):
         """
         Initialize the CMA-ES solver.
@@ -93,13 +95,14 @@ def __init__(
         self.initial_sigma = initial_sigma
         self.population_size = population_size
 
-        self._internal_cma = cma.CMAEvolutionStrategy(
-            initial_mean,
-            initial_sigma,
-            {
-                "popsize": population_size,
-            },
-        )
+        opts = {
+            "popsize": population_size,
+        }
+
+        if bounds is not None:
+            opts["bounds"] = bounds
+
+        self._internal_cma = cma.CMAEvolutionStrategy(initial_mean, initial_sigma, opts)
 
         # Include the x0 and y0
         _ = self._internal_cma.ask()