feature/libe_gen_wrapper + Feature/asktell aposmm

examples/dummy_aposmm_libE_gen/run_example.py

@@ -0,0 +1,101 @@
+"""Basic example of parallel random sampling with simulations."""
+
+from math import gamma, pi, sqrt
+import numpy as np
+from libensemble.generators import APOSMM
+import libensemble.gen_funcs
+
+libensemble.gen_funcs.rc.aposmm_optimizers = "nlopt"
+from optimas.core import VaryingParameter, Objective
+from libensemble.tests.regression_tests.support import (
+    six_hump_camel_minima as minima,
+)
+
+# from optimas.generators import RandomSamplingGenerator
+from optimas.generators import APOSMMWrapper
+from optimas.evaluators import TemplateEvaluator
+from optimas.explorations import Exploration
+
+from multiprocessing import set_start_method
+
+set_start_method("fork", force=True)
+
+
+def analyze_simulation(simulation_directory, output_params):
+    """Analyze the simulation output.
+
+    This method analyzes the output generated by the simulation to
+    obtain the value of the optimization objective and other analyzed
+    parameters, if specified. The value of these parameters has to be
+    given to the `output_params` dictionary.
+
+    Parameters
+    ----------
+    simulation_directory : str
+        Path to the simulation folder where the output was generated.
+    output_params : dict
+        Dictionary where the value of the objectives and analyzed parameters
+        will be stored. There is one entry per parameter, where the key
+        is the name of the parameter given by the user.
+
+    Returns
+    -------
+    dict
+        The `output_params` dictionary with the results from the analysis.
+
+    """
+    # Read back result from file
+    with open("result.txt") as f:
+        result = float(f.read())
+    # Fill in output parameters.
+    output_params["f"] = result
+    return output_params
+
+
+# Create varying parameters and objectives.
+var_1 = VaryingParameter("x0", -3.0, 3.0)
+var_2 = VaryingParameter("x1", -2.0, 2.0)
+obj = Objective("f")
+
+n = 2
+
+aposmm = APOSMM(
+    initial_sample_size=100,
+    localopt_method="LN_BOBYQA",
+    sample_points=np.round(minima, 1),
+    rk_const=0.5 * ((gamma(1 + (n / 2)) * 5) ** (1 / n)) / sqrt(pi),
+    xtol_abs=1e-2,
+    ftol_abs=1e-2,
+    dist_to_bound_multiple=0.5,
+    max_active_runs=4,  # refers to APOSMM's simul local optimization runs
+    lb=np.array([var_1.lower_bound, var_2.lower_bound]),
+    ub=np.array([var_1.upper_bound, var_2.upper_bound]),
+)
+
+gen = APOSMMWrapper(
+    varying_parameters=[var_1, var_2],
+    objectives=[obj],
+    libe_gen=aposmm,
+)
+
+# Create evaluator.
+ev = TemplateEvaluator(
+    sim_template="template_simulation_script.py",
+    analysis_func=analyze_simulation,
+)
+
+
+# Create exploration.
+exp = Exploration(
+    generator=gen, evaluator=ev, max_evals=300, sim_workers=4, run_async=True
+)
+
+
+# To safely perform exploration, run it in the block below (this is needed
+# for some flavours of multiprocessing, namely spawn and forkserver)
+if __name__ == "__main__":
+    exp.run(100)
+    exp.run(200)
+    exp.finalize()
+    assert len(gen.libe_gen.all_local_minima)
+    print(f"Found {len(gen.libe_gen.all_local_minima)} minima!")

examples/dummy_aposmm_libE_gen/template_simulation_script.py

@@ -0,0 +1,22 @@
+"""Simple template script used for demonstration.
+
+The script evaluates an analytical expression and stores the results in a
+`result.txt` file that is later read by the analysis function.
+"""
+
+import numpy as np
+
+# 2D function with multiple minima
+# result = -({{x0}} + 10 * np.cos({{x0}})) * ({{x1}} + 5 * np.cos({{x1}}))
+
+x1 = {{x0}}
+x2 = {{x1}}
+
+term1 = (4 - 2.1 * x1**2 + (x1**4) / 3) * x1**2
+term2 = x1 * x2
+term3 = (-4 + 4 * x2**2) * x2**2
+
+result = term1 + term2 + term3
+
+with open("result.txt", "w") as f:
+    f.write("%f" % result)

examples/dummy_random_libEgen/run_example.py

