[WIP] Enable using Xopt generators in optimas

optimas/generators/xopt/__init__.py

@@ -0,0 +1 @@
+from .nelder_mead import NelderMeadGenerator

optimas/generators/xopt/nelder_mead.py

@@ -0,0 +1,74 @@
+from typing import List, Optional
+
+import numpy as np
+import pandas as pd
+
+from xopt import VOCS
+from xopt.generators.scipy.neldermead import (
+ NelderMeadGenerator as XoptNelderMeadGenerator,
+)
+
+from optimas.core import (
+ Objective,
+ VaryingParameter,
+ Parameter,
+ Evaluation,
+ Trial,
+)
+from optimas.generators.base import Generator
+
+
+class NelderMeadGenerator(Generator):
+ def __init__(
+ self,
+ varying_parameters: List[VaryingParameter],
+ objectives: List[Objective],
+ analyzed_parameters: Optional[List[Parameter]] = None,
+ save_model: Optional[bool] = False,
+ model_save_period: Optional[int] = 5,
+ model_history_dir: Optional[str] = "model_history",
+ ) -> None:
+ super().__init__(
+ varying_parameters=varying_parameters,
+ objectives=objectives,
+ analyzed_parameters=analyzed_parameters,
+ save_model=save_model,
+ model_save_period=model_save_period,
+ model_history_dir=model_history_dir,
+ )
+ self._create_xopt_generator()
+
+ def _ask(self, trials: List[Trial]) -> List[Trial]:
+ n_trials = len(trials)
+ xopt_trials = self.xopt_gen.generate(n_trials)
+ if xopt_trials:
+ for trial, xopt_trial in zip(trials, xopt_trials):
+ trial.parameter_values = [
+ xopt_trial[var.name] for var in self.varying_parameters
+ ]
+ return trials
+
+ def _tell(self, trials: List[Trial]) -> None:
+ # pd.DataFrame({"x1": [0.5], "x2": [5.0], "y1": [0.5], "c1": [0.5]})
+ for trial in trials:
+ data = {}
+ for oe in trial.objective_evaluations:
+ data[oe.parameter.name] = [oe.value]
+ df = pd.DataFrame(data)
+ self.xopt_gen.add_data(df)
+
+ def _create_xopt_generator(self):
+ variables = {}
+ for var in self.varying_parameters:
+ variables[var.name] = [var.lower_bound, var.upper_bound]
+ objectives = {}
+ for objective in self.objectives:
+ name = objective.name
+ objectives[name] = "MINIMIZE" if objective.minimize else "MAXIMIZE"
+ vocs = VOCS(variables=variables, objectives=objectives)
+ initial_point = {}
+ for var in self.varying_parameters:
+ initial_point[var.name] = (var.lower_bound + var.upper_bound) / 2
+ self.xopt_gen = XoptNelderMeadGenerator(
+ vocs=vocs, initial_point=initial_point
+ )

tests/test_neldermead.py

@@ -0,0 +1,68 @@
+import numpy as np
+
+from optimas.explorations import Exploration
+from optimas.generators.xopt import NelderMeadGenerator
+from optimas.evaluators import FunctionEvaluator
+from optimas.core import VaryingParameter, Objective
+
+
+def eval_func(input_params, output_params):
+ """Evaluation function for single-fidelity test"""
+ x0 = input_params["x0"]
+ x1 = input_params["x1"]
+ result = -(x0 + 10 * np.cos(x0)) * (x1 + 5 * np.cos(x1))
+ output_params["f"] = result
+
+
+def test_neldermead():
+ """Test that grid sampling generates the expected configurations."""
+
+ # Create varying parameters.
+ names = ["x0", "x1"]
+ lower_bounds = [-3.0, 2.0]
+ upper_bounds = [1.0, 5.0]
+ vars = []
+ n_steps = [7, 15]
+ for name, lb, ub in zip(names, lower_bounds, upper_bounds):
+ vars.append(VaryingParameter(name, lb, ub))
+
+ # Set number of evaluations.
+ n_evals = np.prod(n_steps)
+
+ # Define objective.
+ obj = Objective("f", minimize=False)
+
+ # Create generator and run exploration.
+ gen = NelderMeadGenerator(varying_parameters=vars, objectives=[obj])
+ ev = FunctionEvaluator(function=eval_func)
+ exploration = Exploration(
+ generator=gen,
+ evaluator=ev,
+ max_evals=n_evals,
+ sim_workers=1,
+ exploration_dir_path="./tests_output/test_neldermead",
+ )
+ exploration.run()
+
+ # Get generated points.
+ h = exploration.history
+ h = h[h["sim_ended"]]
+ x0_gen = h["x0"]
+ x1_gen = h["x1"]
+
+ # Get expected 1D steps along each variable.
+ x0_steps = np.linspace(lower_bounds[0], upper_bounds[0], n_steps[0])
+ x1_steps = np.linspace(lower_bounds[1], upper_bounds[1], n_steps[1])
+
+ # Check that the scan along each variable is as expected.
+ np.testing.assert_array_equal(np.unique(x0_gen), x0_steps)
+ np.testing.assert_array_equal(np.unique(x1_gen), x1_steps)
+
+ # Check that for every x0 step, the expected x1 steps are performed.
+ for x0_step in x0_steps:
+ x1_in_x0_step = x1_gen[x0_gen == x0_step]
+ np.testing.assert_array_equal(x1_in_x0_step, x1_steps)
+
+
+if __name__ == "__main__":
+ test_neldermead()