Source code for gemseo.post.core.robustness_quantifier

# 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.
# Contributors:
#    INITIAL AUTHORS - initial API and implementation and/or initial
#                        documentation
#        :author: Francois Gallard
#    OTHER AUTHORS   - MACROSCOPIC CHANGES
"""Quantification of robustness of the optimum to variables perturbations."""
from __future__ import annotations

import numpy as np
from numpy.random import multivariate_normal

from gemseo.post.core.hessians import BFGSApprox
from gemseo.post.core.hessians import LSTSQApprox
from gemseo.post.core.hessians import SR1Approx


[docs]class RobustnessQuantifier: """classdocs.""" AVAILABLE_APPROXIMATIONS = ["BFGS", "SR1", "LEAST_SQUARES"] def __init__(self, history, approximation_method="SR1"): """ Args: history: An approximation history. approximation_method: The name of an approximation method for the Hessian. """ self.history = history if approximation_method not in self.AVAILABLE_APPROXIMATIONS: raise ValueError( f"Unknown hessian approximation method {approximation_method}; " f"the available ones are: {self.AVAILABLE_APPROXIMATIONS}." ) if approximation_method == "SR1": approx_class = SR1Approx elif approximation_method == "BFGS": approx_class = BFGSApprox elif approximation_method == "LEAST_SQUARES": approx_class = LSTSQApprox self.approximator = approx_class(history) self.b_mat = None self.x_ref = None self.f_ref = None self.fgrad_ref = None
[docs] def compute_approximation( self, funcname, first_iter=0, last_iter=0, b0_mat=None, at_most_niter=-1, func_index=None, ): """Build the BFGS approximation for the Hessian. Args: funcname: The name of the function. first_iter: The index of the first iteration. last_iter: The index of the last iteration. b0_mat: The Hessian matrix at the first iteration. at_most_niter: The maximum number of iterations to take func_index: The component of the function. Returns: An approximation of the Hessian matrix. """ self.b_mat, _, x_ref, grad_ref = self.approximator.build_approximation( funcname=funcname, first_iter=first_iter, last_iter=last_iter, b_mat0=b0_mat, at_most_niter=at_most_niter, return_x_grad=True, func_index=func_index, ) self.x_ref = x_ref self.f_ref = self.approximator.f_ref self.fgrad_ref = grad_ref return self.b_mat
[docs] def compute_expected_value(self, expect, cov): r"""Compute the expected value of the output. Equal to :math:`0.5\mathbb{E}[e^TBe]` where :math:`e` is the expected values and :math:`B` the covariance matrix. Args: expect: The expected value of the inputs. cov: The covariance matrix of the inputs. Returns: The expected value of the output. Raises: ValueError: When expectation and covariance matrices have inconsistent shapes or when the Hessian approximation is missing. """ n_vars = len(expect) if cov.shape != (n_vars, n_vars): raise ValueError("Inconsistent expect and covariance matrices shapes") if self.b_mat is None: raise ValueError( "Build Hessian approximation before computing expected_value_offset" ) b_approx = 0.5 * self.b_mat exp_val = np.trace(np.dot(b_approx, cov)) exp_val += np.linalg.multi_dot( ((expect - self.x_ref).T, b_approx, (expect - self.x_ref)) ) return exp_val
[docs] def compute_variance(self, expect, cov): r"""Compute the variance of the output. Equal to :math:`0.5\mathbb{E}[e^TBe]` where :math:`e` is the expected values and :math:`B` the covariance matrix. Args: expect: The expected value of the inputs. cov: The covariance matrix of the inputs. Returns: The variance of the output. Raises: ValueError: When expectation and covariance matrices have inconsistent shapes or when the Hessian approximation is missing. """ if self.b_mat is None: raise ValueError("Build Hessian approximation before computing variance") n_vars = len(expect) if cov.shape != (n_vars, n_vars): raise ValueError("Inconsistent expect and covariance matrices shapes") b_approx = 0.5 * self.b_mat mu_cent = expect - self.x_ref v_mat = np.linalg.multi_dot((b_approx, cov, b_approx, cov)) v_mat += 4 * np.linalg.multi_dot((mu_cent.T, b_approx, cov, b_approx, mu_cent)) return 2 * np.trace(v_mat)
[docs] def compute_function_approximation(self, x_vars): """Compute a second order approximation of the function. Args: x_vars: The point on which the approximation is evaluated. Returns: A second order approximation of the function. """ if self.b_mat is None or self.x_ref is None: raise ValueError( "Build Hessian approximation before computing function approximation" ) x_l = x_vars - self.x_ref return ( 0.5 * np.linalg.multi_dot((x_l.T, self.b_mat, x_l)) + np.dot(self.fgrad_ref.T, x_l) + self.f_ref )
[docs] def compute_gradient_approximation(self, x_vars): """Computes a first order approximation of the gradient based on the hessian. Args: x_vars: The point on which the approximation is evaluated. """ if self.b_mat is None or self.fgrad_ref is None: raise ValueError( "Build Hessian approximation before computing function approximation" ) x_l = x_vars - self.x_ref return np.dot(self.b_mat, x_l) + self.fgrad_ref
[docs] def montecarlo_average_var(self, mean, cov, n_samples=100000, func=None): """Computes the variance and expected value using Monte Carlo approach. Args: mean: The mean value. cov: The covariance matrix. n_samples: The number of samples for the distribution. func: If ``None``, the ``compute_function_approximation`` function, otherwise a user function. """ n_dv = len(mean) if not cov.shape == (n_dv, n_dv): raise ValueError( "Covariance matrix dimension " + "incompatible with mean dimensions" ) ran = multivariate_normal(mean=mean, cov=cov, size=n_samples).T vals = np.zeros(n_samples) if func is None: func = self.compute_function_approximation for i in range(n_samples): vals[i] = func(ran[:, i]) average = np.average(vals) var = np.var(vals) return average, var