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

gemseo_multi_fidelity/core/mf_scenario.py

@@ -0,0 +1,205 @@
+# 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
+"""Multi-fidelity MDO scenario."""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+from typing import TYPE_CHECKING
+from typing import Any
+from typing import ClassVar
+
+from gemseo.algos.database import Database
+
+# from gemseo.algos.opt.factory import OptimizationLibraryFactory
+from gemseo.algos.optimization_problem import OptimizationProblem
+from gemseo.scenarios.mdo_scenario import MDOScenario
+
+from gemseo_multi_fidelity.core.mf_opt_problem import MFOptimizationProblem
+from gemseo_multi_fidelity.drivers.mf_algo_factory import MFAlgoFactory
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+    from gemseo.algos.opt.factory import OptimizationLibraryFactory
+    from gemseo.core.discipline.discipline import Discipline
+
+    from gemseo_multi_fidelity.core.mf_formulation import MFFormulation
+
+LOGGER = logging.getLogger(__name__)
+
+
+class MFMDOScenario(MDOScenario):
+    """Multi-fidelity MDO Scenario class."""
+
+    _ALGO_FACTORY_CLASS: ClassVar[type[OptimizationLibraryFactory]] = MFAlgoFactory
+    """Algorithm factory class."""
+
+    formulation: MFFormulation
+
+    def __init__(
+        self,
+        disciplines: Sequence[MDOScenario],
+        formulation_name: str,
+        name: str | None = None,
+        **formulation_options: Any,
+    ):
+        """Constructor."""
+        hifi_scenario = disciplines[0]
+        design_space = hifi_scenario.design_space
+        objective_name = hifi_scenario.formulation.optimization_problem.objective_name
+        super().__init__(
+            disciplines=disciplines,
+            formulation_name=formulation_name,
+            objective_name=objective_name,
+            design_space=design_space,
+            name=name,
+            **formulation_options,
+        )
+        # self._algo_factory=MFAlgoFactory()
+
+    def _execute(self) -> None:
+        self.optimization_result = self._algo_factory.execute(
+            self.formulation.mf_opt_problem,
+            algo_name=self._settings.algo_name,
+            **self._settings.algo_settings,
+        )
+
+    @property
+    def disciplines(self) -> tuple[Discipline, ...]:
+        """The disciplines."""
+        return self.formulation.disciplines
+
+    def save_optimization_history(
+        self,
+        file_path,
+        file_format=OptimizationProblem.HistoryFileFormat.HDF5,
+        append=False,
+        hdf_node_path="",
+    ) -> None:
+        """Save the optimization history of the scenario to a file.
+
+        Args:
+            file_path: The path to the file to save the history.
+            file_format: The format of the file, either ``hdf5`` or ``ggobi``
+                (default value = ``hdf5``).
+            append: If True, data is appended to the file if not empty
+                (default value = ``False``).
+            hdf_node_path: The path of the HDF node in which the problem should be
+                exported, ``None`` to select the root node.
+        """
+        if file_format != OptimizationProblem.HistoryFileFormat.HDF5:
+            raise ValueError(
+                "Cannot export optimization history to file format:" + str(file_format)
+            )
+        self.formulation.mf_opt_problem.to_hdf(
+            file_path, append=append, hdf_node_path=hdf_node_path
+        )
+
+    def set_optimization_history_backup(
+        self,
+        file_path: str | Path,
+        at_each_iteration: bool = False,
+        at_each_function_call: bool = True,
+        erase: bool = False,
+        load: bool = False,
+        plot: bool = False,
+    ) -> None:
+        """Set the backup file to store the evaluations of the functions during the run.
+
+        Args:
+            file_path: The backup file path.
+            at_each_iteration: Whether the backup file is updated at every iteration of
+                the optimization.
+            at_each_function_call: Whether the backup file is updated at every function
+                call.
+            erase: Whether the backup file is erased before the run.
+            load: Whether the backup file is loaded before run, useful after a crash.
+            plot: Whether to plot the optimization history view at each iteration. The
+                plots will be generated only after the first two iterations.
+
+        Raises:
+            ValueError: If both ``erase`` and ``pre_load`` are ``True``.
+        """
+        opt_pb = self.formulation.optimization_problem
+        self.__history_backup_is_set = True
+        self._opt_hist_backup_path = Path(file_path)
+
+        if self._opt_hist_backup_path.exists():
+            if erase and load:
+                msg = (
+                    "Conflicting options for history backup, "
+                    "cannot pre load optimization history and erase it!"
+                )
+                raise ValueError(msg)
+            if erase:
+                LOGGER.warning(
+                    "Erasing optimization history in %s",
+                    self._opt_hist_backup_path,
+                )
+                self._opt_hist_backup_path.unlink()
+            elif load:
+                opt_pb.database.update_from_hdf(self._opt_hist_backup_path)
+                max_iteration = len(opt_pb.database)
+                if max_iteration != 0:
+                    opt_pb.evaluation_counter.current = max_iteration
+
+        opt_pb.add_listener(
+            self._execute_backup_callback,
+            at_each_iteration=at_each_iteration,
+            at_each_function_call=at_each_function_call,
+        )
+
+        if plot:
+            opt_pb.add_listener(
+                self._execute_plot_callback,
+                at_each_iteration=True,
+                at_each_function_call=False,
+            )
+
+        elif load:
+            # Load only the reference databases
+            ref_databases = self.formulation.get_reference_databases()
+            for i, _database in enumerate(ref_databases):
+                if i == 0:
+                    hdf_node = ""
+                else:
+                    dtb_group = MFOptimizationProblem.MF_DTB_GROUP
+                    hdf_node = f"{dtb_group}_{i:d}"
+                self.formulation._databases[i] = Database().from_hdf(
+                    file_path=file_path, hdf_node_path=hdf_node
+                )
+
+        def backup_callback(x_vect=None) -> None:
+            """A callback function to back up optimization history."""
+            self.save_optimization_history(file_path, append=True)
+
+        # Add the callback for each sub-problem
+        mf_opt_prob = self.formulation.mf_opt_problem
+        for sub_prob in mf_opt_prob.sub_opt_problems:
+            sub_prob.add_listener(
+                backup_callback,
+                at_each_iteration=at_each_iteration,
+                at_each_function_call=at_each_function_call,
+            )

