Egor driver (#6)

* Add initial basic implementation of Egor driver

* Fix sego API change

* Fix test due to remove file pb?

* Add tests for Egor driver

* Bump 1.1.0

* Add egobox in requirements

* Re activate black check

* black format

* Use development mode for test

* Make codacy happy

Author: relf

.github/workflows/tests.yml

@@ -26,10 +26,10 @@ jobs:
         python -m pip install --upgrade pip
         python -m pip install black pytest
         if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
-        pip install .
-#    - name: Format with black
-#      run: |
-#        black --check .
+        pip install -e .
+    - name: Format with black
+      run: |
+        black --check .
     - name: Test with pytest
       run: |
         pytest

.gitignore

@@ -104,3 +104,6 @@ venv.bak/
 
 # mypy
 .mypy_cache/
+
+# ignore openmdao reports
+**/reports

README.md

@@ -6,6 +6,7 @@
 
 Set of specialized classes to handle specific methods using OpenMDAO framework.
 
+*   <code>EgoboxEgorDriver</code> : an OpenMDAO driver for Egor optimizer from [Egobox](https://github.com/relf/egobox#egobox) library 
 *   <code>OneraSegoDriver</code> : an OpenMDAO driver for Onera Super EGO optimizers 
 *   <code>SmtDoeDriver</code> : an OpenMDAO driver for sampling methods from surrogate [SMT](https://smt.readthedocs.io/en/latest/) library 
 *   <code>SalibDoeDriver</code> : an OpenMDAO driver for Morris or Saltelli DoE from sensitive analysis [SALib](https://salib.readthedocs.io/en/latest/) library 

openmdao_extensions/egobox_egor_driver.py

@@ -0,0 +1,253 @@
+import numpy as np
+import traceback
+
+from openmdao.core.driver import Driver, RecordingDebugging
+from openmdao.core.analysis_error import AnalysisError
+
+EGOBOX_NOT_INSTALLED = False
+try:
+    import egobox as egx
+    from egobox import Egor
+except ImportError:
+    EGOBOX_NOT_INSTALLED = True
+
+
+def to_list(l, size):
+    if not (isinstance(l, np.ndarray) or isinstance(l, list)):
+        return [l] * size
+    diff_len = len(l) - size
+    if diff_len > 0:
+        return l[0:size]
+    elif diff_len < 0:
+        return [l[0]] * size
+    else:
+        return l
+
+
+class EgoboxEgorDriver(Driver):
+    """OpenMDAO driver for egobox optimizer"""
+
+    def __init__(self, **kwargs):
+        """Initialize the driver with the given options."""
+        super(EgoboxEgorDriver, self).__init__(**kwargs)
+
+        if EGOBOX_NOT_INSTALLED:
+            raise RuntimeError("egobox library is not installed.")
+
+        # What we support
+        self.supports["inequality_constraints"] = True
+        self.supports["linear_constraints"] = True
+
+        # What we don't support
+        self.supports["equality_constraints"] = False
+        self.supports["two_sided_constraints"] = False
+        self.supports["multiple_objectives"] = False
+        self.supports["active_set"] = False
+        self.supports["simultaneous_derivatives"] = False
+        self.supports["total_jac_sparsity"] = False
+        self.supports["gradients"] = False
+        self.supports["integer_design_vars"] = False
+
+        self.opt_settings = {}
+
+    def _declare_options(self):
+        self.options.declare(
+            "optimizer",
+            default="EGOR",
+            values=["EGOR"],
+            desc="Name of optimizer to use",
+        )
+
+    def _setup_driver(self, problem):
+        super(EgoboxEgorDriver, self)._setup_driver(problem)
+
+        self.comm = None
+
+    def run(self):
+        model = self._problem().model
+
+        self.iter_count = 0
+        self.name = "egobox_optimizer_egor"
+
+        # Initial Run
+        with RecordingDebugging(
+            self.options["optimizer"], self.iter_count, self
+        ) as rec:
+            # Initial Run
+            model._solve_nonlinear()
+            rec.abs = 0.0
+            rec.rel = 0.0
+        self.iter_count += 1
+
+        # Format design variables to suit segomoe implementation
+        self.xspecs = self._initialize_vars()
+
+        # Format constraints to suit segomoe implementation
+        self.n_cstr = self._initialize_cons()
+
+        # Format option dictionary to suit Egor implementation
+        optim_settings = {
+            "cstr_tol": 1e-6,
+        }
+        n_iter = self.opt_settings["maxiter"]
+        optim_settings.update(
+            {k: v for k, v in self.opt_settings.items() if k != "maxiter"}
+        )
+
+        dim = 0
+        for name, meta in self._designvars.items():
+            dim += meta["size"]
+        print("Designvars dimension: ", dim)
+        if dim > 10:
+            self.optim_settings["kpls_dim"] = 3
+
+        # Instanciate a SEGO optimizer
+        egor = Egor(
+            self._objfunc,
+            xspecs=self.xspecs,
+            n_cstr=self.n_cstr,
+            **optim_settings,
+        )
+
+        # Run the optim
+        res = egor.minimize(n_eval=n_iter)
+
+        # Set optimal parameters
+        i = 0
+        for name, meta in self._designvars.items():
+            size = meta["size"]
+            self.set_design_var(name, res.x_opt[i : i + size])
+            i += size
+
+        with RecordingDebugging(
+            self.options["optimizer"], self.iter_count, self
+        ) as rec:
+            model._solve_nonlinear()
+            rec.abs = 0.0
+            rec.rel = 0.0
+        self.iter_count += 1
+
+        return True
+
+    def _initialize_vars(self):
+        variables = []
+        desvars = self._designvars
+        for _, meta in desvars.items():
+            if meta["size"] > 1:
+                if np.isscalar(meta["lower"]):
+                    variables += [
+                        egx.Vspec(
+                            egx.Vtype(egx.Vtype.FLOAT), [meta["lower"], meta["upper"]]
+                        )
+                        for i in range(meta["size"])
+                    ]
+                else:
+                    variables += [
+                        egx.Vspec(
+                            egx.Vtype(egx.Vtype.FLOAT), [meta["lower"], meta["upper"]]
+                        )
+                        for i in range(meta["size"])
+                    ]
+            else:
+                variables += [
+                    egx.Vspec(
+                        egx.Vtype(egx.Vtype.FLOAT), [meta["lower"], meta["upper"]]
+                    )
+                ]
+        return variables
+
+    def _initialize_cons(self, eq_tol=None, ieq_tol=None):
+        """Format OpenMDAO constraints to suit EGOR implementation
+
+        Parameters
+        ----------
+        eq_tol: dict
+            Dictionary to define specific tolerance for eq constraints
+            {'[groupName]': [tol]} Default tol = 1e-5
+        """
+        con_meta = self._cons
+
+        self.ieq_cons = {
+            name: con for name, con in con_meta.items() if not con["equals"]
+        }
+
+        # Inequality constraints
+        n_cstr = 0
+        for name in self.ieq_cons.keys():
+            meta = con_meta[name]
+            size = meta["size"]
+            # Bounds - double sided is supported
+            lower = to_list(meta["lower"], size)
+            upper = to_list(meta["upper"], size)
+            for k in range(size):
+                if (lower[k] is None or lower[k] < -1e29) and upper[k] == 0.0:
+                    n_cstr += 1
+                else:
+                    raise ValueError(
+                        f"Constraint {lower[k]} < g(x) < {upper[k]} not handled by Egor driver"
+                    )
+        return n_cstr
+
+    def _objfunc(self, points):
+        """
+        Function that evaluates and returns the objective function and the
+        constraints. This function is called by SEGOMOE
+
+        Parameters
+        ----------
+        point : numpy.ndarray
+            point to evaluate
+
+        Returns
+        -------
+        func_dict : dict
+            Dictionary of all functional variables evaluated at design point.
+        fail : int
+            0 for successful function evaluation
+            1 for unsuccessful function evaluation
+        """
+        res = np.zeros((points.shape[0], 1 + self.n_cstr))
+        model = self._problem().model
+
+        for k, point in enumerate(points):
+            try:
+                # Pass in new parameters
+                i = 0
+
+                for name, meta in self._designvars.items():
+                    size = meta["size"]
+                    self.set_design_var(name, point[i : i + size])
+                    i += size
+
+                # Execute the model
+                with RecordingDebugging(
+                    self.options["optimizer"], self.iter_count, self
+                ) as _:
+                    self.iter_count += 1
+                    try:
+                        model.run_solve_nonlinear()
+
+                    # Let the optimizer try to handle the error
+                    except AnalysisError:
+                        model._clear_iprint()
+
+                # Get the objective function evaluation - single obj support
+                for obj in self.get_objective_values().values():
+                    res[k, 0] = obj
+
+                # Get the constraint evaluations
+                j = 1
+                for con_res in self.get_constraint_values().values():
+                    # Make sure con_res is array_like
+                    con_res = to_list(con_res, 1)
+                    # Perform mapping
+                    for i, _ in enumerate(con_res):
+                        res[k, j + i] = con_res[i]
+                    j += 1
+
+            except Exception as msg:
+                tb = traceback.format_exc()
+                print("Exception: %s" % str(msg))
+                print(70 * "=", tb, 70 * "=")
+
+        return res

openmdao_extensions/onera_sego_driver.py

@@ -168,13 +168,13 @@ def run(self, path_hs="", eq_tol={}, ieq_tol={}):
         i = 0
         for name, meta in self._designvars.items():
             size = meta["size"]
-            self.set_design_var(name, x_best[i : i + size])
+            self.set_design_var(name, x_best[0][i : i + size])
             i += size
 
         with RecordingDebugging(
             self.options["optimizer"], self.iter_count, self
         ) as rec:
-            model._solve_nonlinear()
+            model.run_solve_nonlinear()
             rec.abs = 0.0
             rec.rel = 0.0
         self.iter_count += 1

openmdao_extensions/tests/functions_test.py

@@ -0,0 +1,72 @@
+import numpy as np
+from math import cos, sin, pi
+from openmdao.api import (
+    IndepVarComp,
+    Group,
+    ExplicitComponent,
+)
+
+
+class Branin(ExplicitComponent):
+    def setup(self):
+        self.add_input("x1", val=1.0)
+        self.add_input("x2", val=1.0)
+        self.add_output("obj", val=1.0)
+        self.add_output("con", val=1.0)
+
+    @staticmethod
+    def compute(inputs, outputs):
+        x_1 = inputs["x1"][0]
+        x_2 = inputs["x2"][0]
+        # obj
+        part1 = (x_2 - (5.1 * x_1**2) / (4.0 * pi**2) + 5.0 * x_1 / pi - 6.0) ** 2
+        part2 = 10.0 * ((1.0 - 1.0 / (8.0 * pi)) * cos(x_1) + 1.0)
+        part3 = (5.0 * x_1 + 25.0) / 15.0
+        outputs["obj"] = part1 + part2 + part3
+
+        # con
+        x_g1 = (x_1 - 2.5) / 7.5
+        x_g2 = (x_2 - 7.5) / 7.5
+        part1 = (4.0 - 2.1 * x_g1**2 + (x_g1**4) / 3.0) * x_g1**2
+        part2 = x_g1 * x_g2
+        part3 = (4.0 * x_g2**2 - 4.0) * x_g2**2
+        part4 = 3.0 * sin(6.0 * (1.0 - x_g1))
+        part5 = 3.0 * sin(6.0 * (1.0 - x_g2))
+        outputs["con"] = -(part1 + part2 + part3 + part4 + part5 - 6.0)
+
+
+class BraninMDA(Group):
+    def setup(self):
+        indeps = self.add_subsystem("indeps", IndepVarComp(), promotes=["*"])
+        indeps.add_output("x1", 9.1)
+        indeps.add_output("x2", 4.75)
+
+        self.add_subsystem("Branin", Branin(), promotes=["*"])
+
+
+class Ackley(ExplicitComponent):
+    def setup(self):
+        self.add_input("x", val=[1.0, 1.0])
+        self.add_output("obj", val=1.0)
+
+    @staticmethod
+    def compute(inputs, outputs):
+        dim = 2
+        a = 20.0
+        b = 0.2
+        c = 2 * np.pi
+        point = inputs["x"]
+        outputs["obj"] = (
+            -a * np.exp(-b * np.sqrt(1.0 / dim * np.sum(point**2)))
+            - np.exp(1.0 / dim * np.sum(np.cos(c * point)))
+            + a
+            + np.exp(1)
+        )
+
+
+class AckleyMDA(Group):
+    def setup(self):
+        indeps = self.add_subsystem("indeps", IndepVarComp(), promotes=["*"])
+        indeps.add_output("x", [1.0, 1.0])
+
+        self.add_subsystem("Ackley", Ackley(), promotes=["*"])