@@ -0,0 +1,76 @@
+"""Basic example of parallel random sampling with simulations."""
+
+from libensemble.gen_funcs.persistent_sampling import RandSample
+from optimas.core import VaryingParameter, Objective
+
+# from optimas.generators import RandomSamplingGenerator
+from optimas.generators import libEWrapper
+from optimas.evaluators import TemplateEvaluator
+from optimas.explorations import Exploration
+
+
+def analyze_simulation(simulation_directory, output_params):
+    """Analyze the simulation output.
+
+    This method analyzes the output generated by the simulation to
+    obtain the value of the optimization objective and other analyzed
+    parameters, if specified. The value of these parameters has to be
+    given to the `output_params` dictionary.
+
+    Parameters
+    ----------
+    simulation_directory : str
+        Path to the simulation folder where the output was generated.
+    output_params : dict
+        Dictionary where the value of the objectives and analyzed parameters
+        will be stored. There is one entry per parameter, where the key
+        is the name of the parameter given by the user.
+
+    Returns
+    -------
+    dict
+        The `output_params` dictionary with the results from the analysis.
+
+    """
+    # Read back result from file
+    with open("result.txt") as f:
+        result = float(f.read())
+    # Fill in output parameters.
+    output_params["f"] = result
+    return output_params
+
+
+# Create varying parameters and objectives.
+var_1 = VaryingParameter("x0", 0.0, 15.0)
+var_2 = VaryingParameter("x1", 0.0, 15.0)
+obj = Objective("f")
+
+
+# Create generator.
+# gen = RandomSamplingGenerator(
+#     varying_parameters=[var_1, var_2], objectives=[obj], distribution="normal"
+# )
+
+gen = libEWrapper(
+    varying_parameters=[var_1, var_2],
+    objectives=[obj],
+    libe_gen=RandSample,
+)
+
+# Create evaluator.
+ev = TemplateEvaluator(
+    sim_template="template_simulation_script.py",
+    analysis_func=analyze_simulation,
+)
+
+
+# Create exploration.
+exp = Exploration(
+    generator=gen, evaluator=ev, max_evals=10, sim_workers=4, run_async=True
+)
+
+
+# To safely perform exploration, run it in the block below (this is needed
+# for some flavours of multiprocessing, namely spawn and forkserver)
+if __name__ == "__main__":
+    exp.run()

examples/dummy_random_libEgen/template_simulation_script.py

@@ -0,0 +1,13 @@
+"""Simple template script used for demonstration.
+
+The script evaluates an analytical expression and stores the results in a
+`result.txt` file that is later read by the analysis function.
+"""
+
+import numpy as np
+
+# 2D function with multiple minima
+result = -({{x0}} + 10 * np.cos({{x0}})) * ({{x1}} + 5 * np.cos({{x1}}))
+
+with open("result.txt", "w") as f:
+    f.write("%f" % result)

optimas/explorations/base.py

@@ -16,6 +16,7 @@
 from libensemble.executors.mpi_executor import MPIExecutor
 
 from optimas.core.trial import TrialStatus
+from optimas.generators.libE_wrapper import libEWrapper
 from optimas.generators.base import Generator
 from optimas.evaluators.base import Evaluator
 from optimas.evaluators.function_evaluator import FunctionEvaluator
@@ -220,6 +221,13 @@ def run(self, n_evals: Optional[int] = None) -> None:
         # Reset `cwd` to initial value before `libE` was called.
         os.chdir(cwd)
 
