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

gemseo_multi_fidelity/mapping/interp_mapper.py

@@ -0,0 +1,422 @@
+# 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
+"""Interpolation mapper."""
+
+from __future__ import annotations
+
+import logging
+from copy import deepcopy
+from typing import TYPE_CHECKING
+from typing import ClassVar
+
+from numpy import array
+from numpy import atleast_2d
+from numpy import eye
+from numpy import inf
+from numpy import vstack
+from numpy import zeros
+from numpy.linalg import norm
+
+from gemseo_multi_fidelity.core.ds_mapper import DesignSpaceMapper
+from gemseo_multi_fidelity.mapping.mapping_errors import MappingError
+
+if TYPE_CHECKING:
+    from gemseo.algos.design_space import DesignSpace
+    from numpy.typing import NDArray
+
+LOGGER = logging.getLogger(__name__)
+
+
+class InterpolationMapper(DesignSpaceMapper):
+    """Interpolation mapper."""
+
+    LINEAR = "linear"
+    CUBIC = "cubic"
+    AUTO_INTERP_TYPES: ClassVar[list] = [LINEAR, CUBIC]
+
+    def __init__(
+        self,
+        design_space_in: DesignSpace,
+        design_space_out: DesignSpace,
+        interp_logic: dict | None = None,
+        auto_interp: bool = False,
+        split_pattern: str = "_",
+        auto_interp_type: str = "linear",
+    ) -> None:
+        """Constructor.
+
+        Args:
+            design_space_in: The input design space.
+            design_space_out: The output design space.
+            interp_logic: The user-defined interpolation logic between input and output
+                variables.
+            auto_interp: ``True`` to activate the auto interpolation feature. Not used
+                if interp_logic is provided.
+            split_pattern: The pattern used to identify variables can that be linked to
+                interpolate i.e. 'name_0', 'name_1', ...
+            auto_interp_type: The type of interpolation law to consider.
+        """
+        super().__init__(design_space_in, design_space_out)
+        self._prolg_oper = None
+        self._restr_oper = None
+        self._norm_prolg = None
+        self._restr_factor = None
+
+        if interp_logic is not None:
+            self._build_interp_from_logic(interp_logic)
+        else:
+            if not auto_interp:
+                msg = (
+                    "Automatic interpolation not activated but "
+                    "no interpolation logic has been provided"
+                )
+                raise ValueError(msg)
+            self._build_interp_auto(split_pattern, auto_interp_type)
+
+        self._check_interp()
+        self._compute_factors()
+
+    def _build_interp_from_logic(self, interp_logic: dict) -> None:
+        """Build operators from the interp logic that contains all the logic.
+
+        Args:
+            interp_logic: The interp logic.
+        """
+        prolg_oper = {}
+        restr_oper = {}
+
+        for var_out, prolg_logic in iter(list(interp_logic.items())):
+            prolg_oper[var_out] = {}
+            for var_in, oper in iter(list(prolg_logic.items())):
+                try:
+                    len(oper)
+                    prolg_val = atleast_2d(oper).copy()
+                except TypeError:
+                    # Light storage, make sure it is a float
+                    prolg_val = float(oper)
+                prolg_oper[var_out][var_in] = prolg_val
+                if var_in not in restr_oper:
+                    restr_oper[var_in] = {}
+                # Do not save the prolg transpose on purpose, use only a reference
+                restr_oper[var_in][var_out] = prolg_val
+        self._prolg_oper = prolg_oper
+        self._restr_oper = restr_oper
+
+    def _build_interp_on_var_size(
+        self,
+        var_name: str,
+        dim_in: int,
+        dim_out: int,
+        interp_type: str,
+        log_prefix: str,
+    ) -> dict:
+        """Build a prolongation operator based on input and output sizes.
+
+        Args:
+            var_name: The name of the variable considered.
+            dim_in: The input dimension.
+            dim_out: The output dimension.
+            interp_type: The type of interpolation to use.
+            log_prefix: The prefix for logs.
+
+        Returns:
+            The prolongation operator.
+        """
+        if dim_out == dim_in:
+            # Exact match
+            LOGGER.info("%s assuming identity law for %s", log_prefix, var_name)
+            oper_array = 1.0
+        else:
+            # Check if sizes allow deducing the operator and log it so that
+            # the user has a better understanding of what to expect
+            if dim_out == 2 * dim_in - 1:
+                # Outside values are exact
+                LOGGER.info(
+                    "%s assuming %s interpolation law with exact outside values for %s",
+                    log_prefix,
+                    interp_type,
+                    var_name,
+                )
+            elif dim_out == 2 * dim_in + 1:
+                # Outside values will be interpolated
+                LOGGER.info(
+                    "%s assuming %s interpolation law "
+                    "with interpolated outside values for %s",
+                    log_prefix,
+                    interp_type,
+                    var_name,
+                )
+            else:
+                msg = (
+                    "{None} not same size for the variable {None} "
+                    "between in and out but cannot deduce "
+                    "an interpolation pattern"
+                )
+                raise MappingError(msg)
+            # Actual array assembly
+            oper_array = self._build_prolg_oper(dim_in, dim_out, interp_type)
+        return {var_name: oper_array}
+
+    def _build_prolg_oper(self, dim_in: int, dim_out: int, interp_type: str) -> NDArray:
+        """Build a linear interpolation operator.
+
+        Args:
+            dim_in: The input dimension.
+            dim_out: The output dimension.
+            interp_type: The type of interpolation to use.
+
+        Returns:
+            The linear interpolation operator.
+        """
+        # Checks
+        if interp_type not in self.AUTO_INTERP_TYPES:
+            err = "{} not in implemented auto interpolation laws: {}"
+            err = err.format(interp_type, self.AUTO_INTERP_TYPES)
+            raise ValueError(err)
+
+        if interp_type == self.CUBIC and dim_in % 3 != 0:
+            msg = "Cannot use cubic interpolation if dim_in % 3 != 0"
+            raise MappingError(msg)
+
+        assert dim_in < dim_out
+
+        is_outside_interpolated = dim_out == 2 * dim_in + 1
+
+        if is_outside_interpolated:
+            # Outside values will be added at the end
+            dim_out -= 2
+
+        i_in = 0
+        oper = zeros((dim_out, dim_in))
+
+        # TODO use a sparse representation?
+        for i in range(dim_out):
+            if i % 2 == 0:
+                oper[i, i_in] = 1.0
+                i_in += 1
+            else:
+                if interp_type == self.LINEAR:
+                    oper[i, i_in - 1 : i_in + 1] = array([0.5, 0.5])
+                else:
+                    if i % 3 == 0:
+                        oper[i, i_in - 2 : i_in + 1] = array([-0.0625, 0.5625, 0.5625])
+                    else:
+                        oper[i, i_in - 1 : i_in + 2] = array([0.5625, 0.5625, -0.0625])
+
+        if is_outside_interpolated:
+            # stack first and last row
+            first_row = zeros((1, dim_in))
+            last_row = zeros((1, dim_in))
+            if interp_type == self.LINEAR:
+                first_row[0, 0] = 0.5
+                last_row[0, -1] = 0.5
+            else:
+                first_row[0, 0:2] = array([0.75, -0.125])
+                last_row[0, -2::] = array([-0.125, 0.75])
+            oper = vstack((first_row, oper, last_row))
+        return oper
+
+    def _build_inter_on_var_names(
+        self, var: str, var_dim: int, split_pattern: str, log_prefix: str
+    ) -> dict:
+        """Build interpolation on var names.
+
+        Tries to build the interpolation logic for var_out using other variables for the
+        input design space.
+
+        Args:
+            var: The name of the output variable.
+            var_dim: The dimension of the output variable.
+            split_pattern: The pattern used to identify linked variables.
+            log_prefix: The prefix for logs.
+
+        Returns:
+            The interpolation logic.
+        """
+        ds_in = self.design_space_in
+        split_name = var.split(split_pattern)
+        var_gen_name = "".join(split_name[0:-1])
+        interp_dict = {}
+
+        try:
+            var_index = int(split_name[-1])
+        except ValueError as exc:
+            msg = f"{var} cannot be linked to variables in the input design space"
+            raise MappingError(msg) from exc
+
+        prev_var = f"{var_gen_name}{split_pattern}{var_index - 1:d}"
+        next_var = f"{var_gen_name}{split_pattern}{var_index + 1:d}"
+
+        # ds_in has prev var?
+        prev_dim = ds_in.get_size(prev_var)
+        if prev_dim is not None:
+            if prev_dim != var_dim:
+                err = "{} {} sizes do not match: {:d} != {:d}"
+                err = err.format(var, prev_var, var_dim, prev_dim)
+                raise MappingError(err)
+            interp_dict[prev_var] = 0.5
+
+        # ds_in has next var?
+        next_dim = ds_in.get_size(next_var)
+        if next_dim is not None:
+            if next_dim != var_dim:
+                err = "{} {} sizes do not match: {:d} != {:d}"
+                err = err.format(var, next_var, var_dim, next_dim)
+                raise MappingError(err)
+            interp_dict[next_var] = 0.5
+        return interp_dict
+
+    def _build_interp_auto(self, split_pattern: str, interp_type: str) -> dict:
+        """Handle the auto interpolation detection.
+
+        Args:
+            split_pattern: The pattern used to identify linked variables.
+            interp_type: The type of interpolation to use.
+
+        Returns:
+            The interpolation logic.
+        """
+        ds_in = self.design_space_in
+        ds_out = self.design_space_out
+        interp_logic = {}
+        log_prefix = "Auto interpolation mapping:"
+
+        # Try to build the interp logic using auto rules
+        for var_out, dim_out in iter(list(ds_out.variable_sizes.items())):
+            # Checks if the var exists in the input design space
+            dim_in = ds_in.get_size(var_out)
+            if dim_in is not None:
+                # The variable exists in the input design space
+                interp_dict = self._build_interp_on_var_size(
+                    var_out, dim_in, dim_out, interp_type, log_prefix
+                )
+            else:
+                if interp_type != self.LINEAR:
+                    raise NotImplementedError
+                interp_dict = self._build_inter_on_var_names(
+                    var_out, dim_out, split_pattern, log_prefix
+                )
+            interp_logic[var_out] = interp_dict
+
+        # Call _build_interp_from_logic using the logic built above
+        self._build_interp_from_logic(interp_logic)
+
+    def _check_interp(self) -> None:
+        """Check that all variables are correctly connected."""
+        vars_in = self.design_space_in.variable_names
+
+        def _check_size_zero(item):
+            if len(item) == 0:
+                raise KeyError
+
+        for var_out in self.design_space_out.variable_names:
+            try:
+                dict_prolg = self._prolg_oper[var_out]
+
+                # Might have been declared empty by mistake
+                _check_size_zero(dict_prolg)
+            except KeyError as exc:
+                err = f"{var_out} not connected to any input variable"
+                raise MappingError(err) from exc
+            for var in iter(list(dict_prolg.keys())):
+                if var not in vars_in:
+                    err = (
+                        f"{var_out} connected to variable: {var} "
+                        f"not belonging to input variables: {vars_in}"
+                    )
+                    raise MappingError(err)
+
+    def _compute_factors(self) -> None:
+        """Compute factors."""
+        prolg_arr, _, _ = self.get_jac_array()
+        self._norm_prolg = norm(prolg_arr, ord=inf)
+        self._restr_factor = 1.0 / norm(prolg_arr.T, ord=inf)
+
+    def _map_vars_direct(self, dvs_dict_in: dict) -> dict:
+        """TODO.
+
+        Args:
+            dvs_dict_in: ??? TODO.
+
+        Returns:
+            ??? TODO
+        """
+        dvs_dict_out = {}
+        # Loop on vars out
+        for var_out, prolg_link in iter(list(self._prolg_oper.items())):
+            val_out = zeros(self.design_space_out.get_size(var_out))
+            # Loop on vars in
+            for var_in, sub_oper in prolg_link.items():
+                dvs_in = dvs_dict_in[var_in]
+                if isinstance(sub_oper, float):
+                    # Light storage
+                    val_out += sub_oper * dvs_in
+                else:
+                    # Array
+                    val_out += sub_oper.dot(dvs_in)
+            dvs_dict_out[var_out] = val_out
+        return dvs_dict_out
+
+    def _map_vars_reverse(self, dvs_dict_out: dict) -> dict:
+        """TODO.
+
+        Args:
+            dvs_dict_out: ??? TODO.
+
+        Returns:
+            ??? TODO.
+        """
+        dvs_dict_in = {}
+        # Loop on vars in
+        for var_in, restr_link in iter(list(self._restr_oper.items())):
+            val_in = zeros(self.design_space_in.get_size(var_in))
+            # Loop on vars out
+            for var_out, sub_oper in restr_link.items():
+                dvs_out = dvs_dict_out[var_out]
+                if isinstance(sub_oper, float):
+                    val_in += sub_oper * dvs_out
+                else:
+                    # sub_oper is a reference to the prolg operator for efficiency
+                    # Therefore use sub_oper.T
+                    val_in += dvs_out.dot(sub_oper)
+            # Apply the restriction factor
+            val_in *= self._restr_factor
+            dvs_dict_in[var_in] = val_in
+        return dvs_dict_in
+
+    def get_jac(self) -> dict:
+        """Get the jacobian."""
+        jac_dict = {}
+
+        # Make sure everything is formated into arrays
+        for var_out, prolg_link in iter(list(self._prolg_oper.items())):
+            jac_dict[var_out] = {}
+            for var_in, oper in iter(list(prolg_link.items())):
+                if isinstance(oper, float):
+                    prolg = eye(self.design_space_out.get_size(var_out))
+                else:
+                    # Copy to be on the safe side
+                    prolg = oper.copy()
+                jac_dict[var_out][var_in] = prolg
+        # Build arrays
+        return deepcopy(jac_dict)

