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

gemseo_multi_fidelity/core/corr_function.py

@@ -0,0 +1,411 @@
+# 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
+"""MDOCorrected Function."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+from typing import Any
+
+from gemseo.algos.database import Database
+from gemseo.core.mdo_functions.mdo_function import MDOFunction
+from numpy import array
+from numpy import delete
+from numpy import flip
+from numpy import where
+from numpy.linalg import norm
+
+from gemseo_multi_fidelity.models.model_updater import ModelUpdater
+
+if TYPE_CHECKING:
+    from numpy import ndarray
+    from numpy.typing import NDArray
+
+
+class MDOCorrectedFunction(MDOFunction):
+    """MDO Corrected Function class.
+
+    Corrected function, that can be dynamically updated using the provided correction
+    database. Protects the calls to the original function using this database and store
+    the reference data provided.
+    """
+
+    REF_TAG = "#CORR_REF#"
+
+    def __init__(
+        self, orig_func: MDOFunction, corr_model: ModelUpdater, corr_database: Database
+    ) -> None:
+        """Constructor.
+
+        Args:
+            orig_func: The uncorrected function.
+            corr_model: The model used for the correction.
+            corr_database: The database used for the correction.
+        """
+        if not isinstance(orig_func, MDOFunction):
+            msg = "orig_func must be a MDOFunction"
+            raise TypeError(msg)
+
+        if not isinstance(corr_database, Database):
+            msg = "corr_database must be a Database"
+            raise TypeError(msg)
+
+        if not isinstance(corr_model, ModelUpdater):
+            msg = "corr_model must be an instance of ModelUpdater"
+            raise TypeError(msg)
+
+        # Clone the specified attr
+        args_names = ["func", "name"]
+        args = [getattr(orig_func, attr) for attr in args_names]
+        # args[-1] = "corr_" + args[-1]
+        kwargs_names = ["f_type", "jac", "expr", "input_names", "dim", "output_names"]
+        kwargs = {attr: getattr(orig_func, attr) for attr in kwargs_names}
+
+        super().__init__(*args, **kwargs)
+        # Reference to the database used to protect the calls to the original
+        # functions and to store the reference data.
+        self._corr_database = corr_database
+        self._corr_model = corr_model
+        self._orig_func = self._process_orig_func(orig_func)
+        self._build_func_pointers()
+
+    def get_orig_func(self) -> MDOFunction:
+        """Get the original function.
+
+        Returns a pointer to the protected version of the original function (protected
+        by the database).
+
+        Returns:
+            The original function (callback).
+        """
+        return self._orig_func
+
+    def get_orig_database(self) -> Database:
+        """Return the database used to protect the data.
+
+        Returns:
+            The database.
+        """
+        return self._corr_database
+
+    def _process_orig_func(self, orig_func: MDOFunction) -> MDOFunction:
+        """Process orig_func to make sure that its call if protected by a database.
+
+        Args:
+            orig_func: The function to wrap.
+
+        Returns:
+            The protected version of orig_func.
+        """
+        # Make sure it is protected by the database
+        fname = orig_func.name
+
+        def wrapped_orig_func(x_vect: NDArray) -> float:
+            """Wrapped original function.
+
+            Makes sure each call is stored in the provided database.
+
+            Args:
+                x_vect: The design variable.
+
+            Returns:
+                The evaluation of the function at x_vect.
+            """
+            value = None
+            if self._corr_database.get(x_vect, False):
+                # x_vect is part of the database
+                value = self._corr_database.get_function_value(fname, x_vect)
+
+            if value is None:
+                # Not evaluated yet, evaluate
+                value = orig_func.func(x_vect)
+                values_dict = {fname: value}
+                # Store the new value
+                self._corr_database.store(x_vect, values_dict)
+            return value
+
+        db_func = MDOFunction(
+            wrapped_orig_func,
+            name=fname,
+            f_type=orig_func.f_type,
+            expr=orig_func.expr,
+            input_names=orig_func.input_names,
+            dim=orig_func.dim,
+            output_names=orig_func.output_names,
+        )
+
+        if orig_func.has_jac:
+
+            def dwrapped_orig_func(x_vect: Any) -> NDArray:
+                """Wrapped original jacobian.
+
+                Makes sure each call is stored in the provided database.
+
+                Args:
+                    x_vect: The design variable.
+
+                Returns:
+                    The evaluation of the jacobian at x_vect.
+                """
+                jac = None
+                if self._corr_database.get(x_vect, False):
+                    # x_vect is part of the database
+                    jac = self._corr_database.get_function_value(
+                        Database.GRAD_TAG + fname, x_vect
+                    )
+
+                if jac is None:
+                    # not evaluated yet, evaluate
+                    jac = orig_func.jac(x_vect).real
+                    values_dict = {Database.GRAD_TAG + fname: jac}
+                    # Store the new value
+                    self._corr_database.store(x_vect, values_dict)
+                return jac
+
+            db_func.jac = dwrapped_orig_func
+
+        # Return only the reference of the db_func
+        return db_func
+
+    def _build_func_pointers(self):
+        """Set the corrected function. To be overloaded by subclasses."""
+        raise NotImplementedError
+
+    def _compute_correction(
+        self,
+        x_ref: NDArray,
+        val_ref: NDArray,
+        grad_ref: NDArray = None,
+        hess_ref: NDArray = None,
+    ):
+        """Compute correction.
+
+        Actual method to compute the correction from the reference data.
+        To be overloaded by subclasses.
+
+        Args:
+            x_ref: The variables.
+            val_ref: The value to match at x_ref.
+            grad_ref: The gradient to match at x_ref.
+            hess_ref: The hessian to match at x_ref.
+
+        Returns:
+            value correction, gradient correction, hessian correction.
+        """
+        raise NotImplementedError
+
+    def set_reference(
+        self,
+        x_ref: NDArray,
+        val_ref: Any,
+        grad_ref: Any = None,
+        hess_ref: Any = None,
+        max_norm_thr: float | None = None,
+    ) -> None:
+        """Set reference.
+
+        Sets the reference so that the corrected function matches the reference data.
+        Previous correction data with the same order of consistency, whose norm with
+        x_ref is within max_norm_thr, is also used if the correction model handles it.
+
+        Args:
+            x_ref: The design variables.
+            val_ref: The value to match at x_ref.
+            grad_ref: The gradient to match at x_ref.
+            hess_ref: The hessian to match at x_ref.
+            max_norm_thr: The threshold to discard points too far from x_ref.
+        """
+        # Always recompute the correction with the specified reference value even
+        # if already stored in the database
+        val_corr, grad_corr, hess_corr = self._compute_correction(
+            x_ref, val_ref, grad_ref=grad_ref, hess_ref=hess_ref
+        )
+
+        # Store the reference data
+        # Storing the reference rather than the correction data allow
+        # not to be correction-dependent for external uses
+        self.store_reference_data(x_ref, val_ref, grad_ref=grad_ref, hess_ref=hess_ref)
+
+        x_update = [x_ref]
+        val_update = [val_corr]
+        grad_update = None
+        hess_update = None
+
+        if grad_ref is not None:
+            grad_update = [grad_corr]
+        if hess_ref is not None:
+            hess_update = [hess_corr]
+
+        # Only perform the search if required
+        if self._corr_model.HANDLES_MULTI_UPDATE:
+            # tols will be applied, so that the previous point will not
+            # appear in the additional data
+            x_list, val_list, grad_list, hess_list = self.get_reference_data(
+                x_ref,
+                use_grad=grad_ref is not None,
+                use_hess=hess_ref is not None,
+                max_norm_thr=max_norm_thr,
+                min_norm_thr=1e-4,
+            )
+            if x_list is not None:
+                # Some points were found, add them to the update lists
+                for i, x_r in enumerate(x_list):
+                    # Normally everything has already been evaluated
+                    # Recompute the correction which should not be too costly
+                    v_r = val_list[i]
+                    g_r = grad_list[i] if grad_list is not None else None
+                    h_r = hess_list[i] if hess_list is not None else None
+                    v_c, g_c, h_c = self._compute_correction(
+                        x_r, v_r, grad_ref=g_r, hess_ref=h_r
+                    )
+                    x_update.append(x_r)
+                    val_update.append(v_c)
+                    if g_c is not None:
+                        grad_update.append(g_c)
+                    if h_c is not None:
+                        hess_update.append(h_c)
+
+        # Update the model
+        self._corr_model.update(
+            x_update, val_update, grads=grad_update, hess=hess_update
+        )
+
+    def store_reference_data(
+        self, x_ref: NDArray, val_ref: Any, grad_ref: Any = None, hess_ref: Any = None
+    ) -> None:
+        """Store reference data in the database.
+
+        Args:
+            x_ref: The design variables.
+            val_ref: The reference value.
+            grad_ref: The reference gradient.
+            hess_ref: The reference hessian.
+        """
+        ref_name = self.REF_TAG + self._orig_func.name
+        data_dict = {ref_name: val_ref}
+        if grad_ref is not None:
+            data_dict[Database.GRAD_TAG + ref_name] = grad_ref
+        if hess_ref is not None:
+            data_dict[Database.GRAD_TAG + Database.GRAD_TAG + ref_name] = hess_ref
+        self._corr_database.store(x_ref, data_dict)
+
+    def get_reference_data(
+        self,
+        x_ref: NDArray,
+        use_grad: bool = True,
+        use_hess: bool = False,
+        max_norm_thr: float | None = None,
+        min_norm_thr: float = 1e-4,
+    ) -> tuple[list[ndarray], list[Any], list[Any], list[Any]]:
+        """Get reference data.
+
+        Gets reference data from the database, close enough to x_ref and which matches
+        the required consistency. Points too close to x_ref are discarded.
+
+        Args:
+            x_ref: The input (1D array).
+            use_grad: The flag to look for data with grad corrections.
+            use_hess: The flag to look for data with hess corrections.
+            max_norm_thr: The threshold to discard points too far from x_ref.
+            min_norm_thr: The threshold to discard points too close from x_ref.
+
+        Returns:
+            x_list, val_list, grad_list, hess_list.
+        """
+        if use_hess and not use_grad:
+            msg = "Must allow use_grad if use_hess is activated"
+            raise ValueError(msg)
+        # Only data with the highest specified consistency will be kept
+        lookup_method = self._corr_database.get_function_history
+        if use_grad:
+            lookup_method = self._corr_database.get_gradient_history
+        if use_hess:
+            lookup_method = self._corr_database.get_hessian_history
+
+        ref_name = self.REF_TAG + self._orig_func.name
+
+        _, x_ref_hist = lookup_method(ref_name, with_x_vect=True)
+
+        if len(x_ref_hist) == 0:
+            # No valid data available
+            return [None] * 4
+
+        # Reverse the list to get the last points first
+        x_ref_hist = flip(x_ref_hist, 0)  # reverse()
+        x_ref_hist = self._filter_x_hist(
+            x_ref_hist, x_ref, max_norm_thr=max_norm_thr, min_norm_thr=min_norm_thr
+        )
+
+        if len(x_ref_hist) == 0:
+            # No valid filtered data available, return
+            return [None] * 4
+
+        # Assemble data
+        get_data = self._corr_database.get_function_value
+
+        val_hist = [get_data(ref_name, x) for x in x_ref_hist]
+        grad_hist = None
+        hess_hist = None
+
+        if use_grad:
+            grad_tag = Database.GRAD_TAG + ref_name
+            grad_hist = [get_data(grad_tag, x) for x in x_ref_hist]
+        if use_hess:
+            hess_tag = Database.HESS_TAG + ref_name
+            hess_hist = [get_data(hess_tag, x) for x in x_ref_hist]
+
+        return x_ref_hist, val_hist, grad_hist, hess_hist
+
+    @staticmethod
+    def _filter_x_hist(
+        x_hist: NDArray,
+        x_ref: NDArray,
+        max_norm_thr: float | None = None,
+        min_norm_thr: float = 1e-4,
+    ) -> NDArray:
+        """Filter x_hist.
+
+        Filters x_hist using a proximity criterion with x_ref and max_norm as threshold.
+
+        Args:
+            x_hist: The list of points to filter.
+            x_ref: The reference point.
+            max_norm_thr: The threshold to discard points too far away.
+            min_norm_thr: The threshold to discard points too close.
+
+        Returns:
+            The filtered points.
+        """
+        if min_norm_thr <= 0.0:
+            msg = "tol must be > 0."
+            raise ValueError(msg)
+        x_hist = array(x_hist)
+        if max_norm_thr is not None:
+            # Apply the proximity criterion
+            x_hist = x_hist[where(norm(x_hist - x_ref, axis=1) <= max_norm_thr)]
+
+        # Delete points too close from x_ref
+        inds_delete = where(norm(x_hist - x_ref, axis=1) < min_norm_thr)[0]
+
+        if len(inds_delete) != 0:
+            x_hist = delete(x_hist, inds_delete, axis=0)
+        return x_hist

gemseo_multi_fidelity/core/criticality.py

@@ -0,0 +1,124 @@
+# 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
+"""Criticality criteria for bound-constrained problem."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from numpy import abs as np_abs
+from numpy import inf
+from numpy import min as np_min
+from numpy import vstack
+from numpy import where
+from numpy import zeros_like
+from numpy.linalg import norm
+
+if TYPE_CHECKING:
+    from numpy.typing import NDArray
+
+    from gemseo_multi_fidelity.core.boxed_domain import BoxedDomain
+
+
+def crit_out_1(
+    x_vect: NDArray,
+    grad: NDArray,
+    domain: BoxedDomain,
+    grad_tol: float,
+    bound_tol: float,
+) -> float:
+    """See Mouffe's thesis.
+
+    Args:
+        x_vect: The point.
+        grad: The gradient at point.
+        domain: The BoxedDomain.
+        grad_tol: The gradient tolerance.
+        bound_tol: The tolerance on bounds.
+
+    Returns:
+        The criticality.
+    """
+    return norm(compute_crit_vect(x_vect, grad, domain, grad_tol, bound_tol), ord=1)
+
+
+def crit_in_inf(
+    x_vect: NDArray,
+    grad: NDArray,
+    domain: BoxedDomain,
+    grad_tol: float,
+    bound_tol: float,
+) -> float:
+    """See Mouffe's thesis.
+
+    Args:
+        x_vect: The point.
+        grad: The gradient at point.
+        domain: The BoxedDomain.
+        grad_tol: The gradient tolerance.
+        bound_tol: The tolerance on bounds.
+
+    Returns:
+        The criticality.
+    """
+    return norm(compute_crit_vect(x_vect, grad, domain, grad_tol, bound_tol), ord=inf)
+
+
+def compute_crit_vect(
+    x_vect: NDArray,
+    grad: NDArray,
+    domain: BoxedDomain,
+    grad_tol: float,
+    bound_tol: float,
+) -> NDArray:
+    """Compute the criticality vect at x_vect with respect to the specified domain.
+
+    Args:
+        x_vect: The point to test.
+        grad: The gradient at x_vect.
+        domain: The BoxedDomain.
+        grad_tol: The gradient tolerance.
+        bound_tol: The tolerance on bounds.
+
+    Returns:
+        The criticality vect
+    """
+    crit_ratio = grad_tol / bound_tol
+
+    # Compute bounds proximity
+    dist_upper = domain.get_dist_upper(x_vect)
+    dist_lower = domain.get_dist_lower(x_vect)
+
+    crit = zeros_like(x_vect)
+    # Positive grad
+    pos_grad = where(grad > 0.0)[0]
+    # Check if lower bounds are active
+    crit[pos_grad] = np_min(
+        np_abs(vstack((grad[pos_grad], crit_ratio * dist_lower[pos_grad]))), axis=0
+    )
+    # Negative grad
+    neg_grad = where(grad < 0.0)[0]
+    # Check if upper bounds are active
+    crit[neg_grad] = np_min(
+        np_abs(vstack((grad[neg_grad], crit_ratio * dist_upper[neg_grad]))), axis=0
+    )
+    return crit