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

gemseo_multi_fidelity/core/mf_formulation.py

@@ -0,0 +1,635 @@
+# 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
+"""Baseclass for all multi-fidelity formulations."""
+
+from __future__ import annotations
+
+from copy import deepcopy
+from typing import TYPE_CHECKING
+from typing import Any
+
+from gemseo.algos.database import Database
+from gemseo.formulations.base_mdo_formulation import BaseMDOFormulation
+from gemseo.scenarios.mdo_scenario import MDOScenario
+
+from gemseo_multi_fidelity.core.ds_mapper import DesignSpaceMapper
+from gemseo_multi_fidelity.core.errors import ConsistencyError
+from gemseo_multi_fidelity.core.eval_mapper import EvaluationMapper
+from gemseo_multi_fidelity.core.mf_opt_problem import MFOptimizationProblem
+from gemseo_multi_fidelity.corrections.correction_factory import CorrectionFactory
+from gemseo_multi_fidelity.mapping.identity_mapper import IdentityMapper
+from gemseo_multi_fidelity.mapping.mapper_factory import DSMapperFactory
+from gemseo_multi_fidelity.models.updater_factory import UpdaterFactory
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+    from collections.abc import Iterable
+    from collections.abc import Mapping
+    from collections.abc import Sequence
+
+    from gemseo.algos.design_space import DesignSpace
+    from gemseo.core.discipline.discipline import Discipline
+    from gemseo.core.mdo_functions.mdo_function import MDOFunction
+
+    from gemseo_multi_fidelity.core.corr_function import MDOCorrectedFunction
+
+
+class MFFormulation(BaseMDOFormulation):
+    """Abstract MF formulation class.
+
+    To be extended in subclasses for use.
+
+    The MFFormulation creates the functions for the multi-fidelity drivers from the
+    scenarios provided.
+
+    It defines the process implicitly.
+    """
+
+    NAME = "MFFormulation"
+
+    DS_MAPPER_TYPE = "mapper_type"
+    CORR_TYPE = "correction_type"
+    CORR_MODEL_TYPE = "correction_model"
+    mf_opt_problem: MFOptimizationProblem
+
+    def __init__(
+        self,
+        disciplines: Sequence[MDOScenario],
+        objective_name: str,
+        design_space: DesignSpace,
+        design_space_mapping: DesignSpaceMapper | dict | Iterable | None = None,
+        functions_mapping: Iterable[Mapping[str, Any]] | None = None,
+        correction_mapping: Iterable[Mapping[str, Any]] | None = None,
+        databases: Iterable[Database] | None = None,
+        **options,
+    ) -> None:
+        """Constructor.
+
+        ``design_space_mapping`` is the mapping logic between the design space of each
+        fidelity level. If ``None``, design spaces are assumed to be identical. A dict
+        can be provided to specify mappings between two scenarios using their names
+        as keys. Alternatively, a list can be provided, whose length must be
+        exactly equal to the number of scenarios - 1.
+
+        Either preexisting ``DSMapper`` objects can be passed or alternatively factory
+        names and their options.
+
+        design_space_mapping = {scenario_upper_name: mapping_logic} (as dict)
+        design_space_mapping = [mapping_logic_upper, ..., mapping_logic_lower]
+                               (as iterable)
+
+        ``functions_mapping``: If the user chooses to specify scenarios with
+        non-matching names between the problem functions, an iterable of dict must be
+        provided to build the link between the different names. Otherwise, the functions
+        are expected to have identical names.
+
+        functions_mapping = [{upper_name: lower_name, }, ...]
+
+        ``correction_mapping``: An iterable of dict can be provided to specify which
+        type of correction and which correction model to use, while providing the
+        options to set them.
+        If provided, the correction mapping must be of len(scenarios) - 1,
+        as the top level is not corrected.
+
+        The consistency of the definition of the ``MFMDOScenario`` is checked.
+
+        Args:
+            disciplines: The list of MDOScenarios, ordered from the highest to the
+                lowest fidelity [HF_scenario, ..., LF_scenario].
+            objective_name: The name of the objective function from the high-fidelity
+                scenario.
+            design_space: The design space of the high-fidelity scenario.
+            design_space_mapping: The design space mapping (None, dict or fully
+                specified iterable).
+            functions_mapping: The functions mapping (None or iterable of dict).
+            correction_mapping: The correction mapping (None or iterable of dict).
+            databases: The Database objects or their file_path
+                Databases storing previous calls to the functions of the scenarios.
+                [sc_0, ..., sc_n] -> [dtb_0, ..., dtb_n]
+                Each elem can be None as well.
+        """
+        # Standard checks
+        # self.check_disciplines(disciplines)
+        # Make sure all the disciplines provided are actually scenarios
+        self._scenarios = self.check_scenarios(disciplines, design_space)
+
+        # Standard attributes of the BaseMDOFormulation are linked to the top level
+        # for overall consistency
+        self._disciplines = self._scenarios[0].formulation.disciplines
+        self.optimization_problem = self._scenarios[0].formulation.optimization_problem
+
+        # Specific attributes
+        self._correction_mapping = []
+        self._eval_mappers = []
+        self._databases = []
+        self._opt_adapters = []
+
+        self._correction_mapping = self._init_corr_mapping(correction_mapping)
+        self._eval_mappers = self._build_eval_mappers(
+            design_space_mapping, functions_mapping
+        )
+        self._build_corrected_functions(databases)
+        self._init_mf_opt_problem()
+
+    @property
+    def disciplines(self) -> tuple[Discipline, ...]:
+        """The sub scenarios."""
+        return self._scenarios
+
+    def get_top_level_disciplines(self) -> tuple[Discipline, ...]:
+        """Get the top-level disciplines."""
+        return self._disciplines
+
+    @staticmethod
+    def check_scenarios(
+        scenarios: Sequence[MDOScenario], design_space: DesignSpace
+    ) -> Sequence[MDOScenario]:
+        """Check scenarios.
+
+        Args:
+            scenarios: The scenarios.
+            design_space: The design space.
+
+        Returns:
+            The checked scenarios.
+        """
+        # Only MDOScenarios allowed
+        for scenario in scenarios:
+            if not isinstance(scenario, MDOScenario):
+                msg = f"{scenario} not a MDOScenario"
+                raise TypeError(msg)
+
+        if id(scenarios[0].design_space) != id(design_space):
+            msg = (
+                "The design space provided does not belong "
+                "to the high-fidelity scenario"
+            )
+            raise ConsistencyError(msg)
+        return scenarios
+
+    @staticmethod
+    def _check_type(item, expected_type):
+        if not isinstance(item, expected_type):
+            raise TypeError
+
+    @staticmethod
+    def _check_not_type(item, expected_type):
+        if isinstance(item, expected_type):
+            raise TypeError
+
+    def get_reference_databases(self) -> Sequence[Database]:
+        """Accessor to the databases storing the calls to the uncorrected functions.
+
+        Returns:
+            The list of ``Database``.
+        """
+        return self._databases
+
+    def _build_def_mapper(self, scenario_index: int) -> IdentityMapper:
+        """Build mapper.
+
+        Builds an IdentityMapper between scenario[scenario_index] and
+        scenario[scenario_index + 1].
+
+        Args:
+            scenario_index: The index of the scenario.
+
+        Returns:
+            The IdentityMapper.
+        """
+        ind = scenario_index
+        return IdentityMapper(
+            self._scenarios[ind + 1].design_space, self._scenarios[ind].design_space
+        )
+
+    def _build_ds_mappers_from_dict(
+        self, design_space_mapping: dict
+    ) -> Sequence[DesignSpaceMapper]:
+        """Build the DesignSpaceMappers from a dict.
+
+        Args:
+            design_space_mapping: The design space mapping.
+
+        Returns:
+            The list of DesignSpaceMapper.
+        """
+        # Check that scenario names are all different
+        scenarios_names = [s.name for s in self._scenarios]
+
+        if len(set(scenarios_names)) != len(self._scenarios):
+            err = (
+                "Cannot have scenarios with identical names "
+                "if a dict is passed as design_space_mapping arg"
+            )
+            raise RuntimeError(err)
+
+        ds_mapper_list = []
+
+        # The lowest scenario is not mapped with a lower level
+        for i, name in enumerate(scenarios_names[0:-1]):
+            mapper_link = design_space_mapping.get(name)
+            if mapper_link is None:
+                mapper_link = self._build_def_mapper(i)
+            ds_mapper_list.append(mapper_link)
+
+        return self._build_ds_mappers_from_list(ds_mapper_list)
+
+    def _build_ds_mappers_from_list(
+        self, design_space_mapping: Iterable[DesignSpaceMapper]
+    ) -> Sequence[DesignSpaceMapper]:
+        """Build the DesignSpaceMappers from a fully specified iterable.
+
+        Args:
+            design_space_mapping: The design space mapping.
+
+        Returns:
+            The list of DesignSpaceMapper.
+        """
+        # Make sure the input is an iterable of correct len
+        try:
+            _ = len(design_space_mapping)
+            MFFormulation._check_not_type(design_space_mapping, str)
+        except TypeError as exc:
+            msg = "design_space_mapping must be an iterable of mapper specifications"
+            raise msg from exc
+
+        if len(design_space_mapping) != len(self._scenarios) - 1:
+            err = (
+                "A design space mapping must be provided between each scenario "
+                "if an iterable is passed"
+            )
+            raise ValueError(err)
+
+        mappers = []
+        add_mapper = mappers.append
+
+        for i, mapper_logic in enumerate(design_space_mapping):
+            in_scenario = self._scenarios[i + 1]
+            out_scenario = self._scenarios[i]
+            if isinstance(mapper_logic, DesignSpaceMapper):
+                # Make sure stored design spaces point to the design spaces of
+                # the scenarios
+                if id(mapper_logic.design_space_in) != id(in_scenario.design_space):
+                    err = (
+                        f"{mapper_logic} input design space "
+                        f"does not point to the design space of {in_scenario}"
+                    )
+                    raise ConsistencyError(err)
+                if id(mapper_logic.design_space_out) != id(out_scenario.design_space):
+                    err = (
+                        f"{mapper_logic} output design space "
+                        f"does not point to the design space of {out_scenario}"
+                    )
+                    raise ConsistencyError(err)
+                mapper = mapper_logic
+            else:
+                # Copy as we will use pop the design space type afterwards
+                mapper_logic = mapper_logic.copy()
+                try:
+                    ds_type = mapper_logic.pop(self.DS_MAPPER_TYPE)
+                except KeyError as exc:
+                    msg = "Type of DesignSpaceMapper to be used not provided"
+                    raise ValueError(msg) from exc
+                ds_in = in_scenario.design_space
+                ds_out = out_scenario.design_space
+                mapper = DSMapperFactory().create(
+                    ds_type, ds_in, ds_out, **mapper_logic
+                )
+            add_mapper(mapper)
+        return mappers
+
+    def _init_ds_mappers(
+        self, design_space_mapping: DesignSpaceMapper | dict | Iterable | None
+    ) -> Sequence[DesignSpaceMapper]:
+        """Check the design_space_mapping data provided.
+
+        Builds missing or partially defined DesignSpaceMapper objects.
+
+        Args:
+            design_space_mapping: The design space mapper (None, dict or fully specified
+                iterable).
+
+        Returns:
+            The list of DesignSpaceMapper.
+        """
+        n_scenarios = len(self._scenarios)
+
+        # Handle allowed cases
+        if design_space_mapping is None:
+            # Assume identity mappings between all the design spaces
+            mappers = [self._build_def_mapper(i) for i in range(n_scenarios - 1)]
+        else:
+            if isinstance(design_space_mapping, dict):
+                mappers = self._build_ds_mappers_from_dict(design_space_mapping)
+            else:
+                mappers = self._build_ds_mappers_from_list(design_space_mapping)
+        return mappers
+
+    def _check_func_mapping_consistency(
+        self, functions_mapping: Iterable[Mapping[str, Any]]
+    ) -> None:
+        """Check that everything is correctly connected.
+
+        Args:
+            functions_mapping: The list of functions mapping.
+        """
+        for i, mapping in enumerate(functions_mapping):
+            # Make sure the scenarios have the same func names
+            upper_prob = self._scenarios[i].formulation.optimization_problem
+            lower_prob = self._scenarios[i + 1].formulation.optimization_problem
+            lower_f_names = lower_prob.function_names
+
+            # Store lower funcs that have already been connected to avoid that
+            # two upper funcs are connected to the same lower func
+            already_connected = []
+            for upp_name in upper_prob.function_names:
+                connected_to = mapping.get(upp_name)
+                if connected_to is None:
+                    msg = f"Missing {upp_name} in functions_mapping[{i:d}]"
+                    raise KeyError(msg)
+                if connected_to not in lower_f_names:
+                    err = (
+                        f"{upp_name} in functions_mapping[{i:d}] connected"
+                        f" to a func that does not exist: {connected_to}"
+                    )
+                    raise ConsistencyError(err)
+                if connected_to in already_connected:
+                    err = (
+                        f"{upp_name} in functions_mapping[{i:d}] connected"
+                        f" to a func that has already been connected: {connected_to}"
+                    )
+                    raise ConsistencyError(err)
+                already_connected.append(connected_to)
+
+    def _init_func_mapping(
+        self, functions_mapping: Iterable[Mapping[str, Any]] | None = None
+    ):
+        """Check the function mapping provided.
+
+        If ``None`` all function names are assumed to be identical between the levels.
+
+        Args:
+            functions_mapping: The list of functions mapping (None, or iterable of
+                dict).
+
+        Returns:
+            The list of checked functions mapping.
+        """
+        n_scenarios = len(self._scenarios)
+
+        if functions_mapping is None:
+            if n_scenarios != 1:
+                # Assume all the scenarios have identical func names
+                top_prob = self._scenarios[0].formulation.optimization_problem
+                f_names = top_prob.function_names
+                functions_mapping = [
+                    {f_name: f_name for f_name in f_names}
+                    for i in range(n_scenarios - 1)
+                ]
+            else:
+                functions_mapping = []
+        else:
+            # Make sure the mapping is consistent in type and len
+            try:
+                for elem in functions_mapping:
+                    MFFormulation._check_type(elem, dict)
+            except TypeError as exc:
+                msg = "functions_mapping must be an iterable of dict"
+                raise msg from exc
+
+            if len(functions_mapping) != n_scenarios - 1:
+                err = "A func mapping must be provided between each scenario"
+                raise ValueError(err)
+
+        self._check_func_mapping_consistency(functions_mapping)
+        return functions_mapping
+
+    def _build_eval_mappers(
+        self,
+        design_space_mapping: Iterable[DesignSpaceMapper],
+        functions_mapping: Iterable[Mapping[str, Any]],
+    ) -> Sequence[EvaluationMapper]:
+        """Build the evaluation mappers.
+
+        Args:
+            design_space_mapping: The list of DesignSpaceMapper.
+            functions_mapping: The list of functions mapping.
+
+        Returns:
+            The list of evaluation mappers.
+        """
+        eval_mappers = []
+        add_mapper = eval_mappers.append
+
+        # Check the inputs to yield the final objects required
+        ds_mappers = self._init_ds_mappers(design_space_mapping)
+        funcs_mappers = self._init_func_mapping(functions_mapping)
+
+        for ds_mapper, func_mapper in zip(ds_mappers, funcs_mappers, strict=False):
+            add_mapper(
+                EvaluationMapper(ds_mapper, func_mapper, jac_tag=Database.GRAD_TAG)
+            )
+        return eval_mappers
+
+    def _init_corr_mapping(
+        self, correction_mapping: Iterable[Mapping[str, Any]]
+    ) -> Iterable[Mapping[str, Any]]:
+        """Check the correction mapping provided.
+
+        Args:
+            correction_mapping: The list of correction mapping (None, or iterable of
+                dict).
+
+        Returns:
+            The list of checked correction mapping.
+        """
+        n_scenarios = len(self._scenarios)
+        if correction_mapping is None:
+            # Empty correction data, default values will be used later
+            correction_mapping = [{} for i in range(n_scenarios - 1)]
+        else:
+            try:
+                for elem in correction_mapping:
+                    MFFormulation._check_type(elem, dict)
+            except TypeError as exc:
+                msg = "correction_mapping must be an iterable of dict"
+                raise msg from exc
+            if len(correction_mapping) != n_scenarios - 1:
+                err = "A correction mapping must be provided for each sub scenario"
+                raise ValueError(err)
+            correction_mapping = deepcopy(correction_mapping)
+        for corr_dict, scenario in zip(
+            correction_mapping, self._scenarios[1::], strict=False
+        ):
+            prob = scenario.formulation.optimization_problem
+            all_funcs = prob.function_names
+            for func in all_funcs:
+                if func not in corr_dict:
+                    corr_dict[func] = {}
+        return correction_mapping
+
+    def _build_corrected_function(
+        self, level: int, func: MDOFunction, database: Database
+    ) -> MDOCorrectedFunction:
+        """Build a corrected function from the mapping data.
+
+        Args:
+            level: The index of the level to select the right correction mapping.
+            func: The function to correct.
+            database: The Database to store the call to the uncorrected functions.
+
+        Returns:
+            The MDOCorrectedFunction.
+        """
+        corr_data = self._correction_mapping[level - 1][func.name]
+        # Default set to additive correction as it can handle all outputs
+        corr_type = corr_data.get(self.CORR_TYPE, CorrectionFactory.ADD_CORR)
+        # Default set to Taylor model
+        mod_type = corr_data.get(self.CORR_MODEL_TYPE, UpdaterFactory.TAYLOR)
+        # Build the correction model
+        corr_model = UpdaterFactory().create(mod_type, **corr_data)
+        # Build the corrected function
+        return CorrectionFactory().create(corr_type, func, corr_model, database)
+
+    def _build_corrected_functions(self, databases: Iterable[Database]) -> None:
+        """Build corrected functions.
+
+        Builds the databases storing calls to the original functions of each scenario
+        and replaces MDOFunctions by MDOCorrectedFunctions.
+
+        Args:
+            databases: The list of ``Database`` objects storing previous calls to the
+                functions of the scenarios.
+        """
+        _ = len(self._scenarios)
+
+        # Avoid duplicates for double calls (should only happen for testing purposes)
+        self._databases = []
+
+        # Builds all the required databases
+        # if databases is None:
+        #     print("Init databases")
+        #     self._databases = [Database() for i in range(n_scenarios)]
+        # else:
+        #     # Make sure it matches in len and build the missing ones
+        #     if len(databases) != n_scenarios:
+        #         raise ValueError("len(databases) != len(scenarios)")
+        #
+        #     for dtb in databases:
+        #         if dtb is None:
+        #             dtb = Database()
+        #         self._databases.append(dtb)
+        self._databases = [
+            scn.formulation.optimization_problem.database for scn in self._scenarios
+        ]
+
+        # Replace MDOFunctions by MDOCorrectedFunctions
+        for i, (scn, dtb) in enumerate(
+            zip(self._scenarios, self._databases, strict=False)
+        ):
+            opt_prob = scn.formulation.optimization_problem
+
+            if i == 0:
+                # Do not correct, only redirect to database created here
+                opt_prob.database = dtb
+                continue
+
+            # Objective
+            orig_obj = opt_prob.objective
+            opt_prob.objective = self._build_corrected_function(i, orig_obj, dtb)
+            # Constraints
+            constraints = []
+            for con in opt_prob.constraints:
+                corr_con = self._build_corrected_function(i, con, dtb)
+                constraints.append(corr_con)
+            opt_prob.constraints = constraints
+
+    def _init_mf_opt_problem(self) -> None:
+        sub_probs = [scn.formulation.optimization_problem for scn in self._scenarios]
+        self.mf_opt_problem = MFOptimizationProblem(
+            sub_probs, self._eval_mappers, self._databases
+        )
+
+    def _build_workflow_runner(self):
+        raise NotImplementedError
+
+    def _build_option_setter(self) -> None:
+        def set_option(level: int, option: str, value: Any) -> None:
+            """Set an option for a specified level.
+
+            Args:
+                level: The level.
+                option: The option to set.
+                value: The value to set.
+            """
+            adapter = self._opt_adapters[level]
+            adapter.default_input_data[option] = value
+
+        return set_option
+
+    def _build_callback_setter(self) -> None:
+        def add_callback(level: int, target: str, callback: Callable) -> None:
+            """Add a callback for a specific level.
+
+            Args:
+                level: The level.
+                target: The type of callback to set.
+                callback: The callable.
+            """
+            adapter = self._opt_adapters[level]
+            callbacks = adapter.default_input_data.get(target)
+            if callbacks is None:
+                # Init with an empty list
+                callbacks = []
+                adapter.default_input_data[target] = callbacks
+            elif callable(callbacks):
+                # Make sure to convert it as a list
+                callbacks = [callbacks]
+            callbacks.append(callback)
+
+        return add_callback
+
+    def _build_driver_interface(self) -> None:
+        """Build the interface to be used by the multi-fidelity drivers.
+
+        To be called by subclasses at the end of __init__.
+        """
+        run_exec = self._build_workflow_runner()
+        callback_setter = self._build_callback_setter()
+        option_setter = self._build_option_setter()
+
+        self.mf_opt_problem.run_exec = run_exec
+        self.mf_opt_problem._add_callback = callback_setter
+        self.mf_opt_problem._set_option = option_setter
+
+    def get_expected_workflow(
+        self,
+    ) -> Iterable[Any]:
+        """Get the expected workflow."""
+        return []
+
+    def get_expected_dataflow(
+        self,
+    ) -> Iterable[Any]:
+        """Get the expected dataflow."""
+        return []