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

gemseo_multi_fidelity/core/mf_logger.py

@@ -0,0 +1,216 @@
+# 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
+"""MF Logger.
+
+Provides simple features to get a common multi-fidelity output, distinct from the rest
+of the data logged.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from logging import Logger
+
+
+class MFLogger:
+    """Multi-fidelity logger."""
+
+    TAG_WRAP_LINE = "@WRAP_LINE@"
+
+    def __init__(
+        self,
+        logger: Logger | None = None,
+        padding: int = 2,
+        min_wrap: int = 3,
+        wrap_char: str = "-",
+        align_center_at: int = 33,
+    ) -> None:
+        """Constructor.
+
+        Args:
+            logger: The logger to use to write the log. If not provided, the default
+                GEMSEO logger will be used.
+            padding: The padding to set between the wrap chars and the content of the
+                data logged.
+            min_wrap: The minimum number of wrap chars to use on the longest line
+                logged.
+            wrap_char: The char to use to wrap the content.
+            align_center_at: The value at which the data logged will be aligned.
+                If the size of one of the lines to log is too big, the data will not be
+                aligned.
+        """
+        self._check_inputs(padding, min_wrap, wrap_char, align_center_at)
+
+        if logger is None:
+            import logging
+
+            logger = logging.getLogger(__name__)
+
+        self._logger = logger
+        self._padding = padding
+        self._min_wrap = min_wrap
+        self._wrap_char = wrap_char
+        self._align_center_at = align_center_at
+
+        self._map_replace = {}
+        self._info_lines = []
+        self._log_data = []
+
+    @staticmethod
+    def _check_inputs(
+        padding: int, min_wrap: int, wrap_char: str, align_center_at: int
+    ) -> None:
+        """Check the inputs.
+
+        Args:
+            padding: The padding to set between the wrap chars and the content of the
+                data logged.
+            min_wrap: The minimum number of wrap chars to use on the longest line
+                logged.
+            wrap_char: The char to use to wrap the content.
+            align_center_at: The value at which the data logged will be aligned.
+                If the size of one of the lines to log is too big, the data will not be
+                aligned.
+        """
+        vars_to_check = ["padding", "min_wrap", "align_center_at"]
+        values_to_check = [padding, min_wrap, align_center_at]
+        for name, value in zip(vars_to_check, values_to_check, strict=False):
+            if not isinstance(value, int):
+                msg = f"{name} not an int"
+                raise TypeError(msg)
+            if value < 0:
+                msg = f"{name} must be >= 0"
+                raise ValueError(msg)
+        if not isinstance(wrap_char, str):
+            msg = "wrap char must be a str"
+            raise TypeError(msg)
+        if len(wrap_char) != 1:
+            msg = f"{wrap_char} must be a single char"
+            raise ValueError(msg)
+
+    def add_line(self, line: str, clear: bool = False) -> None:
+        """Add a line in memory to be logged later.
+
+        Args:
+            line: The line to log.
+            clear: The flag to clear the current data stored.
+        """
+        if clear:
+            self.clear()
+        self._info_lines.append(line)
+
+    def add_wrap_line(self) -> None:
+        """Add wrap line."""
+        self._info_lines.append(self.TAG_WRAP_LINE)
+
+    def add_tag_link(self, tag: str, value: str) -> None:
+        """Add tag link.
+
+        Args:
+            tag: The tag name.
+            value: The tag value.
+        """
+        tag = str(tag)
+        value = str(value)
+        self._map_replace[tag] = value
+
+    def get_tag_links(self) -> dict:
+        """Get tag links.
+
+        Returns:
+            A copy of the tag link dict.
+        """
+        return self._map_replace.copy()
+
+    def clear(self) -> None:
+        """Clear."""
+        self._info_lines = []
+
+    def _build_log_data(self) -> None:
+        """Compute the max length taking into the data stored in ``map_replace``."""
+        # use the minimum padding settings
+        max_len = 0
+
+        full_lines = []
+        add_line = full_lines.append
+        for line in self._info_lines:
+            full_line = line
+            if line == self.TAG_WRAP_LINE:
+                # Specific wrap tag skip
+                add_line(line)
+                continue
+            # Try to replace specific tags
+            for tag, value in self._map_replace.items():
+                full_line = full_line.replace(tag, value)
+            add_line(full_line)
+            len_line = len(full_line) + 2 * (self._padding + self._min_wrap)
+            if len_line > max_len:
+                max_len = len_line
+
+        # Make it odd
+        if max_len % 2 == 0:
+            max_len += 1
+
+        # Compute the spacing due to the align parameter
+        line_center = max_len // 2 + 1
+        spacing = self._align_center_at - line_center
+
+        if spacing < 0:
+            # Do not add any spacing
+            spacing = 0
+
+        spacing = " " * spacing
+
+        dashed_line = spacing + "".join([self._wrap_char] * max_len)
+        self._log_data = ["", dashed_line]
+
+        add_data = self._log_data.append
+        padding = "".join([" "] * self._padding)
+
+        # Compute the real padding
+        for line in full_lines:
+            if line == self.TAG_WRAP_LINE:
+                add_data(dashed_line)
+            else:
+                n_dash = max_len - len(line) - 2 * self._padding
+                extra_space = "" if n_dash % 2 == 0 else " "
+                half_dash = "".join([self._wrap_char] * (n_dash // 2))
+                info_line = (
+                    f"{half_dash}{padding}{line}{extra_space}{padding}{half_dash}"
+                )
+                add_data(spacing + info_line)
+
+        self._log_data += [dashed_line]
+
+    def log(self, clear: bool = False) -> None:
+        """Log.
+
+        Args:
+            clear: Whether the logger must be cleared.
+        """
+        self._build_log_data()
+        list(map(self._logger.info, self._log_data))
+        if clear:
+            self.clear()

gemseo_multi_fidelity/core/mf_opt_problem.py

@@ -0,0 +1,480 @@
+# 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
+"""MF optimization problem."""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING
+from typing import Any
+
+import h5py
+from gemseo.algos.database import Database
+from gemseo.algos.optimization_problem import OptimizationProblem
+from gemseo.utils.hdf5 import get_hdf5_group
+from numpy import array
+from numpy import issubdtype
+from numpy import ndarray
+from numpy import number as np_number
+from six import string_types
+
+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
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+    from collections.abc import Iterable
+    from pathlib import Path
+
+    from gemseo.algos.design_space import DesignSpace
+    from gemseo.core.mdo_functions.collections.constraints import Constraints
+    from numpy.typing import NDArray
+    from typing_extensions import Self
+
+LOGGER = logging.getLogger(__name__)
+
+
+class MFOptimizationProblem:
+    """Multi-fidelity optimization problem class."""
+
+    MF_PROB_GROUP = "mf_problem"
+    MF_DTB_GROUP = "ref_database"
+    MF_F_MAP_GROUP = "func_mapping"
+
+    def __init__(
+        self,
+        sub_opt_problems: Iterable[OptimizationProblem],
+        eval_mappers: Iterable[EvaluationMapper],
+        ref_databases: Iterable[Database],
+    ) -> None:
+        """Constructor."""
+        self._check_inputs(sub_opt_problems, eval_mappers, ref_databases)
+        self.sub_opt_problems: list[OptimizationProblem] = sub_opt_problems
+        self.eval_mappers: list[EvaluationMapper] = eval_mappers
+        self.ref_databases: list[Database] = ref_databases
+
+        self._run_exec = None
+        self._set_option = None
+        self._add_callback = None
+
+    @property
+    def design_space(self) -> DesignSpace:
+        """Get design space."""
+        return self.sub_opt_problems[0].design_space
+
+    @property
+    def constraints(self) -> Constraints:
+        """Get constraints."""
+        return self.sub_opt_problems[0].constraints
+
+    @property
+    def is_linear(self):
+        """Get if an optimization problem is linear."""
+        return self.sub_opt_problems[0].is_linear
+
+    def check(self):
+        """Check."""
+
+    def preprocess_functions(self, *args, **kwargs):
+        """Preprocess functions."""
+
+    @property
+    def new_iter_observables(self):
+        """Get new iteration observables."""
+        return []
+
+    @property
+    def database(self) -> Database:
+        """Get database."""
+        return self.sub_opt_problems[0].database
+
+    def _new_iteration_callback(self, x_vect: NDArray) -> False:
+        """Iterate the progress bar, implement the stop criteria.
+
+        Args:
+            x_vect: The design variables values.
+
+        Raises:
+            MaxTimeReached: If the elapsed time is greater than the maximum execution
+                time.
+        """
+        # Deactivate this, it is handled by the subproblems
+        return
+
+    @staticmethod
+    def check_is_instance(obj: Any, klass: type | tuple(type)) -> None:
+        """Check that an object is an instance of a class."""
+        if not isinstance(obj, klass):
+            msg = f"{obj} not a {klass.__name__}"
+            raise TypeError(msg)
+
+    def _check_inputs_types(
+        self,
+        sub_opt_problems: Iterable[OptimizationProblem],
+        eval_mappers: Iterable[EvaluationMapper],
+        ref_databases: Iterable[Database],
+    ):
+        for obj_list, klass in zip(
+            [sub_opt_problems, eval_mappers, ref_databases],
+            [OptimizationProblem, EvaluationMapper, Database],
+            strict=False,
+        ):
+
+            def check_type(obj):
+                MFOptimizationProblem.check_is_instance(obj, klass)  # noqa: B023
+
+            list(map(check_type, obj_list))
+
+    def _check_inputs_len(
+        self,
+        sub_opt_problems: Iterable[OptimizationProblem],
+        eval_mappers: Iterable[EvaluationMapper],
+        ref_databases: Iterable[Database],
+    ) -> None:
+        n_probs = len(sub_opt_problems)
+
+        if len(ref_databases) != n_probs:
+            msg = (
+                "Inconsistent number of sub-optimization problems "
+                f"reference databases: {n_probs:d} != {len(ref_databases):d}"
+            )
+            raise ConsistencyError(msg)
+        if len(eval_mappers) != n_probs - 1:
+            msg = (
+                f"Should be {n_probs - 1:d} "
+                f"evaluation mappers not {len(eval_mappers):d}"
+            )
+            raise ConsistencyError(msg)
+
+    @staticmethod
+    def _check_ds_consistency(
+        sub_opt_problems: Iterable[OptimizationProblem],
+        eval_mappers: Iterable[EvaluationMapper],
+    ) -> None:
+        # Make sure the design space of the sub opt problems and the evaluation mappers
+        # are correctly referenced
+        for i, mapper in enumerate(eval_mappers):
+            ds_in = mapper.design_space_mapper.design_space_in
+            ds_out = mapper.design_space_mapper.design_space_out
+            ds_upper = sub_opt_problems[i].design_space
+            ds_lower = sub_opt_problems[i + 1].design_space
+            if id(ds_in) != id(ds_lower):
+                msg = (
+                    "design spaces not correctly linked with "
+                    f"evaluation mappers: level {i:d}"
+                )
+                raise ConsistencyError(msg)
+            if id(ds_out) != id(ds_upper):
+                msg = (
+                    "design spaces not correctly linked with "
+                    f"evaluation mappers: level {i:d}"
+                )
+                raise ConsistencyError(msg)
+
+    def _check_inputs(
+        self,
+        sub_opt_problems: Iterable[OptimizationProblem],
+        eval_mappers: Iterable[EvaluationMapper],
+        ref_databases: Iterable[Database],
+    ) -> None:
+        """Check the inputs."""
+        # Make sure the all types are ok
+        self._check_inputs_types(sub_opt_problems, eval_mappers, ref_databases)
+
+        # Make sure the len are consistent
+        self._check_inputs_len(sub_opt_problems, eval_mappers, ref_databases)
+
+        # Check the consistency of the design spaces
+        self._check_ds_consistency(sub_opt_problems, eval_mappers)
+
+    @property
+    def n_levels(self) -> int:
+        """Get number of levels."""
+        return len(self.sub_opt_problems)
+
+    @property
+    def run_exec(self) -> Callable:
+        """Run execution getter."""
+        if self._run_exec is None:
+            msg = "Run exec not set"
+            raise RuntimeError(msg)
+        return self._run_exec
+
+    @run_exec.setter
+    def run_exec(self, func: Callable) -> None:
+        """Run execution setter."""
+        self._run_exec = func
+
+    def _check_level(self, level: int) -> None:
+        if level < 0 or level >= len(self.sub_opt_problems):
+            err = (
+                f"level = {level:d} does not specify a valid level: "
+                f"{list(range(len(self.sub_opt_problems)))}"
+            )
+            raise ValueError(err)
+
+    def add_callback(self, level: int, target: str, callback: Callable) -> None:
+        """Add callback.
+
+        Args:
+            level: The level.
+            target: The target name.
+            callback: The Callable.
+        """
+        self._check_level(level)
+        if self._add_callback is None:
+            msg = "_add_callback not set"
+            raise RuntimeError(msg)
+        self._add_callback(level, target, callback)
+
+    def set_exec_option(self, level: int, option: str, value: Any) -> None:
+        """Set execution option.
+
+        Args:
+            level: The level.
+            option: The option name.
+            value: The option value.
+        """
+        self._check_level(level)
+        if self._set_option is None:
+            msg = "_set_option not set"
+            raise RuntimeError(msg)
+        self._set_option(level, option, value)
+
+    def set_exec_options(self, level: int, options_dict: dict) -> None:
+        """Set execution options.
+
+        Args:
+            level: The level.
+            options_dict: The options.
+        """
+        for name, value in options_dict.items():
+            self.set_exec_option(level, name, value)
+
+    def to_hdf(
+        self, file_path: Path | str, append: bool = False, hdf_node_path: str = ""
+    ) -> None:
+        """Export to HDF.
+
+        Exports the multi-fidelity optimization problem to HDF file.
+        The high-fidelity problem can still be imported as a standard optimization
+        problem using this file.
+
+        Args:
+            file_path: The path of the file to store the data.
+            append: If ``True``, data is appended to the file if not empty.
+            hdf_node_path: The path of the HDF node in which the problem should be
+                exported, empty to select the root node.
+        """
+        LOGGER.info("Export multi-fidelity optimization problem to file: %s", file_path)
+        # The high-fidelity problem is stored as the root of the node provided
+        # to be read as a standard Optimization problem
+        self.sub_opt_problems[0].to_hdf(
+            file_path, append=append, hdf_node_path=hdf_node_path
+        )
+
+        # Open the file and store all the required data
+        # Always open in append mode as exporting the hifi problem will already clean
+        # the node if not in append mode
+        with h5py.File(file_path, mode="a") as h5file:
+            hdf_node = get_hdf5_group(h5file, hdf_node_path)
+
+            root_path = hdf_node_path + "/" if hdf_node_path != "" else ""
+
+            opt_node_paths = []
+            dtb_node_paths = []
+
+            # Build the groups required
+            for i in range(1, self.n_levels):
+                # The other problems are stored as sub-nodes
+                opt_path = f"{self.MF_PROB_GROUP}_{i:d}"
+                dtb_path = f"{self.MF_DTB_GROUP}_{i:d}"
+                f_map_path = f"{self.MF_F_MAP_GROUP}_{i - 1:d}"
+                # Build the groups
+                hdf_node.require_group(opt_path)
+                hdf_node.require_group(dtb_path)
+                f_map_grp = hdf_node.require_group(f_map_path)
+                # Add the path of the current HDF node as the HDF file is
+                # reloaded for each object before writing
+                opt_path = root_path + opt_path
+                dtb_path = root_path + dtb_path
+
+                # Store the func mapping
+                for f_in, f_out in self.eval_mappers[i - 1].output_mapping.items():
+                    f_out = array(f_out)
+                    self.__store_h5data(f_map_grp, f_out, f_in, f_out.dtype)
+                    # f_map_grp.require_dataset(
+                    #     f_in, f_out.shape, f_out.dtype, exact=True, data=(f_out,)
+                    # )
+
+                # Add the paths
+                opt_node_paths.append(opt_path)
+                dtb_node_paths.append(dtb_path)
+
+        # Call the export method of the objects to store
+        for i, (opt_prob, ref_dtb) in enumerate(
+            zip(self.sub_opt_problems[1::], self.ref_databases[1::], strict=False)
+        ):
+            # Sub-optimization problem
+            opt_prob.to_hdf(file_path, append=True, hdf_node_path=opt_node_paths[i])
+            # Reference database
+            ref_dtb.to_hdf(
+                file_path=file_path, append=True, hdf_node_path=dtb_node_paths[i]
+            )
+
+    @staticmethod
+    def from_hdf(
+        file_path: str | Path,
+        x_tolerance: float = 1e-10,
+        hdf_node_path: str | None = None,
+    ) -> Self:
+        """Import a multi-fidelity optimization problem from an HDF file.
+
+        Args:
+            file_path: The path of the file to read.
+            x_tolerance: The tolerance to read a point from the database.
+            hdf_node_path: The path of the HDF node from which the problem should be
+                imported, empty to specify the root node.
+
+        Returns:
+            The read multi-fidelity optimization problem.
+        """
+        LOGGER.info(
+            "Import multi-fidelity optimization problem from file: %s", file_path
+        )
+        with h5py.File(file_path, mode="r") as h5file:
+            hdf_node = get_hdf5_group(h5file, hdf_node_path)
+            root_path = hdf_node_path + "/" if hdf_node_path is not None else ""
+
+            # Check the consistency of the number of sub-problems stored
+            n_sub_lvl = len([
+                key
+                for key in hdf_node
+                if key.startswith(MFOptimizationProblem.MF_PROB_GROUP)
+            ])
+            n_ref_dtb = len([
+                key
+                for key in hdf_node
+                if key.startswith(MFOptimizationProblem.MF_DTB_GROUP)
+            ])
+            n_f_map = len([
+                key
+                for key in hdf_node
+                if key.startswith(MFOptimizationProblem.MF_F_MAP_GROUP)
+            ])
+
+            if (n_sub_lvl != n_ref_dtb) or (n_sub_lvl != n_f_map):
+                raise ConsistencyError(
+                    "Mismatch between the number of data stored " + "for each level"
+                )
+
+            sub_opt_problems = []
+            ref_databases = []
+            func_mappings = []
+
+            # Import the hi-fi problem
+            opt_prob = OptimizationProblem.from_hdf(
+                file_path, x_tolerance=x_tolerance, hdf_node_path=hdf_node_path
+            )
+            sub_opt_problems.append(opt_prob)
+            # The ref database of the hi-fi problem is the same as the one
+            # stored in the optimization problem
+            ref_databases.append(opt_prob.database)
+
+            for i in range(n_sub_lvl):
+                opt_path = f"{root_path}{MFOptimizationProblem.MF_PROB_GROUP}_{i + 1:d}"
+                dtb_path = f"{root_path}{MFOptimizationProblem.MF_DTB_GROUP}_{i + 1:d}"
+                f_map_path = f"{MFOptimizationProblem.MF_F_MAP_GROUP}_{i:d}"
+                # Import the sub-optimization problem and the reference database
+                opt_prob = OptimizationProblem.from_hdf(
+                    file_path, x_tolerance=x_tolerance, hdf_node_path=opt_path
+                )
+                ref_dtb = Database.from_hdf(file_path=file_path, hdf_node_path=dtb_path)
+
+                # Read the func mapping
+                func_mapping = {}
+                # Cannot fail at this point because the number of evaluation has
+                # been checked previously against the number of sublevels
+                f_map_grp = hdf_node[f_map_path]
+
+                for f_in in f_map_grp:
+                    f_in = str(f_in)
+                    f_out = str(f_map_grp[f_in])
+                    func_mapping[f_in] = f_out
+
+                sub_opt_problems.append(opt_prob)
+                ref_databases.append(ref_dtb)
+                func_mappings.append(func_mapping)
+
+        # Build limited eval mappers. They cannot actually map anything but provide the
+        # output mapping
+        eval_mappers = []
+        for i, (func_mapping, prob) in enumerate(
+            zip(func_mappings, sub_opt_problems[0:-1], strict=False)
+        ):
+            ds_mapper = DesignSpaceMapper(
+                sub_opt_problems[i + 1].design_space, prob.design_space
+            )
+            eval_mapper = EvaluationMapper(ds_mapper, func_mapping)
+            eval_mappers.append(eval_mapper)
+
+        return MFOptimizationProblem(sub_opt_problems, eval_mappers, ref_databases)
+
+    @staticmethod
+    def __store_h5data(
+        group: Any, data_array: NDArray, dataset_name: str, dtype: str | None = None
+    ) -> None:
+        """Store an array in a HDF5 file group.
+
+        Args:
+            group: The group pointer.
+            data_array: The data to be stored.
+            dataset_name: The name of the dataset to store the array.
+            dtype: Numpy dtype or string. If ``None``, dtype('f') will be used.
+                   TODO: clarify use of dtype argument
+        """
+        dtype = None
+        is_arr_n = isinstance(data_array, ndarray) and issubdtype(
+            data_array.dtype, np_number
+        )
+        attr = data_array
+        if isinstance(data_array, string_types):
+            attr = data_array.encode("ascii", "ignore")
+        elif isinstance(data_array, bytes):
+            attr = data_array.decode()
+        elif isinstance(data_array, ndarray) and not issubdtype(
+            data_array.dtype, np_number
+        ):
+            attr = str(data_array)
+            dtype = h5py.special_dtype(vlen=str)
+        elif hasattr(data_array, "__iter__") and not is_arr_n:
+            attr = [
+                att.encode("ascii", "ignore") if isinstance(att, string_types) else att
+                for att in data_array
+            ]
+            dtype = h5py.special_dtype(vlen=str)
+
+        if dataset_name in group:
+            del group[dataset_name]
+        group.create_dataset(dataset_name, data=attr, dtype=dtype)