Inverse FORM

In FORM [15], the performance function is linearized according to

\[G(\textbf{U}) \approx G(\textbf{U}^\star) + \nabla G(\textbf{U}^\star)(\textbf{U}-\textbf{U}^\star)^\intercal\]

where \(\textbf{U}^\star\) is the expansion point, \(G(\textbf{U})\) is the performance function evaluated in the standard normal space and \(\nabla G(\textbf{U}^\star)\) is the gradient of \(G(\textbf{U})\) evaluated at \(\textbf{U}^\star\). The probability failure is approximated as

\[p_{fail} = \Phi(-\beta_{HL})\]

where \(\Phi(\cdot)\) is the standard normal cumulative distribution function and \(\beta_{HL}=||\textbf{U}^*||\) is the norm of the design point known as the Hasofer-Lind reliability index.

The goal of the inverse FORM algorithm is to find a design point \(\textbf{U}^\star\) that minimizes the performance function \(G(\textbf{U})\) and lies on the hypersphere defined by \(||\textbf{U}^*|| = \beta_{HL}\), or equivalently \(||\textbf{U}^*|| = -\Phi^{-1}(p_{fail})\). The default convergence criteria used for this algorithm are:

\[\text{tolerance}_{\textbf{U}}:\ ||\textbf{U}_i - \textbf{U}_{i-1}||_2 \leq 10^{-3}\]
\[\text{tolerance}_{\nabla G(\textbf{U})}:\ ||\nabla G(\textbf{U}_i)- \nabla G(\textbf{U}_{i-1})||_2 \leq 10^{-3}\]

Problem Statement

Compute \(u^* = \text{argmin}\ G(\textbf{U})\) such that \(||\textbf{U}||=\beta\).

The feasibility criteria \(||\textbf{U}||=\beta\) may be equivalently defined as \(\beta = -\Phi^{-1}(p_{fail})\), where \(\Phi^{-1}(\cdot)\) is the inverse standard normal CDF.

Algorithm

This method implements a gradient descent algorithm to solve the optimization problem within the tolerances specified by tolerance_u and tolerance_gradient.

  1. Define \(u_0\) and \(\beta\) directly or \(\beta=-\Phi^{-1}(p_\text{fail})\)

  2. Set \(u=u_0\) and \(\text{converged}=False\)

  3. While not \(\text{converged}\):

    1. \(\alpha = \frac{\nabla G(u)}{|| \nabla G(u) ||}\)

    2. \(u_{new} = - \alpha \beta\)

    3. If \(||u_{new} - u || \leq \text{tolerance}_u\) and/or \(|| \nabla G(u_{new}) - \nabla G(u) || \leq \text{tolerance}_{\nabla G(u)}\);

      set \(\text{converged}=True\)

      else;

      \(u = u_{new}\)

The InverseFORM class is imported using the following command:

>>> from UQpy.reliability.taylor_series import InverseFORM

Methods

class InverseFORM(distributions, runmodel_object, p_fail=0.05, beta=None, seed_x=None, seed_u=None, df_step=0.01, corr_x=None, corr_z=None, max_iterations=100, tolerance_u=0.001, tolerance_gradient=0.001)[source]

Class to perform the Inverse First Order Reliability Method.

Each time run() is called the results are appended to the class attributes. By default, tolerance_u and tolerance_gradient must be satisfied for convergence. Specifying a tolerance as None will ignore that criteria, but both cannot be None. This is a child class of the TaylorSeries class.

Parameters:

  • distributions (Union[None, Distribution, list[Distribution]]) – Marginal probability distributions of each random variable. Must be of type DistributionContinuous1D or JointIndependent.

  • runmodel_object (RunModel) – The computational model. Must be of type RunModel.

  • p_fail (Optional[float]) – Probability of failure defining the feasibility criteria as \(||u||=-\Phi^{-1}(p_{fail})\). Default: \(0.05\). Set to None to use beta as the feasibility criteria. Only one of p_fail or beta may be provided.

  • beta (Optional[float]) – Hasofer-Lind reliability index defining the feasibility criteria as \(||u|| = \beta\). Default: None. Only one of p_fail or beta may be provided.

  • seed_x (Union[ndarray, list, None]) – Point in the parameter space \(\mathbf{X}\) to start from. Only one of seed_x or seed_u may be provided. If either seed_u or seed_x is provided, then the run() method will be executed automatically.

  • seed_u (Union[ndarray, list, None]) – Point in the uncorrelated standard normal space \(\mathbf{U}\) to start from. Only one of seed_x or seed_u may be provided. If either seed_u or seed_x is provided, then the run() method will be executed automatically.

  • df_step (Union[int, float]) – Finite difference step in standard normal space. Default: \(0.01\)

  • corr_x (Union[ndarray, list, None]) – Correlation matrix \(\mathbf{C_X}\) of the random vector \(\mathbf{X}\)

  • corr_z (Union[ndarray, list, None]) – Correlation matrix \(\mathbf{C_Z}\) of the random vector \(\mathbf{Z}\) Default: corr_z is the identity matrix.

  • max_iterations (int) – Maximum number of iterations for the HLRF algorithm. Default: \(100\)

  • tolerance_u (Union[float, int, None]) – Convergence threshold for criterion \(||\mathbf{U}_i - \mathbf{U}_{i-1}||_2 \leq\) tolerance_u of the HLRF algorithm. Default: \(1.0e-3\)

  • tolerance_gradient (Union[float, int, None]) – Convergence threshold for criterion \(||\nabla G(\mathbf{U}_i)- \nabla G(\mathbf{U}_{i-1})||_2 \leq\) tolerance_gradient of the HLRF algorithm. Default: \(1.0e-3\)

run(seed_x=None, seed_u=None)[source]

Runs the inverse FORM algorithm.

Parameters:

  • seed_x (Union[ndarray, list, None]) – Point in the parameter space \(\mathbf{X}\) to start from. Only one of seed_x or seed_u may be provided. If neither is provided, the zero vector in \(\mathbf{U}\) space is the seed.

  • seed_u (Union[ndarray, list, None]) – Point in the uncorrelated standard normal space \(\mathbf{U}\) to start from. Only one of seed_x or seed_u may be provided. If neither is provided, the zero vector in \(\mathbf{U}\) space is the seed.

Attributes

InverseFORM.alpha: float

Normalized gradient vector in \(\textbf{U}\) space

InverseFORM.alpha_record: list

Record of \(\alpha=\frac{\nabla G(u)}{||\nabla G(u)||}\)

InverseFORM.beta
InverseFORM.beta_record: list

Record of Hasofer-Lind reliability index that defines the feasibility criteria \(||\textbf{U}||=\beta_{HL}\)

InverseFORM.design_point_u: list

Design point in the standard normal space \(\textbf{U}\)

InverseFORM.design_point_x: list

Design point in the parameter space \(\textbf{X}\)

InverseFORM.error_record: list

Record of the final error defined by \(error_u = ||u_{new} - u||\) and \(error_{\nabla G(u)} = || \nabla G(u_{new}) - \nabla G(u)||\)

InverseFORM.iteration_record: list

Record of the number of iterations before algorithm termination

InverseFORM.failure_probability_record: list

Record of the probability of failure defined by \(p_{fail} = \Phi(-\beta_{HL})\)

Examples