+    def finalize(self) -> None:
+        """Finalize the exploration, cleanup generator."""
+        if isinstance(self.generator, libEWrapper):
+            self.generator.libe_gen.final_tell(
+                self._libe_history.H[["sim_id", "f"]]
+            )
+
     def attach_trials(
         self,
         trial_data: Union[Dict, List[Dict], np.ndarray, pd.DataFrame],

optimas/gen_functions.py

@@ -48,6 +48,10 @@ def persistent_generator(H, persis_info, gen_specs, libE_info):
 
     # Get generator, objectives, and parameters to analyze.
     generator = gen_specs["user"]["generator"]
+
+    if hasattr(generator, "libe_gen"):
+        generator.init_libe_gen(H, persis_info, gen_specs, libE_info)
+
     objectives = generator.objectives
     analyzed_parameters = generator.analyzed_parameters
 
@@ -109,6 +113,7 @@ def persistent_generator(H, persis_info, gen_specs, libE_info):
                         y = calc_in[par.name][i]
                         ev = Evaluation(parameter=par, value=y)
                         trial.complete_evaluation(ev)
+                trial.libE_calc_in = calc_in[i]
                 # Register trial with unknown SEM
                 generator.tell([trial])
             # Set the number of points to generate to that number:

optimas/generators/__init__.py

@@ -22,6 +22,8 @@
 from .grid_sampling import GridSamplingGenerator
 from .line_sampling import LineSamplingGenerator
 from .random_sampling import RandomSamplingGenerator
+from .libE_wrapper import libEWrapper
+from .aposmm import APOSMMWrapper
 
 
 __all__ = [
@@ -32,4 +34,6 @@
     "GridSamplingGenerator",
     "LineSamplingGenerator",
     "RandomSamplingGenerator",
+    "libEWrapper",
+    "APOSMMWrapper",
 ]

optimas/generators/aposmm.py

@@ -0,0 +1,104 @@
+import numpy as np
+from typing import List
+
+from libensemble.generators import LibEnsembleGenInterfacer
+
+from optimas.core import (
+    Objective,
+    Trial,
+    VaryingParameter,
+    Parameter,
+    TrialParameter,
+)
+from .libE_wrapper import libEWrapper
+
+
+class APOSMMWrapper(libEWrapper):
+    """
+    Wraps a live, parameterized APOSMM generator instance. Note that .tell() parameters
+    are internally cached until either the initial sample or N points (for N local-optimization processes)
+    are evaluated.
+    """
+
+    def __init__(
+        self,
+        varying_parameters: List[VaryingParameter],
+        objectives: List[Objective],
+        libe_gen=None,
+    ) -> None:
+        custom_trial_parameters = [
+            TrialParameter(
+                "x_on_cube", dtype=(float, (len(varying_parameters),))
+            ),
+            TrialParameter("local_pt", dtype=bool),
+        ]
+        super().__init__(
+            varying_parameters=varying_parameters,
+            objectives=objectives,
+            custom_trial_parameters=custom_trial_parameters,
+            libe_gen=libe_gen,
+        )
+        self.libe_gen = libe_gen
+        self.num_evals = 0
+        self._told_initial_sample = False
+
+    def _slot_in_data(self, trial):
+        """Slot in libE_calc_in and trial data into corresponding array fields."""
+        self.new_array["f"][self.num_evals] = trial.libE_calc_in["f"]
+        self.new_array["x"][self.num_evals] = trial.parameter_values
+        self.new_array["sim_id"][self.num_evals] = trial.libE_calc_in["sim_id"]
+        self.new_array["x_on_cube"][self.num_evals] = trial.x_on_cube
+        self.new_array["local_pt"][self.num_evals] = trial.local_pt
+
+    @property
+    def _array_size(self):
+        """Output array size must match either initial sample or N points to evaluate in parallel."""
+        user = self.libe_gen.gen_specs["user"]
+        return (
+            user["initial_sample_size"]
+            if not self._told_initial_sample
+            else user["max_active_runs"]
+        )
+
+    @property
+    def _enough_initial_sample(self):
+        """We're typically happy with at least 90% of the initial sample."""
+        return self.num_evals > int(
+            0.9 * self.libe_gen.gen_specs["user"]["initial_sample_size"]
+        )
+
+    @property
+    def _enough_subsequent_points(self):
+        """But we need to evaluate at least N points, for the N local-optimization processes."""
+        return (
+            self.num_evals >= self.libe_gen.gen_specs["user"]["max_active_runs"]
+        )
+
+    def _ask(self, trials: List[Trial]) -> List[Trial]:
+        """Fill in the parameter values of the requested trials."""
+        n_trials = len(trials)
+        gen_out = self.libe_gen.ask(n_trials)
+
+        for i, trial in enumerate(trials):
+            trial.parameter_values = gen_out[i]["x"]
+            trial.x_on_cube = gen_out[i]["x_on_cube"]
+            trial.local_pt = gen_out[i]["local_pt"]
+
+        return trials
+
+    def _tell(self, trials: List[Trial]) -> None:
+        """Pass objective values to generator, slotting/caching into APOSMM's expected results array."""
+        trial = trials[0]
+        if self.num_evals == 0:
+            self.new_array = self.libe_gen.create_results_array(
+                self._array_size, empty=True
+            )
+        self._slot_in_data(trial)
+        self.num_evals += 1
+        if not self._told_initial_sample and self._enough_initial_sample:
+            self.libe_gen.tell(self.new_array)
+            self._told_initial_sample = True
+            self.num_evals = 0
+        elif self._told_initial_sample and self._enough_subsequent_points:
+            self.libe_gen.tell(self.new_array)
+            self.num_evals = 0  # reset, create a new array next time around