XpyriMentor and Suggestors

.github/workflows/python-package-tests.yml

@@ -15,7 +15,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        python-version: ["3.8", "3.9", "3.10", "3.11", "3.12"]
+        python-version: ["3.9", "3.10", "3.11", "3.12"]
 
     steps:
       - uses: actions/checkout@v4

ProcessOptimizer/optimizer/optimizer.py

@@ -1053,10 +1053,13 @@ def get_constraints(self):
     def update_next(self):
         """Updates the value returned by opt.ask(). Useful if a parameter was updated after ask was called."""
         self.cache_ = {}
+        self._n_initial_points = self.n_initial_points_-len(self.Xi)
+        copy = self.copy(random_state=self.rng)
+        self.models = copy.models
         # Ask for a new next_x. Usefull if new constraints have been added or lenght_scale has been tweaked.
         # We only need to overwrite _next_x if it exists.
-        if hasattr(self, "_next_x"):
-            opt = self.copy(random_state=self.rng)
+        if hasattr(copy, "_next_x"):
+            opt = copy
             self._next_x = opt._next_x
 
     def get_result(self):

ProcessOptimizer/space/space.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from abc import ABC, abstractmethod
 from typing import Iterable, List, Union
 
@@ -11,7 +12,7 @@
 from .transformers import Identity
 from .transformers import Log10
 from .transformers import Pipeline
-from ..utils import get_random_generator
+from ..utils import get_random_generator, is_2Dlistlike
 
 # helper class to be able to print [1, ..., 4] instead of [1, '...', 4]
 
@@ -39,7 +40,7 @@ def space_factory(input: Union["Space", List]) -> "Space":
         return Space(input)
 
 