gemseo_multi_fidelity/core/noise_criterion.py

@@ -0,0 +1,94 @@
+# 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
+"""Noise criterion."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from numpy import asarray
+from numpy import inner
+from numpy.linalg import norm
+
+if TYPE_CHECKING:
+    from numpy.typing import NDArray
+
+
+def check_gradient_by_step(
+    step: float | NDArray,
+    delta_func: float,
+    grad_orig: float | NDArray,
+    thr_step_check: float = 1e-5,
+    mul_step_thr: float = 0.05,
+) -> list[bool, str]:
+    """Check gradient by step."""
+    step = asarray(step)
+    grad_orig = asarray(grad_orig)
+    step_norm = norm(step)
+    thr_fail = mul_step_thr * step_norm
+
+    # Do not check above the threshold
+    if step_norm > thr_step_check:
+        msg = (
+            f"No gradient check allowed: ||step|| = {step_norm:.6g}, "
+            f"thr = {thr_step_check:.6g}"
+        )
+        is_consistent = True
+    else:
+        var_err = delta_func - inner(grad_orig, step).item()
+        is_consistent = abs(var_err) <= thr_fail
+        msg = f"Stepwise error: {var_err:.6g}, consistent: {is_consistent}"
+    return is_consistent, msg
+
+
+if __name__ == "__main__":
+    from numpy import array
+    from numpy import sum as np_sum
+    from numpy.random import Generator
+
+    def func(x_vect: NDArray) -> float:
+        """Sum."""
+        return np_sum(x_vect**2)
+
+    def grad(x_vect: NDArray, noise_per=0.0) -> NDArray:
+        """Gradient."""
+        real_grad = 2.0 * x_vect
+        if noise_per != 0.0:
+            grad_norm = norm(real_grad)
+            real_grad += grad_norm * noise_per * 1e-2 * Generator(x_vect.shape[0])
+        return real_grad
+
+    x_grad = array([2.0])
+    step = 1e-3
+    delta_func = func(x_grad + step) - func(x_grad)
+    grad_val = grad(x_grad, noise_per=0.0)
+
+    is_grad_correct, msg = check_gradient_by_step(
+        step, delta_func, grad_val, thr_step_check=1e-3, mul_step_thr=0.05
+    )
+    assert True
+
+    grad_val = grad(x_grad, noise_per=5.0)
+    is_grad_correct, msg = check_gradient_by_step(
+        step, delta_func, grad_val, thr_step_check=1e-3, mul_step_thr=0.05
+    )