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

gemseo_multi_fidelity/core/ds_mapper.py

@@ -0,0 +1,307 @@
+# 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
+"""Base class for design space mapping."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING
+from typing import Any
+
+from gemseo.algos.design_space import DesignSpace
+from numpy import abs as np_abs
+from numpy import arange
+from numpy import ndarray
+from numpy import zeros
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+
+    from numpy.typing import NDArray
+
+try:
+    import matplotlib.gridspec as gridspec
+    import pylab
+    # from matplotlib.cm import seismic
+
+    PLOT_AVAILABLE = True
+except ImportError:
+    PLOT_AVAILABLE = False
+
+
+class DesignSpaceMapper:
+    """Abstract class for design space mapping."""
+
+    def __init__(
+        self, design_space_in: DesignSpace, design_space_out: DesignSpace
+    ) -> None:
+        """
+        Args:
+            design_space_in: The input ``DesignSpace`` object.
+            design_space_out: The output ``DesignSpace`` object.
+        """  # noqa: D205 D212 D415
+        self._check_design_space(design_space_in, design_space_out)
+        self.design_space_in = design_space_in
+        self.design_space_out = design_space_out
+
+    @staticmethod
+    def _check_design_space(ds_in, ds_out):
+        if not isinstance(ds_in, DesignSpace):
+            msg = "design_space_in must be an instance of DesignSpace"
+            raise TypeError(msg)
+        if not isinstance(ds_out, DesignSpace):
+            msg = "design_space_out must be an instance of DesignSpace"
+            raise TypeError(msg)
+
+    def _map_vars_direct(self, dvs_dict_in: DesignSpace):
+        """Real direct mapping routine. To be overloaded by subclasses."""
+        raise NotImplementedError
+
+    def _map_vars_reverse(self, dvs_dict_out: DesignSpace):
+        """Real reverse mapping routine. To be overloaded by subclasses."""
+        raise NotImplementedError
+
+    def _map_vars(
+        self,
+        dvs: Mapping[str, Any] | NDArray,
+        to_array: bool = True,
+        direct: bool = True,
+    ) -> Mapping[str, Any] | NDArray:
+        """Take care of formating inputs/outputs using the DesignSpace API.
+
+        The real mapping is performed in _map_vars_direct and _map_vars_reverse.
+
+        Args:
+            dvs: The variables to map.
+            to_array: The flag to specify if a dict or an array should be returned as
+                output.
+            direct: The flag to indicate if the mapping must be performed in the direct
+                or reverse order.
+
+        Returns:
+            The mapping.
+        """
+        # Reverse if needed
+        if direct:
+            ds_in = self.design_space_in
+            ds_out = self.design_space_out
+            map_method = self._map_vars_direct
+        else:
+            ds_in = self.design_space_out
+            ds_out = self.design_space_in
+            map_method = self._map_vars_reverse
+
+        # Make sure the input is a dict
+        if isinstance(dvs, Mapping):
+            dvs_in_dict = dvs
+        elif isinstance(dvs, ndarray):
+            dvs_in_dict = ds_in.convert_array_to_dict(dvs)
+        else:
+            raise TypeError("Unsupported DV type " + str(type(dvs)))
+        dvs_out = map_method(dvs_in_dict)
+        if to_array:
+            dvs_out = ds_out.convert_dict_to_array(dvs_out)
+        return dvs_out
+
+    def map_vars_direct(
+        self, dvs_in: Mapping[str, Any] | NDArray, to_array: bool = False
+    ) -> Mapping[str, Any] | NDArray:
+        """Map the provided design variables from in to out.
+
+        Args:
+            dvs_in: The design variables from the input design space.
+            to_array: The flag to specify if a dict or an array should be returned as
+                output.
+
+        Returns:
+            The design variables in the output design space either dict or array
+            depending on the ``to_array`` flag.
+        """
+        return self._map_vars(dvs_in, to_array=to_array, direct=True)
+
+    def map_vars_reverse(
+        self, dvs_out: Mapping[str, Any] | NDArray, to_array: bool = False
+    ) -> Mapping[str, Any] | NDArray:
+        """Map the provided design variables from out to in.
+
+        Args:
+            dvs_out: The design variables from the output design space.
+            to_array: The flag to specify if a dict or an array should be returned as
+                output.
+
+        Returns:
+            The design variables in the input design space either dict or array
+            depending on the ``to_array`` flag.
+        """
+        return self._map_vars(dvs_out, to_array=to_array, direct=False)
+
+    def has_reverse(self) -> bool:
+        """Check if the mapper can perform the reverse mapping.
+
+        Returns:
+            ``True`` if reverse mapping can be performed.
+        """
+        is_reverse_implemented = True
+        try:
+            self.map_vars_reverse(self.design_space_out.get_current_value(as_dict=True))
+        except NotImplementedError:
+            is_reverse_implemented = False
+        return is_reverse_implemented
+
+    def _map_ds(self, direct: bool = True):
+        """Map the design spaces directly.
+
+        Args:
+            direct: ``True`` for direct mode, ``False`` for the reverse mode.
+        """
+        if direct:
+            ds_in = self.design_space_in
+            ds_out = self.design_space_out
+            map_method = self.map_vars_direct
+        else:
+            ds_in = self.design_space_out
+            ds_out = self.design_space_in
+            map_method = self.map_vars_reverse
+
+        x_in = ds_in.get_current_value(as_dict=True)
+        x_out = map_method(x_in, to_array=True)
+        # Make sure the new current x fits in the design space
+        x_out = ds_out.project_into_bounds(x_out, normalized=False)
+        ds_out.set_current_value(x_out)
+
+    def map_ds_direct(self) -> None:
+        """Map the design spaces from in to out."""
+        self._map_ds(direct=True)
+
+    def map_ds_reverse(self) -> None:
+        """Map the design spaces from out to in."""
+        self._map_ds(direct=False)
+
+    def get_jac(self) -> dict:
+        """Get the jacobian of the mapper (direct).
+
+        Returns:
+            The jacobian.
+        """
+        raise NotImplementedError
+
+    def get_jac_array(self) -> tuple[NDArray, Iterable[str], Iterable[str]]:
+        """Return an array of the mapper jacobian with the associated variables names.
+
+        Returns:
+            The tuple (jacobian, vars_in, vars_out).
+        """
+        ds_out = self.design_space_out
+        ds_in = self.design_space_in
+
+        # Prepare the labels depending on the sizes
+        vars_out = []
+        vars_in = []
+        map_vars_out_to_indexes = {}
+        map_vars_in_to_indexes = {}
+
+        for vars_list, ds, map_inds in zip(
+            [vars_out, vars_in],
+            [ds_out, ds_in],
+            [map_vars_out_to_indexes, map_vars_in_to_indexes],
+            strict=False,
+        ):
+            i_curr = 0
+            for var in ds.variable_names:
+                var_size = int(ds.get_size(var))
+                if var_size == 1:
+                    vars_list += [var]
+                else:
+                    vars_list += [f"{var}_{i:d}" for i in range(int(var_size))]
+                map_inds[var] = [i_curr, i_curr + var_size]
+                i_curr += var_size
+
+        # Build the jacobian array
+        jac_array = zeros((len(vars_out), len(vars_in)))
+        jac_dict = self.get_jac()
+
+        for var_out, jac_link in iter(list(jac_dict.items())):
+            i_start, i_end = map_vars_out_to_indexes[var_out]
+            for var_in, sub_array in iter(list(jac_link.items())):
+                j_start, j_end = map_vars_in_to_indexes[var_in]
+                jac_array[i_start:i_end, j_start:j_end] = sub_array
+
+        return jac_array, vars_in, vars_out
+
+    def plot_jac(self) -> None:
+        """Plot the mapping jacobian using pylab.
+
+        If pylab is not available, no output is produced.
+        """
+        if not PLOT_AVAILABLE:
+            return
+
+        jac_array, vars_in, vars_out = self.get_jac_array()
+
+        # Build the figure
+        max_value = np_abs(jac_array).max()
+
+        fig = pylab.plt.figure(figsize=(8, 8), dpi=80, facecolor="w", edgecolor="k")
+        grid = gridspec.GridSpec(
+            2, 2, width_ratios=[10, 1], height_ratios=[10, 1], wspace=0.04, hspace=0.2
+        )
+        ax1 = fig.add_subplot(grid[0, 0])
+        ax1.set_xlabel("variables in", labelpad=10, rotation="horizontal", size=12)
+        ax1.set_ylabel("variables out", labelpad=10, rotation="vertical", size=12)
+        # Set the title
+        ax1.set_title("Mapper jacobian")
+
+        # Plot the data
+        im = ax1.imshow(
+            jac_array / max_value,
+            cmap="seismic",
+            vmin=-1,
+            vmax=1.0,
+            interpolation="nearest",
+            aspect="auto",
+        )
+
+        ax1.set_yticklabels(vars_out)
+        ax1.set_yticks(arange(jac_array.shape[0]))
+        ax1.set_xticklabels(vars_in)
+        ax1.set_xticks(arange(jac_array.shape[1]))
+
+        # Custom colorbar
+        ax2 = fig.add_subplot(grid[0, 1])
+        pylab.plt.colorbar(im, cax=ax2)
+
+        # Set window size
+        mng = pylab.plt.get_current_fig_manager()
+        mng.resize(700, 1000)
+        pylab.plt.show()
+
+    def __str__(self) -> str:
+        """Textual representation of the DesignSpaceMapper.
+
+        Returns:
+            The textual representation.
+        """
+        ds_in = self.design_space_in
+        ds_out = self.design_space_out
+        class_name = self.__class__.__name__
+        return f"{class_name}\n\n{ds_in}\n\n-- (direct) -->\n\n{ds_out}"

gemseo_multi_fidelity/core/errors.py

@@ -0,0 +1,42 @@
+# 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) 2018 AIRBUS OPERATIONS
+
+#
+# Contributors:
+#    INITIAL AUTHORS - API and implementation and/or documentation
+#      :author: Romain Olivanti
+#    OTHER AUTHORS   - MACROSCOPIC CHANGES
+"""Errors."""
+
+from __future__ import annotations
+
+
+class ConsistencyError(Exception):
+    """Consistency error."""
+
+    def __init__(self, msg: str) -> None:
+        """Constructor.
+
+        Args:
+            msg: The explanation for the inconsistency.
+        """
+        super().__init__()
+        self.msg = msg
+
+    def __str__(self) -> str:
+        """Custom string representation."""
+        return repr(self.msg)

gemseo_multi_fidelity/core/eval_mapper.py

@@ -0,0 +1,188 @@
+# 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
+"""Evaluation Mapper."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from gemseo.algos.database import Database
+
+from gemseo_multi_fidelity.core.ds_mapper import DesignSpaceMapper
+
+if TYPE_CHECKING:
+    from numpy.typing import NDArray
+
+
+class EvaluationMapper:
+    """Object to perform the mapping of an evaluation between two levels."""
+
+    def __init__(
+        self,
+        ds_mapper: DesignSpaceMapper,
+        output_mapping: dict,
+        jac_tag: str = Database.GRAD_TAG,
+    ) -> None:
+        """Auto-detects jacobian inputs using the ``jac_tag`` prefix.
+
+        Args:
+            ds_mapper: The designer space mapper between the two levels.
+            output_mapping: The mapping (direct).
+            jac_tag: The prefix to identify jacobian data.
+        """
+        if not isinstance(ds_mapper, DesignSpaceMapper):
+            msg = "ds_mapper must be an instance of DesignSpaceMapper"
+            raise TypeError(msg)
+
+        if not isinstance(output_mapping, dict):
+            msg = "output_mapping must be a dict"
+            raise TypeError(msg)
+
+        if len(output_mapping) == 0:
+            msg = "output_mapping must not be empty"
+            raise ValueError(msg)
+
+        self.design_space_mapper = ds_mapper
+        self.output_mapping = output_mapping
+        self.jac_tag = jac_tag
+        self.reverse_output_mapping = self.build_reverse_output_mapping(output_mapping)
+
+    @staticmethod
+    def build_reverse_output_mapping(output_mapping: dict) -> dict:
+        """Build the reverse mapping.
+
+        Args:
+            output_mapping: The mapping of the functions in the direct order.
+
+        Returns:
+            The reverse mapping.
+        """
+        reverse_mapping = {}
+
+        for var_in, var_out in iter(list(output_mapping.items())):
+            # Must be strings
+            for v in [var_in, var_out]:
+                if not isinstance(v, str):
+                    msg = f"{v} not a str"
+                    raise TypeError(msg)
+            reverse_mapping[var_out] = var_in
+        return reverse_mapping
+
+    def _map_eval(
+        self,
+        dict_eval: dict,
+        x_eval: dict | NDArray = None,
+        to_arrays: bool = False,
+        direct: bool = True,
+    ) -> tuple[dict, NDArray]:
+        """Actual mapping routine.
+
+        Args:
+            dict_eval: The data to map.
+            x_eval: The variables linked to the data.
+            to_arrays: The flag to convert all dicts to arrays expressed in the output
+                space.
+            direct: ``True`` for the direct order.
+
+        Returns:
+            The tuple (data_mapped, x_mapped).
+        """
+        if direct:
+            map_vars = self.design_space_mapper.map_vars_direct
+            # TODO update with dedicated method
+            map_jac = self.design_space_mapper.map_vars_direct
+            output_mapping = self.output_mapping
+        else:
+            map_vars = self.design_space_mapper.map_vars_reverse
+            # TODO update with dedicated method
+            map_jac = self.design_space_mapper.map_vars_reverse
+            output_mapping = self.reverse_output_mapping
+
+        x_mapped = map_vars(x_eval, to_array=to_arrays) if x_eval is not None else None
+
+        dict_mapped = {}
+
+        for data_name, value in dict_eval.items():
+            # process all inputs, all known funcs will be mapped
+            if data_name.startswith(self.jac_tag):
+                is_jac = True
+                data_name = data_name.split(self.jac_tag)[-1]
+            else:
+                is_jac = False
+            try:
+                name_out = output_mapping[data_name]
+                if is_jac:
+                    mapped_value = map_jac(value, to_array=to_arrays)
+                    name_out = self.jac_tag + name_out
+                else:
+                    mapped_value = value
+                dict_mapped[name_out] = mapped_value
+            except KeyError:
+                # Not an item that must be mapped
+                pass
+
+        return dict_mapped, x_mapped
+
+    def map_eval_direct(
+        self,
+        dict_eval: dict,
+        x_eval: dict | NDArray = None,
+        to_arrays: bool = False,
+    ) -> tuple[dict, NDArray]:
+        """Map the provided data (direct logic).
+
+        Args:
+            dict_eval: The data to map.
+            x_eval: The variables linked to the data, if ``None``, x_mapped will be
+                ``None``.
+            to_arrays: The flag to convert all dicts to arrays expressed in the output
+                space.
+
+        Returns:
+            The tuple (data_mapped, x_mapped).
+        """
+        return self._map_eval(
+            dict_eval, x_eval=x_eval, to_arrays=to_arrays, direct=True
+        )
+
+    def map_eval_reverse(
+        self,
+        dict_eval: dict,
+        x_eval: dict | NDArray = None,
+        to_arrays: bool = False,
+    ) -> tuple[dict, NDArray]:
+        """Map the provided data (reverse logic).
+
+        Args:
+            dict_eval: The data to map.
+            x_eval: The variables linked to the data, if ``None``, x_mapped will be
+                ``None``.
+            to_arrays: The flag to convert all dicts to arrays expressed in the input
+                space.
+
+        Returns:
+            The tuple (data_mapped, x_mapped).
+        """
+        return self._map_eval(
+            dict_eval, x_eval=x_eval, to_arrays=to_arrays, direct=False
+        )

