Make scikit-learn optional

Author: weslleyspereira

.github/workflows/python-package.yml

@@ -37,7 +37,7 @@ jobs:
       - name: Install dependencies
         run: |
           python -m pip install --upgrade pip
-          pip install -e .
+          pip install -e .[nomad,sklearn]
       - name: Lint with ruff
         run: |
           python -m pip install flake8 jupyter
@@ -47,7 +47,7 @@ jobs:
           flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics
       - name: Install test dependencies
         run: |
-          python -m pip install pytest pytest-timeout PyNomadBBO pygoblet
+          python -m pip install pytest pytest-timeout pygoblet
           python -m pip list
       - name: Test with pytest (fast tests)
         run: |

examples/vlse_benchmark/vlse_bench.py

@@ -200,11 +200,6 @@ def run_optimizer(
         )
     ),
 }
-algorithms["GP"] = {
-    "model": gp.GaussianProcess(normalize_y=True, random_state=42),
-    "optimizer": optimize.bayesian_optimization,
-    "acquisition": acquisition.MaximizeEI(seed=42),
-}
 
 # Maximum number of evaluations per function. 100*n, where n is the input
 # dimension

pdm.lock

@@ -22,11 +22,14 @@ dependencies = [
     "numpy",
     "scipy",
     "pymoo",
-    "scikit-learn",
     "autograd",
     "networkx",
 ]
 
+[project.optional-dependencies]
+nomad = ["PyNomadBBO"]
+sklearn = ["scikit-learn"]
+
 [project.urls]
 Homepage = "https://github.com/NREL/soogo"
 Docs = "https://nrel.github.io/soogo"

pyproject.toml

@@ -22,12 +22,18 @@
 import scipy.optimize as scipy_opt
 
 # Scikit-learn imports
-from sklearn.exceptions import ConvergenceWarning
-from sklearn.gaussian_process import GaussianProcessRegressor
-from sklearn.gaussian_process.kernels import (
-    RBF as GPkernelRBF,
-    ConstantKernel as GPConstantKernel,
-)
+try:
+    from sklearn.exceptions import ConvergenceWarning
+    from sklearn.gaussian_process import GaussianProcessRegressor
+    from sklearn.gaussian_process.kernels import (
+        RBF as GPkernelRBF,
+        ConstantKernel as GPConstantKernel,
+    )
+except ImportError:
+    GaussianProcessRegressor = None
+    GPkernelRBF = None
+    GPConstantKernel = None
+    ConvergenceWarning = None
 
 # Local imports
 from .base import Surrogate
