gemseo-multi-fidelity 0.0.1__py3-none-any.whl

gemseo_multi_fidelity/mf_rosenbrock/delayed_disc.py

@@ -0,0 +1,136 @@
+# Copyright 2021 IRT Saint Exupéry, https://www.irt-saintexupery.com
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License version 3 as published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+
+# Copyright (c) 2019 AIRBUS OPERATIONS
+
+#
+# Contributors:
+#    INITIAL AUTHORS - API and implementation and/or documentation
+#      :author: Romain Olivanti
+#    OTHER AUTHORS   - MACROSCOPIC CHANGES
+"""Delayed discipline."""
+
+from __future__ import annotations
+
+from time import sleep
+from typing import TYPE_CHECKING
+
+from gemseo.core.discipline.discipline import Discipline
+from numpy import atleast_1d
+from numpy import atleast_2d
+from numpy import zeros
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+    from collections.abc import Iterable
+
+    from gemseo.typing import StrKeyMapping
+
+
+class DelayedFuncDisc(Discipline):
+    """Delayed function discipline.
+
+    Simple convenience discipline to encapsulate a single function.
+    Can add a fake delay for the function evaluation and the jacobian evaluation.
+    Delays can be different for the two calls and are added as input of the disciplines.
+    They can be adjusted for each call.
+    """
+
+    DVS = "x"
+    DT_FUNC_SEC = "dt_func_sec"
+    DT_JAC_SEC = "dt_jac_sec"
+
+    def __init__(
+        self,
+        name: str,
+        func: Callable,
+        jac: Callable,
+        dimension: int,
+        out_name: str | None = None,
+        dt_func_sec: float = 0.0,
+        dt_jac_sec: float = 0.0,
+    ) -> None:
+        """Constructor.
+
+        Args:
+            name: The name of the discipline.
+            func: The function pointer.
+            jac: The jacobian pointer.
+            dimension: The dimension of the dvs.
+            out_name: The name of the output, name of the discipline if none.
+            dt_func_sec: The delay to add for the function evaluation.
+            dt_jac_sec: The delay to add for the jacobian evaluation.
+        """
+        super().__init__(name=name)
+        self._func = func
+        self._jac = jac
+
+        self._check_dt(dt_func_sec)
+        self._check_dt(dt_jac_sec)
+
+        default_inputs = {
+            self.DVS: zeros(dimension),
+            self.DT_FUNC_SEC: dt_func_sec,
+            self.DT_JAC_SEC: dt_jac_sec,
+        }
+
+        self._out_name = self.name if out_name is None else out_name
+
+        self.input_grammar.update_from_data(default_inputs)
+        self.output_grammar.update_from_names([self._out_name])
+        self.default_input_data = default_inputs
+        self.add_differentiated_inputs([self.DVS])
+        self.add_differentiated_outputs([self._out_name])
+        self._check_funcs()
+
+    @staticmethod
+    def _check_dt(dt_sec: float) -> None:
+        if dt_sec < 0.0:
+            msg = "dt < 0."
+            raise ValueError(msg)
+
+    def _check_funcs(self) -> None:
+        for f_name, f_pointer in zip(
+            ["func", "jac"], [self._func, self._jac], strict=False
+        ):
+            if not callable(f_pointer):
+                msg = f"{f_name} not callable"
+                raise TypeError(msg)
+            try:
+                f_pointer(self.default_input_data[self.DVS])
+            except Exception as exc:
+                msg = f"{f_name} not callable for the specified dimension"
+                raise RuntimeError(msg) from exc
+
+    def _run(self, input_data: StrKeyMapping) -> None:
+        x_vect = self.io.data[self.DVS]
+        dt_sec = self.io.data[self.DT_FUNC_SEC]
+        self._check_dt(dt_sec)
+
+        # Compute the value
+        sleep(dt_sec)
+        self.io.data[self._out_name] = atleast_1d(self._func(x_vect))
+
+    def _compute_jacobian(
+        self, input_names: Iterable[str] = (), output_names: Iterable[str] = ()
+    ) -> None:
+        x_vect = self.io.data[self.DVS]
+        dt_sec = self.io.data[self.DT_JAC_SEC]
+        self._check_dt(dt_sec)
+
+        # Compute the jacobian
+        sleep(dt_sec)
+        self.jac = {}
+        self.jac[self._out_name] = {self.DVS: atleast_2d(self._jac(x_vect))}