gemseo_multi_fidelity/core/id_mapper_adapter.py

@@ -0,0 +1,61 @@
+# 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
+"""Convenience adapter.
+
+To map the output of a sub-optimization in the same design space.
+"""
+
+from __future__ import annotations
+
+from gemseo_multi_fidelity.core.mapper_adapter import MFMapperAdapter
+from gemseo_multi_fidelity.core.scenario_adapter import MFScenarioAdapter
+
+
+class MFIdMapperAdapter(MFMapperAdapter):
+    """Multi-fidelity identity mapper adapter."""
+
+    def __init__(self, name: str, direct: bool = True) -> None:
+        """Constructor.
+
+        Args:
+            name: The name of the adapter.
+            direct: Whether it is direct.
+        """
+        # Do not call the super of MFIdMapperAdapter as the evaluation mapper
+        # is checked
+        super(MFMapperAdapter, self).__init__(name=name)
+
+        if not isinstance(direct, bool):
+            msg = "direct must be a boolean"
+            raise TypeError(msg)
+
+        self._is_direct = direct
+        super()._init_grammars(self.__class__.__base__.__name__)
+
+    def _map_x_best(self) -> None:
+        """Map the output best point as the next starting point."""
+        x_in = self.io.data[MFScenarioAdapter.X_BEST]
+        self.io.data[MFScenarioAdapter.X_START] = x_in
+
+    def _map_reference_data(self) -> None:
+        """Map the reference data, filters out reference data in direct mode."""