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

gemseo_multi_fidelity/drivers/mf_driver_lib.py

@@ -0,0 +1,462 @@
+# 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
+#               Francois Gallard: portage to GEMSEO 6
+
+"""Multi-fidelity abstract driver library."""
+
+from __future__ import annotations
+
+from abc import abstractmethod
+from copy import deepcopy
+from logging import getLogger
+from time import time
+from typing import TYPE_CHECKING
+from typing import Any
+from typing import ClassVar
+
+from gemseo.algos.base_algorithm_library import BaseAlgorithmLibrary
+
+from gemseo_multi_fidelity.core.mf_logger import MFLogger
+from gemseo_multi_fidelity.core.scenario_adapter import MFScenarioAdapter
+
+# from gemseo_multi_fidelity.drivers.core.quad_updater import QuadUpdater
+# from gemseo_multi_fidelity.drivers.core.utils.precond_builder import PrecondBuilder
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+    from collections.abc import Iterable
+
+    from gemseo.algos.optimization_problem import OptimizationProblem
+    from gemseo.algos.optimization_result import OptimizationResult
+    from numpy.typing import NDArray
+
+    from gemseo_multi_fidelity.core.eval_mapper import EvaluationMapper
+    from gemseo_multi_fidelity.core.mf_opt_problem import MFOptimizationProblem
+
+LOGGER = getLogger(__name__)
+
+
+class MFDriverLibrary(BaseAlgorithmLibrary):
+    """Multi-fidelity Driver Library."""
+
+    DRIVER_NAME = "AbstractMFDriver"
+
+    X_START = "x_start"
+    INPUT_LEVEL = "input_level"
+    RUN_OPTIONS = "run_options"
+
+    OPTIONS_DIR = "options"
+    OPTIONS_MAP: ClassVar[dict] = {}
+
+    STATUS_CONVERGED = "converged"
+    STATUS_ERROR = "error"
+
+    HESS_PAIRS_X0 = "lmem_x0"
+    TIMESTAMP = "timestamp"
+    _problem: MFOptimizationProblem | None
+    """The optimization problem the driver library is bonded to."""
+
+    def __init__(self, algo_name: str = "Refinement") -> None:
+        """Constructor."""
+        super().__init__(algo_name)
+        self._x_0_driver = None
+        self._x_0_hf = None
+
+    @staticmethod
+    def _check_is_instance(
+        obj: Any, klass: type | tuple(type), err_msg: str | None = None
+    ) -> bool | None:
+        if not isinstance(obj, klass):
+            if not err_msg:
+                err_msg = f"{obj} not a {klass.__name__}"
+            raise TypeError(err_msg)
+        return True
+
+    def check_run_options(self, options: dict) -> dict:
+        """Check run options.
+
+        Args:
+            options: The options to check.
+
+        Returns:
+            The dict of checked options.
+        """
+        n_levels = len(self._problem.sub_opt_problems)
+
+        logger = MFLogger()
+        logger.add_line(self.DRIVER_NAME)
+
+        if options is None:
+            options = {}
+
+        if isinstance(options, dict):
+            # Specific setter, duplicate all options
+            options = [deepcopy(options) for i in range(n_levels)]
+            if len(options) > 0:
+                logger.add_line("single dictionary to set options")
+                logger.add_line("all options will be forwarded to all levels")
+        else:
+            # Is it iterable?
+            try:
+                len_options = len(options)
+                # Is it an iterable of dict?
+                for elem in options:
+                    self._check_is_instance(elem, dict)
+            except TypeError as exc:
+                msg = "options must be an iterable of dict or a single dict"
+                raise msg from exc
+
+            options = list(deepcopy(options))
+            # Is the len correct?
+            if len_options != n_levels:
+                n_missing = n_levels - len_options
+                logger.add_line(f"missing options for {n_missing:d} levels")
+                logger.add_line("default options will be used")
+                options += [{} for i in range(n_levels - len_options)]
+        logger.log()
+        return options
+
+    def set_run_options(self, options: Iterable[dict]) -> None:
+        """Set run options.
+
+        Args:
+            options: The options to set.
+        """
+        for level, opt_dict in enumerate(options):
+            self._problem.set_exec_options(level, opt_dict)
+
+    def _set_log_callbacks(self) -> None:
+        """Set specific callbacks dedicated to log some events."""
+        n_levels = len(self._problem.sub_opt_problems)
+
+        for level in range(n_levels):
+            lvl_logger = MFLogger()
+            lvl_logger.add_tag_link("$LVL$", level)
+            lvl_logger.add_line(self.DRIVER_NAME)
+            lvl_logger.add_line("Running level $LVL$")
+
+            def log_level_entry(local_data, logger=lvl_logger):
+                logger.log()
+
+            self._problem.add_callback(
+                level, MFScenarioAdapter.ON_ENTRY_CALLBACKS, log_level_entry
+            )
+
+    def _set_timestamp_callbacks(self) -> None:
+        for _level, prob in enumerate(self._problem.sub_opt_problems):
+
+            def log_timestamp(x_vect=None, prob=prob):
+                dtb = prob.database
+                x_new = dtb.get_x_vect(-1)
+                if dtb.get_function_value(self.TIMESTAMP, x_new) is None:
+                    dtb.store(x_new, {self.TIMESTAMP: time()})
+
+            prob.database.add_store_listener(log_timestamp)
+
+    def _match_level_from_dvs(self, dvs: dict) -> int | None:
+        """Find the index of the first level to which the dvs provided belong.
+
+        Args:
+            dvs: The dict of design variables.
+
+        Returns:
+            The index.
+        """
+        if not isinstance(dvs, dict):
+            msg = f"dvs must be a dict, got instead {type(dvs)}"
+            raise TypeError(msg)
+
+        for i, prob in enumerate(self._problem.sub_opt_problems):
+            design_space = prob.design_space
+            try:
+                design_space.check_membership(dvs)
+            except ValueError:
+                pass
+            else:
+                return i
+        return None
+
+    def _propagate_dvs(self, index: int, dvs: dict | None = None) -> None:
+        """Propagate the starting in all design spaces.
+
+        Args:
+            index: The index of the level to propagate from.
+            dvs: The dict of design variables.
+        """
+        # Set the starting point at the right level
+        if dvs is not None:
+            self._problem.sub_opt_problems[index].design_space.set_current_value(dvs)
+
+        if index != 0:
+            # Propagate to upper levels
+            for mapper in self._problem.eval_mappers[index - 1 :: -1]:
+                ds_mapper = mapper.design_space_mapper
+                ds_mapper.map_ds_direct()
+
+        n_adapters = len(self._problem.sub_opt_problems)
+        if index != n_adapters - 1:
+            # Propagate to lower levels
+            for mapper in self._problem.eval_mappers[index:n_adapters]:
+                ds_mapper = mapper.design_space_mapper
+                ds_mapper.map_ds_reverse()
+
+    def set_starting_point(self, options: dict) -> None:
+        """Set starting point.
+
+        Args:
+            options: The dict of options.
+        """
+        x_start = options.get(self.X_START)
+
+        if x_start is not None:
+            x_start = dict(x_start)
+            start_level = self._match_level_from_dvs(x_start)
+            if start_level is None:
+                err = f"{self.X_START} does not belong to any design space"
+                raise ValueError(err)
+        else:
+            start_level = options.get(self.INPUT_LEVEL, 0)
+            if start_level >= len(self._problem.sub_opt_problems):
+                err = f"{self.INPUT_LEVEL} does not specify a valid level"
+                raise ValueError(err)
+
+        # Propagate the starting point at all levels
+        self._propagate_dvs(start_level, dvs=x_start)
+
+    def _store_x_0(self, start_level: int) -> None:
+        """Store x_0.
+
+        Args:
+            start_level: The index of start level.
+        """
+        start_ds = self._problem.sub_opt_problems[start_level].design_space
+        hf_ds = self._problem.sub_opt_problems[0].design_space
+        self._x_0_driver = start_ds.get_current_value(as_dict=True)
+        self._x_0_hf = hf_ds.get_current_value(as_dict=True)
+
+    def get_hifi_opt_result(self) -> OptimizationResult:
+        """Get the HF optimization result.
+
+        Retrieves the optimum from the high-fidelity problem and builds an optimization
+        result object from it.
+
+        Returns:
+            The optimization result.
+        """
+        return self._problem.sub_opt_problems[0].solution
+        # # compute the best feasible or infeasible point
+        # f_opt, x_opt, is_feas, c_opt, c_opt_grad = hf_prob.get_optimum()
+        # if f_opt is not None and not hf_prob.minimize_objective:
+        #     f_opt = -f_opt
+        # x_0 = hf_prob.design_space.convert_dict_to_array(self._x_0_hf)
+        # return OptimizationResult(
+        #     x_0=x_0,
+        #     x_opt=x_opt,
+        #     f_opt=f_opt,
+        #     status=status,
+        #     constraint_values=c_opt,
+        #     constraints_grad=c_opt_grad,
+        #     optimizer_name=self.algo_name,
+        #     message=message,
+        #     n_obj_call=hf_prob.objective.execution_statistics.n_calls,
+        #     is_feasible=is_feas
+        # )
+
+    # TODO: CLEAN (SEEMS TO BE DEAD CODE)
+    # def _pre_run(self, problem: MFOptimizationProblem, **settings: Any) -> None:
+    #     """Pre-run.
+    #
+    #     Args:
+    #         problem: The optimization problem.
+    #         settings: The settings kwargs.
+    #     """
+    #     self.set_starting_point(settings)
+    #     # Extract and set run options
+    #     run_options = self.check_run_options(settings.get(self.RUN_OPTIONS, {}))
+    #     self.set_run_options(run_options)
+    #
+    #     # Call _set_log_callbacks after the run options as the user can
+    #     # define the callbacks using the run options
+    #     self._set_log_callbacks()
+    #     self._set_timestamp_callbacks()
+    #
+    #     # Lib-specific pre-run
+    #     start_level = self._pre_run(problem, **settings)
+    #     self._store_x_0(start_level)
+
+    def _new_iteration_callback(self, x_vect: NDArray) -> None:
+        # deactivate iter handling
+        pass
+
+    def _get_result(
+        self,
+        problem: MFOptimizationProblem,
+        message: Any,
+        status: Any,
+        *args: Any,
+    ) -> OptimizationResult:
+        """Return the result of the resolution of the problem.
+
+        Args:
+            message: The message associated with the termination criterion if any.
+            status: The status associated with the termination criterion if any.
+            *args: Specific arguments.
+        """
+        return self._RESULT_CLASS.from_optimization_problem(
+            problem.sub_opt_problems[0],
+            message=message,
+            status=status,
+            optimizer_name=self._algo_name,
+        )
+
+    @abstractmethod
+    def _run(
+        self, problem: MFOptimizationProblem, **settings: Any
+    ) -> OptimizationResult:
+        return
+
+    def _get_result(self, problem: MFOptimizationProblem) -> OptimizationResult:
+        """Return the result of the resolution of the problem.
+
+        Args:
+            message: The message associated with the termination criterion if any.
+            status: The status associated with the termination criterion if any.
+            *args: Specific arguments.
+        """
+        return problem.sub_opt_problems[0].solution
+
+    # def _post_run(
+    #     self,
+    #     problem: MFOptimizationProblem,
+    #     result: OptimizationResult,
+    #     max_design_space_dimension_to_log: int,
+    #     **settings: Any,
+    # ) -> None:
+    #     print("MF driver lib _post_run sub problems 0")
+    #     super(MFDriverLibrary)._post_run(
+    #         problem.sub_opt_problems[0],
+    #         result=result,
+    #         max_design_space_dimension_to_log=max_design_space_dimension_to_log,
+    #         **settings
+    #     )
+
+    # def execute(
+    #     self,
+    #     problem:MFOptimizationProblem,
+    #     settings_model: BaseMFDriver_Settings | None = None,
+    #     **settings: Any)-> OptimizationResult:
+    #
+    #     self._problem = problem
+    #     # problem.check()
+    #     settings = self._validate_settings(settings_model=settings_model, **settings)
+    #
+    #
+    #     #options = self._load_options(**settings)
+    #
+    #     # Set the starting point
+    #     self.set_starting_point(settings)
+    #     # Extract and set run options
+    #     run_options = self.check_run_options(settings.get(self.RUN_OPTIONS, {}))
+    #     self.set_run_options(run_options)
+    #
+    #     # Call _set_log_callbacks after the run options as the user can
+    #     # define the callbacks using the run options
+    #     self._set_log_callbacks()
+    #     self._set_timestamp_callbacks()
+    #
+    #     # Lib-specific pre-run
+    #     start_level = self._pre_run(problem, **settings)
+    #     self._store_x_0(start_level)
+    #
+    #     # Run the driver
+    #     result = self._run(problem, **settings)
+    #
+    #     # Lib-specific post-run
+    #     self._post_run(
+    #         problem.sub_opt_problems[0],
+    #         result,
+    #         max_design_space_dimension_to_log=40,
+    #         **settings
+    #     )
+    #
+    #     return result
+
+    def set_auto_restart(self, level: int) -> None:
+        """Set a level to make sure that it can be auto-restarted.
+
+        i.e. that its output point is also set as the next starting point.
+
+        Args:
+            level: The index of the level to target.
+        """
+
+        def set_restart(local_data):
+            x_best = local_data[MFScenarioAdapter.X_BEST]
+            local_data[MFScenarioAdapter.X_START] = deepcopy(x_best)
+
+        self._problem.add_callback(
+            level, MFScenarioAdapter.ON_EXIT_CALLBACKS, set_restart
+        )
+
+    @staticmethod
+    def _build_precond_build_callback(
+        opt_problem: OptimizationProblem, mapper: EvaluationMapper
+    ) -> Callable:
+        """Build callback to build a preconditioner.
+
+        Builds a callback allowing to build a preconditioner from the database of the
+        optimization problem provided. The callback stores it in the output options of
+        the scenario adapter to be used by the next level.
+        If a mapper is provided, the preconditioner is mapped accordingly.
+
+        Args:
+            opt_problem: The optimization problem from which the preconditioner is
+                built.
+            mapper: The mapper to map the hessian approximation pairs used to build the
+                preconditioner.
+
+        Returns:
+            The callback.
+        """
+        raise NotImplementedError
+
+    @staticmethod
+    def _build_precond_forward_callback(mapper: EvaluationMapper) -> Callable:
+        """Build preconditioner forwarding callback.
+
+        Builds a callback allowing to forward the preconditioner used at the current
+        level to the next one.
+
+        Args:
+            mapper: The mapper to map the preconditioner.
+
+        Returns:
+            The callback.
+        """
+        raise NotImplementedError
+
+    @staticmethod
+    def _build_pairs_builder(
+        opt_problem: OptimizationProblem, max_corr: int = 100
+    ) -> callable:
+        raise NotImplementedError