gemseo_multi_fidelity/mapping/mapper_factory.py

@@ -0,0 +1,70 @@
+# 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
+"""A factory to create a design space mapper from its name."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+from typing import ClassVar
+
+from gemseo_multi_fidelity.mapping.identity_mapper import IdentityMapper
+from gemseo_multi_fidelity.mapping.interp_mapper import InterpolationMapper
+
+if TYPE_CHECKING:
+    from gemseo.algos.design_space import DesignSpace
+
+    from gemseo_multi_fidelity.core.ds_mapper import DesignSpaceMapper
+
+
+class DSMapperFactory:
+    """DesignSpaceMapper factory."""
+
+    ID = "identity"
+    INTERP = "interp"
+
+    AVAILABLE_MAPPERS: ClassVar[list] = [ID, INTERP]
+    """List of available mappers."""
+
+    def create(
+        self, name: str, ds_in: DesignSpace, ds_out: DesignSpace, **kwargs
+    ) -> DesignSpaceMapper:
+        """Create a DesignSpace Mapper from its name.
+
+        Args:
+            name: The name of the DesignSpace Mapper to use.
+            ds_in: The input design space.
+            ds_out: The output design space.
+            kwargs: The keyword arguments to be passed to the mapper class.
+
+        Returns:
+            The DesignSpace Mapper.
+        """
+        if name == self.ID:
+            klass = IdentityMapper
+        elif name == self.INTERP:
+            klass = InterpolationMapper
+        else:
+            msg = f"{name} not in {self.AVAILABLE_MAPPERS}"
+            raise ValueError(msg)
+
+        return klass(ds_in, ds_out, **kwargs)

gemseo_multi_fidelity/mapping/mapping_errors.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
+"""Mapping error."""
+
+from __future__ import annotations
+
+
+class MappingError(Exception):
+    """Error to raise if a mapping is not consistent."""
+
+    def __init__(self, msg: str | None = None) -> None:
+        """Constructor.
+
+        Args:
+            msg: The explanation for the error.
+        """
+        super().__init__()
+        self.msg = msg
+
+    def __str__(self) -> str:
+        """Textual representation of the Error.
+
+        Returns:
+            The textual representation.
+        """
+        return repr(self.msg)

gemseo_multi_fidelity/mapping/subset_mapper.py

@@ -0,0 +1,122 @@
+# 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) 2020 AIRBUS OPERATIONS
+
+#
+# Contributors:
+#    INITIAL AUTHORS - API and implementation and/or documentation
+#      :author: Romain Olivanti
+#    OTHER AUTHORS   - MACROSCOPIC CHANGES
+"""Subset mapper."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from numpy import array
+
+from gemseo_multi_fidelity.core.ds_mapper import DesignSpaceMapper
+
+if TYPE_CHECKING:
+    from gemseo.algos.design_space import DesignSpace
+    from numpy.typing import NDArray
+
+
+class SubsetMapper(DesignSpaceMapper):
+    """Mapper of only a subset of variables."""
+
+    def __init__(
+        self,
+        design_space_in: DesignSpace,
+        design_space_out: DesignSpace,
+        vars_mapping: dict | None = None,
+    ) -> None:
+        """Constructor.
+
+        Args:
+            design_space_in: The input DesignSpace object.
+            design_space_out: The output DesignSpace object.
+            vars_mapping: The user-defined mapping between input and output variables.
+        """
+        super().__init__(design_space_in, design_space_out)
+        self._vars_mapping = self._check_vars_mapping(vars_mapping)
+
+    def _check_vars_mapping(self, vars_mapping: dict) -> dict:
+        vars_in = self.design_space_in.variable_names
+        vars_out = self.design_space_out.variable_names
+        if vars_mapping is None:
+            # Find the variables that can be matched automatically
+            vars_mapping = {}
+
+            for var in vars_out:
+                if var in vars_in:
+                    vars_mapping[var] = var
+        else:
+            if not isinstance(vars_mapping, dict):
+                msg = "vars_mapping must be a dict or None"
+                raise TypeError(msg)
+            linked_vars_in = []
+            for var_out, var_in in vars_mapping.items():
+                if var_out not in vars_out:
+                    msg = f"{var_out} not in {vars_out}"
+                    raise ValueError(msg)
+                if var_in not in vars_in:
+                    msg = f"{var_in} not in {vars_in}"
+                    raise ValueError(msg)
+                if var_in in linked_vars_in:
+                    msg = f"{var_in} linked to more than one var out"
+                    raise ValueError(msg)
+                linked_vars_in.append(var_in)
+        return vars_mapping
+
+    def _map_vars_direct(self, dvs_dict_in: DesignSpace) -> DesignSpace:
+        """Map vars direct.
+
+        Args:
+            dvs_dict_in: The input design space.
+
+        Returns:
+            The output design space.
+        """
+        sub_dict_out = {
+            var_out: dvs_dict_in[var_in]
+            for var_out, var_in in self._vars_mapping.items()
+        }
+        dvs_dict_out = self.design_space_out.get_current_value(as_dict=True)
+        dvs_dict_out.update(sub_dict_out)
+        return dvs_dict_out
+
+    def _map_vars_reverse(self, dvs_dict_out: DesignSpace) -> DesignSpace:
+        """Map vars reverse.
+
+        Args:
+            dvs_dict_out: The output design space.
+
+        Returns:
+            The input design space.
+        """
+        return {
+            var_in: dvs_dict_out[var_out]
+            for var_out, var_in in self._vars_mapping.items()
+        }
+
+    def get_jac(self) -> NDArray:
+        """Get the jacobian.
+
+        Args:
+            The jacobian.
+        """
+        return {key: {val: array([[1.0]])} for key, val in self._vars_mapping.items()}

gemseo_multi_fidelity/mf_rosenbrock/__init__.py

@@ -0,0 +1,16 @@
+# 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.
+
+"""Rosenbrock test case for multi-fidelity."""