gemseo_multi_fidelity/mf_rosenbrock/refact_rosen_testcase.py

@@ -0,0 +1,46 @@
+# Copyright 2021 IRT Saint Exupéry, https://www.irt-saintexupery.com
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License version 3 as published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+
+# Copyright (c) 2019 AIRBUS OPERATIONS
+
+#
+# Contributors:
+#    INITIAL AUTHORS - API and implementation and/or documentation
+#      :author: Romain Olivanti
+#    OTHER AUTHORS   - MACROSCOPIC CHANGES
+"""Refactoring of Rosenbrock test case."""
+
+from __future__ import annotations
+
+from .rosen_mf_case import MFRosenCaseGenerator
+
+
+def build_scenarios() -> list:
+    """Build the scenarios."""
+    coef = 1.0
+    fidelities = [
+        MFRosenCaseGenerator.HF_ROS,
+        MFRosenCaseGenerator.LF_ROS_CUS,
+        MFRosenCaseGenerator.LF_ROS_CUS,
+    ]
+    dims = [2, 2, 2]
+    opts = [
+        {"coef": coef, "dt_func_sec": 0.0, "dt_jac_sec": 0.0},
+        {"coef": coef, "x_sol": 0.9, "dt_func_sec": 0.0, "dt_jac_sec": 0.0},
+        {"coef": coef, "x_sol": 0.6, "dt_func_sec": 0.0, "dt_jac_sec": 0.0},
+    ]
+
+    generator = MFRosenCaseGenerator(fidelities, dimensions=dims, options=opts)
+    return generator.build_scenarios(l_b=-2.1, u_b=2.1)

gemseo_multi_fidelity/mf_rosenbrock/rosen_mf_case.py