gemseo_multi_fidelity/drivers/refinement.py

@@ -0,0 +1,234 @@
+# 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
+#               Francois Gallard: portage to GEMSEO 6
+"""Refinement driver."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+from copy import deepcopy
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+from typing import Any
+from typing import ClassVar
+from typing import Final
+
+from gemseo.algos.opt.base_optimization_library import OptimizationAlgorithmDescription
+
+from gemseo_multi_fidelity.core.scenario_adapter import MFScenarioAdapter
+from gemseo_multi_fidelity.drivers.mf_driver_lib import MFDriverLibrary
+from gemseo_multi_fidelity.drivers.settings.mf_refine_settings import MFRefine_Settings
+from gemseo_multi_fidelity.mapping.identity_mapper import IdentityMapper
+
+if TYPE_CHECKING:
+    from gemseo.algos.optimization_result import OptimizationResult
+
+    from gemseo_multi_fidelity.core.mf_opt_problem import MFOptimizationProblem
+    from gemseo_multi_fidelity.drivers.settings.base_mf_driver_settings import (
+        BaseMFDriver_Settings,
+    )
+
+
+@dataclass
+class RefinementAlgorithmDescription(OptimizationAlgorithmDescription):
+    """The description of the SciPy local optimization library."""
+
+    library_name: str = "MF Refinement"
+    """The library name."""
+
+    Settings: type[BaseMFDriver_Settings] = MFRefine_Settings
+    """The option validation model for Refinement library."""
+
+
+class Refinement(MFDriverLibrary):
+    """Refinement driver class."""
+
+    __DOC: Final[str] = ""
+
+    ALGORITHM_INFOS: ClassVar[dict[str, RefinementAlgorithmDescription]] = {
+        "MF_REFINE": RefinementAlgorithmDescription(
+            algorithm_name="MF_REFINE",
+            description=(
+                "Refinement driver, sequentially solves the optimization problems."
+            ),
+            internal_algorithm_name="MF_REFINE",
+            require_gradient=False,
+            Settings=MFRefine_Settings,
+            handle_multiobjective=False,
+            handle_integer_variables=True,
+            handle_equality_constraints=True,
+            handle_inequality_constraints=True,
+        ),
+    }
+    """The algorithm infos."""
+
+    BUILD_PRECOND = "build_precond"
+    FORWARD_PRECOND = "forward_precond"
+
+    def __init__(self, algo_name: str = "MF_REFINE") -> None:
+        """Constructor."""
+        super().__init__(algo_name=algo_name)
+
+    @staticmethod
+    def _check_not_instance(
+        obj: Any, klass: type | tuple(type), err_msg: str | None = None
+    ) -> bool | None:
+        if isinstance(obj, klass):
+            if not err_msg:
+                if isinstance(klass, tuple):
+                    # Find which class in the tuple matches
+                    matching_classes = [cls for cls in klass if isinstance(obj, cls)]
+                    class_names = ", ".join(cls.__name__ for cls in matching_classes)
+                    err_msg = f"{obj} is a {class_names}"
+                else:
+                    err_msg = f"{obj} is a {klass.__name__}"
+            raise TypeError(err_msg)
+        return True
+
+    @staticmethod
+    def check_iterable(
+        value: Any,
+        size: int,
+        type_to_check: type | None = None,
+        input_name: str = "",
+    ) -> Iterable:
+        """Check iterable.
+
+        Args:
+            value: The input value.
+            size: The size to match.
+            type_to_check: The type to match.
+            input_name: The input name.
+
+        Returns:
+             The checked value.
+        """
+        try:
+            Refinement._check_not_instance(value, (dict, str))
+            if len(value) != size:
+                err_size = f"len {input_name} != {size:d}"
+                raise ValueError(err_size)
+            for item in value:
+                Refinement._check_is_instance(item, type_to_check)
+        except TypeError as exc:
+            if type_to_check is not None and not isinstance(value, type_to_check):
+                err_type = (
+                    f"{input_name} must be a {type_to_check} ",
+                    f"or a list of {type_to_check}",
+                )
+                raise TypeError(err_type) from exc
+            value = [deepcopy(value) for i in range(size)]
+        return value
+
+    def _check_precond_options(self) -> None:
+        """Check the preconditioner options."""
+        # Build precond
+        self.check_iterable(
+            self._settings.build_precond,
+            self._problem.n_levels,
+            type_to_check=bool,
+            input_name=self.BUILD_PRECOND,
+        )
+        # Forward precond
+        self.check_iterable(
+            self._settings.forward_precond,
+            self._problem.n_levels,
+            type_to_check=bool,
+            input_name=self.FORWARD_PRECOND,
+        )
+
+    def _build_precond_callbacks(self) -> None:
+        """Build the preconditioner callbacks."""
+        build_flags = self._settings.build_precond
+        forward_flags = self._settings.forward_precond
+        if not build_flags and not forward_flags:
+            return
+
+        if not isinstance(forward_flags, Iterable):
+            forward_flags = [forward_flags] * self._problem.n_levels
+
+        if not isinstance(build_flags, Iterable):
+            build_flags = [build_flags] * self._problem.n_levels
+
+        for i, (build_precond, forward_precond) in enumerate(
+            zip(build_flags, forward_flags, strict=False)
+        ):
+            if not (build_precond or forward_precond):
+                # Nothing to do
+                continue
+
+            # Select the evaluation mapper - No mapper for the top level
+            mapper = self._problem.eval_mappers[i - 1] if i != 0 else None
+            # Build flag has the priority over the forward one
+            if build_precond:
+                # Build the callback
+                callback = self._build_precond_build_callback(
+                    self._problem.sub_opt_problems[i], mapper
+                )
+            elif forward_precond:
+                if mapper is None or isinstance(
+                    mapper.design_space_mapper, IdentityMapper
+                ):
+                    callback = self._build_precond_forward_callback(mapper)
+                else:
+                    raise NotImplementedError
+
+            # Add it to the on exit callbacks
+            self._problem.add_callback(i, MFScenarioAdapter.ON_EXIT_CALLBACKS, callback)
+
+    def _pre_run(self, problem: MFOptimizationProblem) -> int:
+        """Pre-run.
+
+        Args:
+            problem: The optimization problem.
+
+        Returns:
+            The start level.
+        """
+        # Start at the lowest level
+        start_level = self._problem.n_levels - 1
+        self._check_precond_options()
+        self._build_precond_callbacks()
+        self._store_x_0(start_level)
+        return start_level
+
+    def _run(
+        self, problem: MFOptimizationProblem, **settings: Any
+    ) -> OptimizationResult:
+        """Run.
+
+        Args:
+            problem: The optimization problem.
+            settings: The keyword arguments to pass as settings.
+
+        Returns:
+            The optimization result.
+        """
+        x_start = self._x_0_driver
+        # try:
+        self._problem.run_exec(x_start)
+        return self.get_hifi_opt_result()
+        # except Exception as err:
+        #     status = self.STATUS_ERROR
+        #     message = "{}: {}".format(err.__class__.__name__, err)
+        #     solution= OptimizationResult(message=message,status=status)