-def check_dimension(dimension, transform=None):
+def check_dimension(dimension, transform=None) -> Dimension:
     """Turn a provided dimension description into a dimension object.
 
     Checks that the provided dimension falls into one of the
@@ -201,7 +202,7 @@ def sample(
                     unique_points.append(point)
                     seen.add(point)
             sampled_points = unique_points
-        return np.array(sampled_points)
+        return np.array(sampled_points, dtype=object)
 
     @abstractmethod
     def _sample(self, points: Iterable[float]) -> np.array:
@@ -817,6 +818,31 @@ def inverse_transform(self, Xt):
 
         return rows
 
+    def sample(self, points: Iterable[Union[float, Iterable[float]]]) -> np.ndarray:
+        """Draw points from the space.
+
+        Parameters
+        ----------
+        * `points` [float or list[float]]:
+            A single point or a list of points to sample. All must be between 0 and 1.
+
+        Returns
+        -------
+        * `sampled_points` [np.ndarray]:
+            The sampled points.
+        """
+        if not is_2Dlistlike(points):
+            points = [points]
+        if any(len(point) != len(self) for point in points):
+            raise ValueError(
+                "One or more points does not have the same length as the space " +
+                str(({len(self)}))
+            )
+        sampled_points = []
+        for dim in self.dimensions:
+            sampled_points.append(dim.sample([p[0] for p in points]))
+        return np.array(sampled_points, dtype = object).transpose()
+
     @property
     def n_dims(self):
         """The dimensionality of the original space."""

ProcessOptimizer/tests/test_space.py

@@ -87,14 +87,14 @@ def test_real_bounds():
 @pytest.mark.parametrize(
     "dimension, ismember, point_type",
     [
-        (Real(1, 10), lambda x: 1 <= x <= 10, np.float64),
+        (Real(1, 10), lambda x: 1 <= x <= 10, float),
         (
             Real(10**-5, 10**5, prior="log-uniform"),
             lambda x: 10**-5 <= x <= 10**5,
-            np.float64,
+            float,
         ),
-        (Integer(1, 10), lambda x: 1 <= x <= 10, np.integer),
-        (Integer(1, 10, transform="normalize"), lambda x: 0 <= x <= 10, np.integer),
+        (Integer(1, 10), lambda x: 1 <= x <= 10, int),
+        (Integer(1, 10, transform="normalize"), lambda x: 0 <= x <= 10, int),
         (Categorical(["cat", "dog", "rat"]), lambda x: x in ["cat", "dog", "rat"], str),
     ],
 )
@@ -744,3 +744,55 @@ def test_lhs():
     # Asserting the the values are the same for both the lhs, even though the order is different
     for i in range(4):
         assert set([x[i] for x in lhs_one]) == set([x[i] for x in lhs_two])
+
+
+def test_sample():
+    SPACE = Space(
+        [
+            Integer(1, 6),
+            Real(1, 7),
+            Real(10**-3, 10**3, prior="log-uniform"),
+            Categorical(list("abc")),
+        ]
+    )
+    # Getting one sample
+    samples = SPACE.sample([0.5]*len(SPACE))
+    assert len(samples) == 1
+    assert isinstance(samples, np.ndarray)
+    assert len(samples[0]) == 4
+    values = samples[0]
+    assert isinstance(values, np.ndarray)
+    assert isinstance(values[0], int)
+    assert isinstance(values[1], float)
+    assert isinstance(values[2], float)
+    assert isinstance(values[3], str)
+    # Getting multiple samples
+    samples = SPACE.sample([[0.5]*len(SPACE)]*5)
+    assert len(samples) == 5
+    assert len(samples[0]) == 4
+    assert isinstance(samples, np.ndarray)
+    for sample in samples:
+        assert isinstance(sample, np.ndarray)
+        assert isinstance(sample[0], int)
+        assert isinstance(sample[1], float)
+        assert isinstance(sample[2], float)
+        assert isinstance(sample[3], str)
+
+
+def test_sample_wrong_size():
+    SPACE = Space(
+        [
+            Integer(1, 6),
+            Real(1, 7),
+            Real(10**-3, 10**3, prior="log-uniform"),
+            Categorical(list("abc")),
+        ]
+    )
+    with pytest.raises(ValueError):
+        SPACE.sample([0.5]*3)
+    with pytest.raises(ValueError):
+        SPACE.sample([0.5]*5)
+    with pytest.raises(ValueError):
+        SPACE.sample([[0.5]*3]*5)
+    with pytest.raises(ValueError):
+        SPACE.sample([[0.5]*5]*3)

ProcessOptimizer/tests/test_suggestors/test_initial_point_suggestor.py

@@ -0,0 +1,85 @@
+import numpy as np
+from XpyriMentor.suggestors import (
+    suggestor_factory,
+    InitialPointStrategizer,
+    DefaultSuggestor,
+    POSuggestor,
+    Suggestor,
+    LHSSuggestor,
+)
+from ProcessOptimizer.space import space_factory
+
+
+class MockSuggestor:
+    def __init__(self, suggestions: list):
+        self.suggestions = suggestions
+        self.last_input = {}
+
+    def suggest(self, Xi, Yi, n_asked=1):
+        self.last_input = {"Xi": Xi, "Yi": Yi}
+        return self.suggestions[:n_asked]
+
+
+def test_initialization():
+    space = space_factory([[0, 1], [0, 1]])
+    suggestor = InitialPointStrategizer(
+        initial_suggestor=DefaultSuggestor(space, n_objectives=1, rng=np.random.default_rng(1)),
+        ultimate_suggestor=DefaultSuggestor(space, n_objectives=1, rng=np.random.default_rng(2)),
+    )
+    assert isinstance(suggestor, Suggestor)
+    assert suggestor.n_initial_points == 5
+    # Initial suggestor is a POSuggestor with more than 5 initial points. This means than
+    # we will only use the LHS part of this ProcessOptimizer.
+    assert isinstance(suggestor.initial_suggestor, LHSSuggestor)
+    assert suggestor.initial_suggestor.n_points == 5
+    # Ultimate suggestor is a POSuggestor with no initial points, since
+    # InitialPointSuggestor handles the initial points.
+    assert isinstance(suggestor.ultimate_suggestor, POSuggestor)
+    assert suggestor.ultimate_suggestor.optimizer._n_initial_points == 0
+
+
+def test_factory():
+    space = space_factory([[0, 1], [0, 1]])
+    suggestor = suggestor_factory(
+        space=space,
+        definition={"name": "InitialPoint", "n_initial_points": 10},
+    )
+    assert isinstance(suggestor, InitialPointStrategizer)
+    assert suggestor.n_initial_points == 10
+    assert isinstance(suggestor.initial_suggestor, LHSSuggestor)
+    assert suggestor.initial_suggestor.n_points == 10
+    assert isinstance(suggestor.ultimate_suggestor, POSuggestor)
+    assert suggestor.ultimate_suggestor.optimizer._n_initial_points == 0
+
+
+def test_suggestor_switch():
+    suggestor = InitialPointStrategizer(
+        initial_suggestor=MockSuggestor([[1]]),
+        ultimate_suggestor=MockSuggestor([[2]]),
+        n_initial_points=3,
+    )
+    assert suggestor.suggest([], []) == [[1]]
+    assert suggestor.suggest([1], []) == [[1]]
+    assert suggestor.suggest([1, 2], []) == [[1]]
+    assert suggestor.suggest([1, 2, 3], []) == [[2]]
+
+
+def test_bridging_the_switch():
+    suggestor = InitialPointStrategizer(
+        initial_suggestor=MockSuggestor([[1], [1]]),
+        ultimate_suggestor=MockSuggestor([[2]]),
+        n_initial_points=2,
+    )
+    assert all(suggestor.suggest([], [], n_asked=2) == [[1], [1]])
+    assert all(suggestor.suggest([1], [], n_asked=2) == [[1], [2]])
+
+
+def test_multiple_initial():
+    suggestor = InitialPointStrategizer(
+        initial_suggestor=MockSuggestor([[1], [1]]),
+        ultimate_suggestor=MockSuggestor([[2]]),
+        n_initial_points=2,
+    )
+    assert suggestor.suggest([], []) == [[1]]
+    assert suggestor.suggest([1], []) == [[1]]
+    assert suggestor.suggest([1, 1], []) == [[2]]

ProcessOptimizer/tests/test_suggestors/test_lhs_suggestor.py

@@ -0,0 +1,62 @@
+import numpy as np
+import pytest
+from ProcessOptimizer.space import space_factory
+from XpyriMentor.suggestors import LHSSuggestor, Suggestor, suggestor_factory, IncompatibleNumberAsked
+
+
+def test_initializaton():
+    suggestor = LHSSuggestor(
+        space=space_factory([[1, 2], [1, 2]]),
+        rng=np.random.default_rng(1),
+    )
+    assert isinstance(suggestor, Suggestor)
+    assert suggestor.n_points == 5
+    assert len(suggestor.cache) == 5
+
+
+def test_factory():
+    space = space_factory([[1, 2], [1, 2]])
+    suggestor = suggestor_factory(
+        space=space,
+        definition={"name": "LHS", "n_points": 10},
+    )
+    assert isinstance(suggestor, LHSSuggestor)
+    assert suggestor.n_points == 10
+
+
+def test_suggest():
+    space = space_factory([[0, 10], [0.0, 1.0], ["cat", "dog"]])
+    suggestor = LHSSuggestor(
+        space, rng=np.random.default_rng(1), n_points=5
+    )
+    suggestions = suggestor.suggest([], [])
+    assert len(suggestions) == 1
+    assert len(suggestions[0]) == 3
+    assert suggestions[0] in space
+    suggestions = suggestor.suggest([], [], n_asked=5)
+    # Testing that the values for each dimension is regularly spaced over the range
+    assert set(suggestion[0] for suggestion in suggestions) == {1, 3, 5, 7, 9}
+    assert set(suggestion[1] for suggestion in suggestions) == {0.1, 0.3, 0.5, 0.7, 0.9}
+    assert set(suggestion[2] for suggestion in suggestions) == {"cat", "dog"}
+
+
+def test_suggest_too_many():
+    space = space_factory([[0, 10], [0.0, 1.0], ["cat", "dog"]])
+    suggestor = LHSSuggestor(
+        space, rng=np.random.default_rng(1), n_points=5
+    )
+    for n_told in range(1, 5):
+        told = suggestor.suggest([], [], n_asked=n_told)
+        suggestor.suggest(told, [0]*n_told, n_asked=1)
+    with pytest.raises(IncompatibleNumberAsked):
+        suggestor.suggest([], [], n_asked=6)
+    with pytest.raises(IncompatibleNumberAsked):
+        suggestor.suggest([[1, 0.0, "cat"]], [1], n_asked=5)
+
+
+def test_n():
+    space = space_factory([[0, 10], [0.0, 1.0], ["cat", "dog"]])
+    for n in range(1, 10):
+        suggestor = LHSSuggestor(space, rng=np.random.default_rng(1), n_points=n)
+        assert suggestor.n_points == n
+        assert len(suggestor.cache) == n

ProcessOptimizer/tests/test_suggestors/test_po_suggestor.py

@@ -0,0 +1,37 @@
+import numpy as np
+from XpyriMentor.suggestors import POSuggestor, suggestor_factory
+from ProcessOptimizer.space import space_factory
+
+
+def test_initialization():
+    space = space_factory([[0, 1], [0, 1]])
+    suggestor = POSuggestor(space, rng=np.random.default_rng(1))
+    assert isinstance(suggestor, POSuggestor)
+    assert suggestor.optimizer._n_initial_points == 0
+    nonstandard_suggestor = POSuggestor(
+        space, rng=np.random.default_rng(1), n_initial_points=5
+    )
+    assert nonstandard_suggestor.optimizer._n_initial_points == 5
+
+
+def test_factory():
+    space = space_factory([[0, 1], [0, 1]])
+    suggestor = suggestor_factory(
+        space=space,
+        definition={"name": "PO"},
+    )
+    assert isinstance(suggestor, POSuggestor)
+    assert suggestor.optimizer._n_initial_points == 0
+
+
+def test_suggest():
+    space = space_factory([[0, 1], [0, 1]])
+    suggestor = POSuggestor(space, rng=np.random.default_rng(1))
+    suggestions = suggestor.suggest([[1, 1]], [1])
+    assert len(suggestions) == 1
+    assert len(suggestions[0]) == 2
+    assert suggestions[0] in space
+    suggestions = suggestor.suggest([[1, 1]], [1], n_asked=5)
+    assert len(suggestions) == 5
+    for suggestion in suggestions:
+        assert suggestion in space