@@ -0,0 +1,284 @@
+# Copyright 2021 IRT Saint Exupéry, https://www.irt-saintexupery.com
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License version 3 as published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+
+# Copyright (c) 2019 AIRBUS OPERATIONS
+
+#
+# Contributors:
+#    INITIAL AUTHORS - API and implementation and/or documentation
+#      :author: Romain Olivanti
+#    OTHER AUTHORS   - MACROSCOPIC CHANGES
+#      :author: Francois Gallard - portage to GEMSEO 6
+"""Multi-fidelity Rosenbrock Case Generator."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+from typing import ClassVar
+
+from gemseo import create_scenario
+from gemseo.algos.design_space import DesignSpace
+from gemseo.settings.opt import L_BFGS_B_Settings
+
+from gemseo_multi_fidelity.mf_rosenbrock.delayed_disc import DelayedFuncDisc
+from gemseo_multi_fidelity.mf_rosenbrock.rosen_mf_funcs import rosen
+from gemseo_multi_fidelity.mf_rosenbrock.rosen_mf_funcs import rosen_custom
+from gemseo_multi_fidelity.mf_rosenbrock.rosen_mf_funcs import rosen_custom_grad
+from gemseo_multi_fidelity.mf_rosenbrock.rosen_mf_funcs import rosen_grad
+from gemseo_multi_fidelity.mf_rosenbrock.rosen_mf_funcs import rosen_quartic
+from gemseo_multi_fidelity.mf_rosenbrock.rosen_mf_funcs import rosen_quartic_grad
+from gemseo_multi_fidelity.mf_rosenbrock.rosen_mf_funcs import rosen_sqr
+from gemseo_multi_fidelity.mf_rosenbrock.rosen_mf_funcs import rosen_sqr_grad
+
+if TYPE_CHECKING:
+    from gemseo.scenarios.mdo_scenario import MDOScenario
+    from numpy.typing import NDArray
+
+
+class MFRosenCaseGenerator:
+    """Multi-fidelity Rosenbrock Case Generator.
+
+    Builds scenarios for each fidelity specified.
+    """
+
+    HF_ROS = "rosen"
+    LF_ROS_CUS = "rosen_lf_cus"
+    LF_ROS_QUA = "rosen_lf_qua"
+    LF_ROS_SQR = "rosen_lf_sqr"
+
+    AVAILABLE_FIDS: ClassVar[list] = [HF_ROS, LF_ROS_CUS, LF_ROS_QUA, LF_ROS_SQR]
+    """The list of available fidelities."""
+
+    OUTPUT_NAME = "rosen"
+
+    def __init__(
+        self,
+        fidelities: list[str],
+        dimensions: list[int] = 2,
+        options: list[dict] | None = None,
+    ) -> None:
+        """Constructor.
+
+        Args:
+            fidelities: The list of tags, ordered from the highest fidelity to the
+                lowest.
+            dimensions: The list of dimensions.
+            options: The list of options dicts to set up the multi-fidelity functions.
+        """
+        self._disciplines = []
+        if options is None:
+            options = []
+        try:
+            len(dimensions)
+        except TypeError:
+            dimensions = [dimensions]
+        self._build_disciplines(fidelities, dimensions, options)
+
+    @staticmethod
+    def _process_inputs(
+        n_fidelities: int, dimensions: list[int], opt_dicts: list[dict]
+    ) -> tuple[list[int], list[dict]]:
+        n_dim = len(dimensions)
+        n_options = len(opt_dicts)
+
+        if n_dim < n_fidelities:
+            # Duplicate the last dimension specified
+            dimensions += [dimensions[-1]] * (n_fidelities - n_dim)
+
+        if n_options < n_fidelities:
+            # Append empty dicts
+            opt_dicts += [{}] * (n_fidelities - n_options)
+        return dimensions, opt_dicts
+
+    def _get_fidelity_funcs(
+        self, fidelity: str, options: dict
+    ) -> tuple[NDArray, NDArray]:
+        # Root tag to funcs
+        if fidelity == self.HF_ROS:
+            func = rosen
+            grad = rosen_grad
+        elif fidelity == self.LF_ROS_CUS:
+            func = rosen_custom
+            grad = rosen_custom_grad
+        elif fidelity == self.LF_ROS_QUA:
+            func = rosen_quartic
+            grad = rosen_quartic_grad
+        elif fidelity == self.LF_ROS_SQR:
+            func = rosen_sqr
+            grad = rosen_sqr_grad
+        else:
+            msg = f"{fidelity} not in {self.AVAILABLE_FIDS}"
+            raise ValueError(msg)
+
+        # Build callables with unique arg x_vect
+        func_opts = options.copy()
+
+        def wrapped_func(x_vect: NDArray) -> NDArray:
+            return func(x_vect, **func_opts)
+
+        def wrapped_grad(x_vect: NDArray) -> NDArray:
+            return grad(x_vect, **func_opts)
+
+        return wrapped_func, wrapped_grad
+
+    def _build_disciplines(
+        self, fidelities: list[str], dimensions: list[int], opt_dicts: list[dict]
+    ) -> None:
+        """Build the specified Rosenbrock fidelities as individual disciplines.
+
+        Args:
+            fidelities: The list of fidelity tags.
+            dimensions: The list of dimensions.
+            opt_dicts: The list of dictionary storing options to configure the different
+                fidelities.
+        """
+        last_dt_func = None
+        last_dt_jac = None
+
+        dimensions, opt_dicts = self._process_inputs(
+            len(fidelities), dimensions, opt_dicts
+        )
+
+        for fidelity, dim, opt_dict in zip(
+            fidelities, dimensions, opt_dicts, strict=False
+        ):
+            # Pop delay options, handled at the discipline level
+            try:
+                dt_func = opt_dict.pop(DelayedFuncDisc.DT_FUNC_SEC)
+            except KeyError:
+                dt_func = 0.0
+            try:
+                dt_jac = opt_dict.pop(DelayedFuncDisc.DT_JAC_SEC)
+            except KeyError:
+                dt_jac = 0.0
+            # Perform checks on the delay logic
+            # Func
+            if last_dt_func is not None and dt_func > last_dt_func:
+                msg = (
+                    f"The evaluation of {fidelity} "
+                    "takes longer than the previous fidelity"
+                )
+                raise ValueError(msg)
+            last_dt_func = dt_func
+            # Jacobian
+            if last_dt_jac is not None and dt_jac > last_dt_jac:
+                msg = (
+                    f"The jacobian of {fidelity} "
+                    "takes longer than the previous fidelity"
+                )
+                raise ValueError(msg)
+            last_dt_jac = dt_jac
+            # Build the functions
+            func, grad = self._get_fidelity_funcs(fidelity, opt_dict)
+            discipline = DelayedFuncDisc(
+                fidelity,
+                func,
+                grad,
+                dim,
+                out_name=self.OUTPUT_NAME,
+                dt_func_sec=dt_func,
+                dt_jac_sec=dt_jac,
+            )
+            self._disciplines.append(discipline)
+
+    def build_scenarios(self, l_b: float = -2.1, u_b: float = 2.1) -> list[MDOScenario]:
+        """Build scenarios.
+
+        Args:
+            l_b: The lower bound.
+            u_b: The upper bound.
+
+        Returns:
+            The list of scenarios.
+        """
+        # Process design spaces, adapt dim, default inputs if needed
+        scenarios = []
+
+        for i, disc in enumerate(self._disciplines):
+            scenario_name = f"rosen_l{i:d}"
+            # Build the design space
+            design_space = DesignSpace()
+            default_dvs = disc.default_input_data[disc.DVS]
+            design_space.add_variable(
+                disc.DVS,
+                len(default_dvs),
+                lower_bound=l_b,
+                upper_bound=u_b,
+                value=default_dvs,
+                type_="float",
+            )
+            # Build the scenario
+            scenario = create_scenario(
+                [disc],
+                self.OUTPUT_NAME,
+                design_space,
+                formulation_name="DisciplinaryOpt",
+                name=scenario_name,
+                scenario_type="MDO",
+            )
+
+            scenario.set_algorithm(algo_settings_model=L_BFGS_B_Settings(max_iter=100))
+            # search_paths=search_paths)
+            scenarios.append(scenario)
+        return scenarios
+
+
+if __name__ == "__main__":
+    from time import time
+
+    COEF = 1.0
+    FIDS = [
+        MFRosenCaseGenerator.HF_ROS,
+        MFRosenCaseGenerator.LF_ROS_CUS,
+        MFRosenCaseGenerator.LF_ROS_CUS,
+        MFRosenCaseGenerator.LF_ROS_QUA,
+    ]
+    DIMS = [4, 4, 3, 2]
+    OPTS = [
+        {"coef": COEF, "dt_func_sec": 2.0, "dt_jac_sec": 1.5},
+        {"coef": COEF, "x_sol": 0.9, "dt_func_sec": 1.0, "dt_jac_sec": 1.0},
+        {"coef": COEF, "x_sol": 0.7, "dt_func_sec": 0.7, "dt_jac_sec": 0.7},
+        {"coef": COEF, "dt_func_sec": 0.2, "dt_jac_sec": 0.2},
+    ]
+
+    #    # Made to fail on check
+    #    OPTS = [{"coef": COEF,
+    #             "dt_func_sec": 2.0,
+    #             "dt_jac_sec": 1.5
+    #             },
+    #            {"coef": COEF,
+    #             "x_sol": 0.9,
+    #             "dt_func_sec": 1.0,
+    #             "dt_jac_sec": 1.0
+    #             },
+    #            {"coef": COEF,
+    #             "x_sol": 0.7,
+    #             "dt_func_sec": 1.5,
+    #             "dt_jac_sec": 0.7
+    #             },
+    #            {"coef": COEF,
+    #             "dt_func_sec": 0.2,
+    #             "dt_jac_sec": 0.2
+    #             }]
+    ros_builder = MFRosenCaseGenerator(FIDS, dimensions=DIMS, options=OPTS)
+
+    for disc in ros_builder._disciplines:
+        dt = -time()
+        out = disc.execute()
+        dt += time()
+
+        dt = -time()
+        out_lin = disc.linearize()
+        dt += time()