@@ -64,6 +70,11 @@ class GaussianProcess(Surrogate):
     """
 
     def __init__(self, scaler=None, **kwargs) -> None:
+        if GaussianProcessRegressor is None:
+            raise ImportError(
+                "scikit-learn is required to use the GaussianProcess surrogate model."
+            )
+
         super().__init__()
 
         # Scaler for x
@@ -167,7 +178,7 @@ def min_design_space_size(self, dim: int) -> int:
         """Return the minimum design space size for a given space dimension."""
         return 1 if dim > 0 else 0
 
-    def check_initial_design(self, _sample: np.ndarray) -> int:
+    def check_initial_design(self, sample: np.ndarray) -> int:
         return 0
 
     def update(self, Xnew, ynew) -> None:

soogo/model/gp.py

@@ -25,7 +25,10 @@
 @pytest.mark.parametrize("n", (10, 100))
 @pytest.mark.parametrize("copy_X_train", (True, False))
 def test_X(n: int, copy_X_train: bool):
-    gp = GaussianProcess(copy_X_train=copy_X_train)
+    try:
+        gp = GaussianProcess(copy_X_train=copy_X_train)
+    except ImportError:
+        pytest.skip("GaussianProcess could not be imported, likely because scikit-learn is not installed.")
 
     X0 = np.random.rand(n, 3)
     y = np.random.rand(n)

tests/model/test_gp.py

@@ -38,8 +38,11 @@ def test_rbf_model_is_surrogate():
 
 def test_gaussian_process_is_surrogate():
     """Test that GaussianProcess is a subclass of Surrogate."""
-    gp = GaussianProcess()
-    assert isinstance(gp, Surrogate)
+    try:
+        gp = GaussianProcess()
+        assert isinstance(gp, Surrogate)
+    except ImportError:
+        pytest.skip("GaussianProcess could not be imported, likely because scikit-learn is not installed.")
 
 
 def test_surrogate_interface_methods():
@@ -67,21 +70,24 @@ def test_surrogate_interface_methods():
     assert distances.shape == (1, 3)
 
     # Test Gaussian Process
-    gp = GaussianProcess()
-
-    # Test all required methods exist and work
-    gp.update(x_train, y_train)
-    assert gp.ntrain == 3
-    assert gp.X.shape == (3, 2)
-    assert gp.Y.shape == (3,)
-    assert gp.min_design_space_size(2) >= 0
-    assert gp.check_initial_design(x_train) == 0
-    assert isinstance(gp.iindex, tuple)
-
-    # Test prediction
-    y_pred, y_std = gp(x_test, return_std=True)
-    assert y_pred.shape == (1,)
-    assert y_std.shape == (1,)
+    try:
+        gp = GaussianProcess()
+
+        # Test all required methods exist and work
+        gp.update(x_train, y_train)
+        assert gp.ntrain == 3
+        assert gp.X.shape == (3, 2)
+        assert gp.Y.shape == (3,)
+        assert gp.min_design_space_size(2) >= 0
+        assert gp.check_initial_design(x_train) == 0
+        assert isinstance(gp.iindex, tuple)
+
+        # Test prediction
+        y_pred, y_std = gp(x_test, return_std=True)
+        assert y_pred.shape == (1,)
+        assert y_std.shape == (1,)
+    except ImportError:
+        pass  # If scikit-learn is not installed, this will fail, but that's expected
 
 
 if __name__ == "__main__":

tests/model/test_surrogate.py

@@ -296,15 +296,16 @@ def test_module_imports_in_docs(self):
             # Basic smoke test - instantiate some classes
             rbf_model = RbfModel()
             assert rbf_model is not None
-
-            gp_model = GaussianProcess()
-            assert gp_model is not None
-
-            # Test that classes and functions have expected attributes
             assert hasattr(WeightedAcquisition, "optimize")
             assert hasattr(OptimizeResult, "__init__")
             assert callable(surrogate_optimization)
-            assert callable(bayesian_optimization)
+
+            try:
+                gp_model = GaussianProcess()
+                assert gp_model is not None
+                assert callable(bayesian_optimization)
+            except ImportError:
+                pass # If scikit-learn is not installed, this will fail, but that's expected
 
         except ImportError as e:
             pytest.fail(

tests/test_docs.py

@@ -279,7 +279,6 @@ def test_examples_import_soogo(self):
             from soogo import gosac, socemo, surrogate_optimization  # noqa: F401
             from soogo import RbfModel  # noqa: F401
             from soogo import acquisition, sampling  # noqa: F401
-            # Note: GaussianProcess import might fail in some environments
         except ImportError as e:
             pytest.fail(f"Failed to import required modules: {e}")
 

tests/test_examples.py

@@ -67,13 +67,15 @@ def callback(intermediate_result: OptimizeResult):
         assert (
             intermediate_result.sample.shape[1] == intermediate_result.x.size
         )
-
-    minimize(
-        lambda x: np.sum(x**2, axis=1),
-        ((-10, 3), (-1, 1)),
-        maxeval=10,
-        callback=callback,
-    )
+    try:
+        minimize(
+            lambda x: np.sum(x**2, axis=1),
+            ((-10, 3), (-1, 1)),
+            maxeval=10,
+            callback=callback,
+        )
+    except ImportError:
+        pytest.skip(f"{minimize.__name__} requires additional dependencies that are not installed.")
 
 
 @pytest.mark.parametrize(
@@ -104,16 +106,18 @@ def ackley(x, n: int = 2):
         )
 
     bounds = [[-32.768, 20], [-32.768, 32.768]]
+    try:
+        res0 = minimize(lambda x: [ackley(x[0], 2)], bounds, maxeval=10, seed=123)
+        res1 = minimize(lambda x: [ackley(x[0], 2)], bounds, maxeval=10, seed=123)
 
-    res0 = minimize(lambda x: [ackley(x[0], 2)], bounds, maxeval=10, seed=123)
-    res1 = minimize(lambda x: [ackley(x[0], 2)], bounds, maxeval=10, seed=123)
-
-    assert np.all(res0.x == res1.x)
-    assert np.all(res0.fx == res1.fx)
-    assert res0.nit == res1.nit
-    assert res0.nfev == res1.nfev
-    assert np.all(res0.sample == res1.sample)
-    assert np.all(res0.fsample == res1.fsample)
+        assert np.all(res0.x == res1.x)
+        assert np.all(res0.fx == res1.fx)
+        assert res0.nit == res1.nit
+        assert res0.nfev == res1.nfev
+        assert np.all(res0.sample == res1.sample)
+        assert np.all(res0.fsample == res1.fsample)
+    except ImportError:
+        pytest.skip(f"{minimize.__name__} requires additional dependencies that are not installed.")
 
 
 def test_batched_sampling():
@@ -133,11 +137,14 @@ def ackley(x, n: int = 2):
 
     bounds = [[-32.768, 20], [-32.768, 32.768]]
 
-    out = bayesian_optimization(
-        lambda x: [ackley(xi - 3.14) for xi in x],
-        bounds=bounds,
-        maxeval=100,
-        batchSize=10,
-        acquisitionFunc=MaximizeEI(pool_size=200, avoid_clusters=True),
-    )
-    assert out.nfev == 100
+    try:
+        out = bayesian_optimization(
+            lambda x: [ackley(xi - 3.14) for xi in x],
+            bounds=bounds,
+            maxeval=100,
+            batchSize=10,
+            acquisitionFunc=MaximizeEI(pool_size=200, avoid_clusters=True),
+        )
+        assert out.nfev == 100
+    except ImportError:
+        pytest.skip("scikit-learn is not installed, skipping Bayesian optimization tests.")