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

gemseo_multi_fidelity/models/rbf/rbf_model.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) 2018 AIRBUS OPERATIONS
+
+#
+# Contributors:
+#    INITIAL AUTHORS - API and implementation and/or documentation
+#      :author: Romain Olivanti
+#    OTHER AUTHORS   - MACROSCOPIC CHANGES
+"""RBF Model."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+from typing import Any
+
+from numpy import asarray
+from numpy import atleast_1d
+from numpy import atleast_2d
+from numpy import concatenate
+from numpy import einsum
+from numpy import empty
+from numpy import inner
+from numpy import split
+from numpy import zeros
+from scipy.linalg import pinvh
+from scipy.linalg import solve
+
+from gemseo_multi_fidelity.models.rbf.kernel_factory import KernelFactory
+
+if TYPE_CHECKING:
+    from numpy.typing import NDArray
+
+
+class RBFModel:
+    """RBF Model with gradient support."""
+
+    def __init__(self, kernel: str = "gaussian", scaling: float = 1.0) -> None:
+        """Constructor.
+
+        Args:
+            kernel: The type of kernel to use.
+            scaling: The scaling for the kernel.
+        """
+        self._kernel_factory = KernelFactory()
+        self._kernel = None
+        self._centers = None
+        self._weights = None
+        self._grad_weights = None
+
+        self._use_mem_eff_train = False
+        self._use_mem_eff_eval = False
+        self._mem_eff_check_overridden = False
+
+        self.set_kernel(kernel)
+        self.set_scaling(scaling)
+
+    def set_kernel(self, kernel):
+        """Set the type of RBF kernel used.
+
+        Args:
+            kernel: The type of RBF kernel.
+        """
+        self._kernel = self._kernel_factory.create(kernel)
+
+    def set_scaling(self, scaling) -> None:
+        """Set the scaling parameter of the RBF kernel.
+
+        Args:
+            scaling: The scaling.
+        """
+        self._kernel.set_scaling(scaling)
+
+    def override_eff_check(
+        self, mem_eff_train: bool = True, mem_eff_eval: bool = False
+    ) -> None:
+        """Override check for memory efficient routines.
+
+        Overrides the check used to choose whether to use 'memory efficient' routines
+        for training and evaluating. Trade-off between speed and memory usage.
+
+        Args:
+            mem_eff_train: ``True`` to use memory efficient routines for training.
+            mem_eff_eval: ``True`` to use memory efficient routines for evaluating.
+        """
+        self._use_mem_eff_train = bool(mem_eff_train)
+        self._use_mem_eff_eval = bool(mem_eff_eval)
+        self._mem_eff_check_overridden = True
+
+    def train(self, centers: NDArray, values: NDArray, gradients: NDArray = None):
+        """Train the model using the specified inputs, outputs.
+
+        Gradient outputs are optional. Fewer gradient outputs than standard outputs can
+        be provided.
+        They will be associated with the first centers provided.
+
+        Args:
+            centers: The training inputs.
+            values: The training outputs.
+            gradients: The training gradient outputs.
+        """
+        self._centers = atleast_2d(centers).copy()
+        values = atleast_1d(values)
+        dim = self.get_dim()
+        n_centers = self.get_n_centers()
+        is_gradient_enhanced = gradients is not None
+
+        if len(values) != n_centers:
+            msg = "One value must be provided for each center"
+            raise ValueError(msg)
+        if is_gradient_enhanced:
+            gradients = atleast_2d(gradients)
+            if gradients.shape[1] != dim:
+                msg = (
+                    "Gradients dim inconsistent with centers: "
+                    f"{gradients.shape[1]:d} != {dim:d}"
+                )
+                raise ValueError(msg)
+            if gradients.shape[0] > n_centers:
+                msg = "Cannot provide more gradients than centers"
+                raise ValueError(msg)
+
+        if not self._mem_eff_check_overridden:
+            # TODO
+            # Choose whether to use memory efficient routines
+            self._use_mem_eff_eval = False
+            self._use_mem_eff_train = True
+
+        if is_gradient_enhanced and self._use_mem_eff_train:
+            train_method = self._compute_weights_mem_eff
+        else:
+            train_method = self._compute_weights_dir
+        self._weights, self._grad_weights = train_method(values, gradients)
+
+    def get_n_centers(self) -> int:
+        """Return the number of centers used for the model.
+
+        Returns:
+            The number of centers.
+        """
+        return self._centers.shape[0] if self._centers is not None else 0
+
+    def get_dim(self) -> int:
+        """Return the dimension of the input space.
+
+        Returns:
+            The dimension of the input space.
+        """
+        return self._centers.shape[1] if self._centers is not None else None
+
+    def _asbl_sqr_fun(self) -> NDArray:
+        """Assemble the squared matrix (fun-fun) of the RBF system.
+
+        Returns:
+            The 2x2 matrix.
+        """
+        # Initialize the RBF matrix
+        mat = empty((self.get_n_centers(),) * 2)
+
+        for i, center in enumerate(self._centers):
+            mat[i, :] = self._kernel(center - self._centers)
+        return mat
+
+    def _asbl_rect_grad(self, n_grads: int) -> NDArray:
+        """Assemble the rectangular matrix (grad-fun) of the RBF system.
+
+        Args:
+            n_grads: The number of centers linked to a gradient output.
+
+        Returns:
+            The 2x2 matrix.
+        """
+        mat = empty((n_grads * self.get_dim(), self.get_n_centers()))
+        grad_centers = self._centers[0:n_grads]
+
+        for i, center in enumerate(self._centers):
+            mat[:, i] = self._kernel.grad(grad_centers - center).flatten()
+        return mat
+
+    def _asbl_sqr_grad(self, n_grads: int) -> NDArray:
+        """Assemble the squared matrix (grad-grad) of the RBF system.
+
+        Args:
+            n_grads: The number of centers linked to a gradient output.
+
+        Returns:
+            The 2x2 matrix.
+        """
+        dim = self.get_dim()
+        mat_size = n_grads * dim
+        mat = zeros((mat_size,) * 2)
+        grad_centers = self._centers[0:n_grads]
+
+        for i, center in enumerate(grad_centers):
+            start_i = i * dim
+            end_i = start_i + dim
+            mat[start_i:end_i, :] = (
+                self._kernel
+                .hess(center - grad_centers)
+                .swapaxes(0, 1)
+                .reshape((dim, mat_size))
+            )
+        return mat
+
+    def _asbl_rbf_mat(self, n_grads: int) -> NDArray:
+        """Convenience method to directly solve the RBF system.
+
+        Assembles the full RBF matrix.
+
+        Args:
+            n_grads: The number of centers linked to a gradient output.
+
+        Returns:
+            The 2x2 matrix.
+        """
+        n_centers = self.get_n_centers()
+        dim = self.get_dim()
+        mat_size = n_centers + dim * n_grads
+
+        # Initialize the RBF matrix
+        mat = empty((mat_size,) * 2)
+        mat[0:n_centers, 0:n_centers] = self._asbl_sqr_fun()
+        if n_grads > 0:
+            mat[n_centers::, 0:n_centers] = self._asbl_rect_grad(n_grads)
+            mat[0:n_centers, n_centers::] = -mat[n_centers::, 0:n_centers].T
+            mat[n_centers::, n_centers::] = self._asbl_sqr_grad(n_grads)
+        return mat
+
+    def _compute_weights_dir(
+        self, values: NDArray, gradients: NDArray
+    ) -> tuple[NDArray, NDArray | None]:
+        """Compute the RBF weights by directly solving the RBF system.
+
+        Args:
+            values: The outputs to match (1D ndarray).
+            gradients: The gradient outputs to match (2D ndarray).
+
+        Returns:
+            The list (weights, grad_weights).
+        """
+        # Symmetric, positive definite only if not gradient enhanced
+        is_grad_enhanced = gradients is not None
+        if is_grad_enhanced:
+            inputs = concatenate([values, gradients.flatten()])
+            n_grads = gradients.shape[0]
+        else:
+            inputs = values
+            n_grads = 0
+
+        res = solve(
+            self._asbl_rbf_mat(n_grads),
+            inputs,
+            assume_a="gen" if is_grad_enhanced else "pos",
+            overwrite_a=True,
+            overwrite_b=is_grad_enhanced,
+            check_finite=False,
+        )
+
+        if is_grad_enhanced:
+            # Split the weights
+            weights, grad_weights = split(res, [self.get_n_centers()])
+            grad_weights = grad_weights.reshape((n_grads, self.get_dim()))
+        else:
+            weights = res
+            grad_weights = None
+        return weights, grad_weights
+
+    def _compute_weights_mem_eff(self, values, gradients) -> tuple[Any, Any]:
+        """Compute the RBF weights by benefiting from the structure of the problem.
+
+        Expected to be more memory efficient when the dimension is high and when several
+        gradients are provided.
+
+        Args:
+            values: The outputs to match (1D ndarray).
+            gradients: The gradient outputs to match (2D ndarray).
+
+        Returns:
+            The list (weights, grad_weights).
+        """
+        # Could be optimized further by using sparse representations
+        n_grads = gradients.shape[0]
+        # Compute the inverse of sqr_fun using the pinvh routine
+        # This will use the fact that sqr_fun i symmetric positive definite
+        inv_fun = pinvh(
+            self._asbl_sqr_fun(), lower=True, return_rank=False, check_finite=False
+        )
+        # Compute first temp term of fun_weights
+        fun_weights = inv_fun.dot(values)
+        # Assemble the rectangular gradient matrix
+        rect_grad = self._asbl_rect_grad(n_grads)
+        tmp_mixed_inputs = gradients.flatten() - rect_grad.dot(fun_weights)
+        prod_inv_grad = inv_fun.dot(-rect_grad.T)
+        del inv_fun
+        tmp_sqr = self._asbl_sqr_grad(n_grads) - rect_grad.dot(prod_inv_grad)
+        del rect_grad
+        # Symmetrical -> lower = True
+
+        grad_weights = solve(
+            tmp_sqr,
+            tmp_mixed_inputs,
+            lower=True,
+            overwrite_a=True,
+            overwrite_b=True,
+            check_finite=False,
+        )
+        del tmp_sqr
+        del tmp_mixed_inputs
+        fun_weights -= prod_inv_grad.dot(grad_weights)
+        return fun_weights, grad_weights.reshape((n_grads, self.get_dim()))
+
+    def __call__(self, x_vect: NDArray) -> float:
+        """Evaluate the model at x_vect.
+
+        Args:
+            x_vect: The point at which the model is evaluated (1d ndarray).
+
+        Returns:
+            The prediction.
+        """
+        diff = asarray(x_vect) - self._centers
+        if self._use_mem_eff_eval:
+            call_method = self._compute_val_mem_eff
+        else:
+            call_method = self._compute_val_vect
+        return call_method(diff)
+
+    def _compute_val_vect(self, diff: NDArray) -> Any:
+        """Compute the prediction of the model at x_vect. (Vectorized version).
+
+        Args:
+            diff: The kernel inputs (x_vect - centers) (2D ndarray).
+
+        Returns:
+            The prediction.
+        """
+        ret = inner(self._weights, self._kernel(diff))
+        if self._grad_weights is not None:
+            ret += einsum("ij,ij", self._grad_weights, self._kernel.grad(diff))
+        return ret
+
+    def _compute_val_mem_eff(self, diff: NDArray) -> float:
+        """Compute the prediction of the model at x_vect. (Less overhead expected).
+
+        Args:
+            diff: The kernel inputs (x_vect - centers) (2d ndarray).
+
+        Returns:
+            The prediction.
+        """
+        ret = 0.0
+        for weight, diff_i in zip(self._weights, diff, strict=False):
+            ret += weight * self._kernel(diff_i)
+        if self._grad_weights is not None:
+            for weight, diff_i in zip(
+                self._grad_weights, diff[0 : len(self._grad_weights)], strict=False
+            ):
+                ret += inner(weight, self._kernel.grad(diff_i))
+        return ret
+
+    def grad(self, x_vect: NDArray):
+        """Evaluate the gradient of the model at x_vect.
+
+        Args:
+            x_vect: The point at which the gradient of the model is evaluated
+                (1D ndarray).
+
+        Returns:
+            The prediction of the gradient.
+        """
+        diff = asarray(x_vect) - self._centers
+        if self._use_mem_eff_eval:
+            grad_method = self._compute_grad_mem_eff
+        else:
+            grad_method = self._compute_grad_vect
+        return grad_method(diff)
+
+    def _compute_grad_vect(self, diff: NDArray) -> Any:
+        """Compute the gradient of the model (Vectorized version).
+
+        Args:
+            diff: The kernel inputs (x_vect - centers) (2D ndarray).
+
+        Returns:
+            The prediction of the gradient.
+        """
+        ret = einsum("i,ij->j", self._weights, self._kernel.grad(diff))
+        if self._grad_weights is not None:
+            ret += einsum("ijk,ik->j", self._kernel.hess(diff), self._grad_weights)
+        return ret
+
+    def _compute_grad_mem_eff(self, diff) -> NDArray:
+        """Compute the gradient of the model (Less overhead expected).
+
+        Args:
+            diff: The kernel inputs (x_vect - centers) (2D ndarray).
+
+        Returns:
+            The prediction of the gradient.
+        """
+        ret = zeros(self.get_dim())
+        for weight, diff_i in zip(self._weights, diff, strict=False):
+            ret += weight * self._kernel.grad(diff_i)
+        if self._grad_weights is not None:
+            for weight, diff_i in zip(
+                self._grad_weights, diff[0 : len(self._grad_weights)], strict=False
+            ):
+                ret += self._kernel.hess(diff_i).dot(weight)
+        return ret

gemseo_multi_fidelity/models/sparse_rbf_updater.py

@@ -0,0 +1,96 @@
+# 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
+"""Sparse RBF updater."""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING
+
+from gemseo.core.mdo_functions.mdo_function import MDOFunction
+
+from gemseo_multi_fidelity.models.model_updater import ModelUpdater
+from gemseo_multi_fidelity.models.rbf.rbf_model import RBFModel
+
+if TYPE_CHECKING:
+    from numpy.typing import NDArray
+
+LOGGER = logging.getLogger(__name__)
+
+
+class SparseRBFUpdater(ModelUpdater):
+    """Updater for the Sparse RBF model."""
+
+    HANDLES_MULTI_UPDATE = True
+
+    N_FUNC_MAX = "rbf_max_val"
+    N_GRAD_MAX = "rbf_max_grad"
+    KERNEL = "rbf_kernel"
+    SCALING = "rbf_scaling"
+
+    def __init__(self, **kwargs) -> None:
+        """Constructor.
+
+        Args:
+            kwargs: The keywords arguments.
+        """
+        n_func_max = int(kwargs.get(self.N_FUNC_MAX, 20))
+        n_grad_max = int(kwargs.get(self.N_GRAD_MAX, 20))
+        kernel = kwargs.get(self.KERNEL, "matern_5_2")
+        scaling = kwargs.get(self.SCALING, 1.0)
+
+        if n_func_max < 1:
+            msg = f"{self.N_FUNC_MAX} must be > 0"
+            raise ValueError(msg)
+        if n_grad_max < 1:
+            msg = f"{self.N_GRAD_MAX} must be > 0"
+            raise ValueError(msg)
+
+        self._n_func_max = n_func_max
+        self._n_grad_max = n_grad_max
+
+        self._model = RBFModel(kernel=kernel, scaling=scaling)
+        super().__init__()
+
+    def _set_function(self) -> None:
+        self.function = MDOFunction(
+            self._model, "RBF", jac=self._model.grad, input_names=["x"], dim=1
+        )
+
+    def _update(
+        self, vects: NDArray, vals: NDArray, grads: NDArray = None, hess: NDArray = None
+    ) -> None:
+        n_func_points = min(len(vects), self._n_func_max)
+        msg = f"Sparse RBF model relying on {n_func_points:d} value(s)"
+        if grads is not None:
+            n_grad_points = min(n_func_points, self._n_grad_max)
+            gradients = grads[0:n_grad_points]
+            msg += f" and {n_grad_points:d} gradient(s)"
+        else:
+            gradients = None
+        LOGGER.info(msg)
+
+        # TODO cross validation
+        self._model.train(
+            vects[0:n_func_points], vals[0:n_func_points], gradients=gradients
+        )

gemseo_multi_fidelity/models/taylor/__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.
+
+"""Taylor model."""