Estimating Failure Probability with Neural Operator Hybrid Approach

Abstract

Evaluating failure probability for complex engineering systems is a computationally intensive task. While the Monte Carlo method is easy to implement, it converges slowly and, hence, requires numerous repeated simulations of a complex system to generate sufficient samples. To improve the efficiency, methods based on surrogate models are proposed to approximate the limit state function. In this work, we reframe the approximation of the limit state function as an operator learning problem and utilize the DeepONet framework with a hybrid approach to estimate the failure probability. The numerical results show that our proposed method outperforms the prior neural hybrid method.

1. Introduction

In practice, evaluating failure probability for systems that inherently contain uncertainty is a fundamental problem encountered in various fields, such as structural safety, risk management, reliability-based optimization, etc. Uncertainties in such systems are abstracted in terms of the failure mode, and failure probability estimation is essentially a problem of evaluating multivariate integrals in domains defined by certain failure modes. While the mathematical formulation of the problem is well defined, evaluating such integrals remains a challenging task in practice.

The most straightforward approach to evaluating the failure probability is to use the Monte Carlo sampling (MCS) method [1,2]. However, due to its slow convergence, MCS requires numerous samples, resulting in a heavy computational burden. This computational burden becomes even more pronounced when complex stochastic PDEs represent the failure modes, since MCS necessitates repeatedly solving the model to estimate the failure probability.

To address this issue, various approaches have been developed, including the first-order reliability method (FORM) [3], second-order reliability method (SORM) [4], and response surface method (RSM) [5,6]. These methods replace the limit state function with a surrogate model that is easy to evaluate, thereby greatly reducing the simulation time. Following this idea, a hybrid method was proposed by [7,8] to estimate the probability based on the surrogate model while re-evaluating samples in a given suspicious region. The design of the hybrid method significantly reduces the time complexity while ensuring accuracy.

There are various methodologies for constructing surrogate models, such as the stochastic Galerkin method [9,10], the reduced basis method [11,12], and deep learning. Deep learning has rapidly developed in recent decades, particularly in scientific and engineering applications. Physics-informed neural networks (PINNs), which build upon the widely known universal approximation capabilities of continuous functions for neural networks (NNs) [13,14], were introduced in [15] and have demonstrated their efficiency in numerous studies [16,17,18]. By utilizing established deep learning and machine learning techniques, NN models can be employed as surrogate models to approximate the limit state function, outperforming traditional surrogate models in certain problems, such as those of high-dimensional systems [19,20,21].

As a significant area within the domain of deep learning, operator learning has emerged in recent years. The underlying principle of operator learning resides in the observation that nonlinear operators can be effectively approximated by employing single-layer neural networks [22,23] (Theorem 1). Operator learning aims to map infinite-dimensional functions to infinite-dimensional functions. Since it is more expressive and can break the curse of dimensionality in input space [24], operator learning has gained much attention in recent years [24,25,26]. Among the operator learning techniques, the DeepONet introduced in [24,26] has been demonstrated to be effective in numerous applications, including [27,28,29].

In this work, we present a novel approach to failure probability estimation by reframing the approximation problem of the limit state function as an operator learning problem and subsequently adapting the DeepONet framework to address it. The operator learning formulation provides a more effective and generalized approach to constructing a surrogate model for the limit state function, resulting in enhanced precision and reduced simulation numbers. To further ensure the precision, we employed a hybrid method [7] for estimating the failure probability. Our proposed neural operator hybrid (NOH) approach significantly reduces the time complexity while maintaining high accuracy compared to earlier neural hybrid and Monte Carlo simulation approaches. We posit that the efficiency of our approach in estimating failure probability demonstrates the potential of operator learning in various tasks.

This paper is structured as follows: In Section 2, we present the problem setting and introduce a hybrid method for evaluating the failure probability. The neural operator learning and proposed algorithm are then fully described in Section 3. To demonstrate the effectiveness of our approach, we describe numerical experiments in Section 4 that cover a variety of scenarios, including ODEs, PDEs, and multivariate models. Finally, we offer concluding remarks and observations in Section 5.

2. Preliminaries

This section will provide an overview of the mathematical framework for failure probability and introduce a hybrid method for solving this problem.

2.1. Problem Setting

Let $Z=\left(Z_1,Z_2,\dots ,Z_{n_z}\right)$ be an $n_z$-dimensional random vector with the distribution function $F_Z\left(z\right)=Prob(Z\le z)$. The image of Z, i.e., the set of all possible values that Z can take, is denoted by $\mathrm{\Omega }$. It is our interest to evaluate the failure probability $P_f$ defined by Equation (1):

$$P_f=Prob\left(Z\in {\mathrm{\Omega }}_f\right)={\int }_{{\mathrm{\Omega }}_f}\mathrm{d}{F}_Z\left(z\right)=\int {\chi }_{{\mathrm{\Omega }}_f}\left(z\right)\mathrm{d}{F}_Z\left(z\right)=\mathbb{E}\left[{\chi }_{{\mathrm{\Omega }}_f}\left(z\right)\right],$$

(1)

where the characteristic function ${\chi }_{{\mathrm{\Omega }}_f}\left(z\right)$ is defined as:

$${\chi }_{{\mathrm{\Omega }}_f}\left(z\right)=\left\{\begin{array}{ccc}\hfill 1\hfill & \hfill \mathrm{if}\hfill & \hfill z\in {\mathrm{\Omega }}_f,\hfill \\ \hfill 0\hfill & \hfill \mathrm{if}\hfill & \hfill z\notin {\mathrm{\Omega }}_f,\hfill \end{array}\right.$$

(2)

and the failure domain ${\mathrm{\Omega }}_f$, where failure occurs, is defined as:

$${\mathrm{\Omega }}_f=\{Z:g\left(Z\right)<0\}.$$

(3)

Here, $g\left(Z\right)$ is a scalar limit state function—also known as a performance function—that characterizes the failure domain. It should be emphasized that, in many real-world systems, $g\left(Z\right)$ does not have an analytical expression and is instead characterized by a complex system that requires expensive simulations to evaluate. Consequently, the evaluation of $g\left(Z\right)$ can be computationally expensive, leading to significant time complexity.

2.2. Hybrid Method

The most straightforward approach to estimating failure probability is the Monte Carlo sampling (MCS) method [1,2], which is given by:

$$P_f^{mc}=\frac{1}{M}\sum _{i=1}^M{\chi }_{\left\{g\right(z)<0\}}\left(z^{\left(i\right)}\right),$$

(4)

where ${\left\{z^{\left(i\right)}\right\}}_{i=1}^M$ is a set of sample points for the random vector Z. The characteristic function ${\chi }_{\left\{g\left(z\right)<0\right\}}\left(z^{\left(i\right)}\right)$ takes a value of 1 if the limit state function $g\left(Z\right)$ evaluated at $z^{\left(i\right)}$ is less than zero and 0 otherwise. The failure probability $P_f^{mc}$ is estimated as the average of the characteristic function over the M sample points.

However, evaluating the limit state function $g\left(Z\right)$ at numerous sample points can be a computationally intensive task, especially when dealing with complex stochastic systems, resulting in significant simulation time complexity. To address this issue, a surrogate model can be used to approximate the limit state function $g\left(Z\right)$ and avoid the need for direct evaluation at each sample point. Specifically, a surrogate model of $g\left(Z\right)$ is denoted by $\widehat{g}\left(Z\right)$, which can be rapidly evaluated. The failure probability can then be estimated as:

$${\widehat{P}}_f^{mc}=\frac{1}{M}\sum _{i=1}^M{\chi }_{\{\widehat{g}\left(z\right)<0\}}\left(z^{\left(i\right)}\right).$$

(5)

While surrogate models can significantly reduce computational costs in Monte Carlo methods, relying solely on them for estimating the failure probability may result in poor precision or even failure. To address this issue, a hybrid approach that combines the surrogate models $\widehat{g}$ and the limit state function g was proposed in [7,8]. In the following, we give a brief review of the hybrid method.

Suppose that $(-\gamma ,\gamma )$ is a suspicious region, where $\gamma$ is a non-negative real number. In this case, we can approximate the failure domain ${\mathrm{\Omega }}_f$ with ${\tilde{\mathrm{\Omega }}}_f$ as follows:

$${\tilde{\mathrm{\Omega }}}_f=\left\{\widehat{g}\left(Z\right)<-\gamma \right\}\cup \left\{\left\{\left|\widehat{g}\left(Z\right)\right|\le \gamma \right\}\cap \{g\left(Z\right)<0\}\right\},$$

(6)

where g is the limit state function, and $\widehat{g}$ represents the surrogate model of g. Enhanced with the hybrid method, the failure probability can be estimable by MCS:

$$\begin{array}{cc}\hfill P_f^h& \hfill =\frac{1}{M}\sum _{i=1}^M{\chi }_{{\widehat{\mathrm{\Omega }}}_f}\left(z^{\left(i\right)}\right)\hfill \\ \hfill & \hfill =\frac{1}{M}\sum _{i=1}^M\left[{\chi }_{\{\widehat{g}<-\gamma \}}\left(z^{\left(i\right)}\right)+{\chi }_{\left\{\right|\widehat{g}|\le \gamma \}}\left(z^{\left(i\right)}\right)·{\chi }_{\{g<0\}}\left(z^{\left(i\right)}\right)\right].\hfill \end{array}$$

(7)

The hybrid method can be considered as an approach for estimating $P_f$ by using a surrogate $\widehat{g}$, followed by a re-evaluation of the samples within the suspicious domain. While increasing the value of $\gamma$ leads to higher time complexity, it also results in more accurate estimation. In Ref. [7], it was proved that for any surrogate $\widehat{g}\left(Z\right)$ and for all $ϵ>0$, there exists a critical value ${\gamma }_N>0$ such that for all $\gamma >{\gamma }_N$, the difference between the estimated $P_f^h$ and the truth $P_f$ is less than $ϵ$, i.e.,

$$\left|P_f-P_f^h\right|<ϵ.$$

(8)

To be more precise,

$${\gamma }_N=\frac{1}{{ϵ}^{1/p}}{∥g\left(Z\right)-\widehat{g}\left(Z\right)∥}_{L_{\mathrm{\Omega }}^p},$$

(9)

where the approximation is measured in the $L^p$-norm with $p\ge 1$.

$${∥g\left(Z\right)-\widehat{g}\left(Z\right)∥}_{L_{\mathrm{\Omega }}^p}={\left({\int }_{\mathrm{\Omega }}{\left|g\left(z\right)-\widehat{g}\left(z\right)\right|}^p\mathrm{d}{F}_Z\left(z\right)\right)}^{1/p}.$$

(10)

Selecting an appropriate value of $\gamma$ that balances accuracy and computational efficiency can be a challenging task. To address this challenge, an iterative algorithm, as demonstrated in Algorithm 1, is commonly employed in practice instead of directly selecting $\gamma$. In Algorithm 1, the surrogate $\widehat{g}$ samples are gradually replaced with g samples in the iteration procedure until either the stopping criterion is reached or the iteration step reaches $\lceil M/\delta M\rceil$, which is equivalent to expanding the suspicious region at each iteration. When k reaches $\lceil M/\delta M\rceil$, the iterative hybrid algorithm degenerates to the Monte Carlo method (4), indicating that the convergence is achieved as $P_f^{\left(k\right)}\to P_f^{mc},k\to \lceil M/\delta M\rceil$. It is obvious that the time complexity of the iterative hybrid algorithm is heavily influenced by the accuracy of the surrogate model used in Algorithm 1.

Algorithm 1 Iterative Hybrid Method [7].

Input:  surrogate model $\widehat{g}$, $S={\left\{z^{\left(i\right)}\right\}}_{i=1}^M$ samples from random variable Z, tolerance $ϵ$, and sample size in each iteration $\delta M$. 1: Initialization: $k=0$. 2: Compute $P_f^{\left(0\right)}=\frac{1}{M}{\sum }_{i=1}^M{\chi }_{\{\widehat{g}\left(z\right)<0\}}\left(z^{\left(i\right)}\right)$. 3: Sort ${\left\{\left|\widehat{g}\left(z^{\left(i\right)}\right)\right|\right\}}_{i=1}^M$ in ascending order; sort the correspond sample S accordingly. 4: for k from 1 to $\lceil M/\delta M\rceil$ do 5:     $\delta S^k={\left\{z^{\left(j\right)}\right\}}_{j=(k-1)\delta M+1}^{k\delta M}$. 6:     $\delta P=\frac{1}{M}{\sum }_{z^{\left(j\right)}\in \delta S^k}\left[-{\chi }_{\{\widehat{g}<0\}}\left(z^{\left(j\right)}\right)+{\chi }_{\{g<0\}}\left(z^{\left(j\right)}\right)\right]$. 7:     $P_f^{\left(k\right)}=P_f^{(k-1)}+\delta P$. 8:     if $\left|\delta P\right|\le ϵ$ for several times then 9:         break 10:    end if 11: end for Output:  $P_f^{\left(k\right)}$

3. Neural Operator Hybrid Algorithm

In Section 2, we described the failure probability problem and the hybrid algorithm for solving it. As we have mentioned, the accuracy of the surrogate model greatly affects the performance of the iterative hybrid algorithm. In this section, we introduce neural operator learning and present the neural operator hybrid (NOH) algorithm, which reframes the approximation problem of the limit state function as an operator learning problem. Unlike prior studies that used neural networks as surrogate models for mappings (as in [19,20,21,30,31]), our algorithm constructs a surrogate model by using operator learning techniques. The benefits of our method are mainly in two aspects: First, it increases the generalization of the surrogate model. Second, it increases the precision of the surrogate model with more information involved, which results in a more effective and generalized approach to estimating failure probability.

3.1. Neural Operator Learning

Neural operator learning aims to accurately represent linear and nonlinear operators that map input functions into output functions. More specifically, let U be a vector space of functions on set $K_1$, and let V be a vector space of functions on set $K_2$; G is an operator map from U to V, i.e.,

$$G:u\mapsto G\left(u\right)\in V,\mathrm{for}u\in U,$$

(11)

where u is a function defined on the domain $K_1$, i.e.,

$$u:x\mapsto u\left(x\right)\in \mathbb{R},\mathrm{for}x\in K_1,$$

(12)

and $G\left(u\right)$ is a function defined on the domain $K_2$, i.e.,

$$G\left(u\right):y\mapsto G\left(u\right)\left(y\right)\in \mathbb{R},\mathrm{for}y\in K_2.$$

(13)

In the context of this paper, U is referred to as the input function space, and V is referred to as the output function space. It is of interest to design neural networks that can approximate the mapping of the operator G from the input function space to the output function space.

In this work, we employ the DeepONet framework [26], an ascendingoperator learning approach based on the following theorem, to construct the surrogate of the operator G.

Theorem 1

(Universal Approximation Theorem for the Operator [23]). Suppose that σ is a continuous non-polynomial function, X is a Banach Space, $K_1\subset X,K_2\subset {\mathbb{R}}^d$ are two compact sets in X and ${\mathbb{R}}^d$, respectively, U is a compact set in $C\left(K_1\right)$, and G is a nonlinear continuous operator that maps U into $C\left(K_2\right)$. Then, for any $ϵ>0$, there are positive integers $n,p,m$ and constants $c_i^k,{\xi }_{ij}^k,{\theta }_i^k,{\zeta }_k\in \mathbb{R},w_k\in {\mathbb{R}}^d,x_j\in K_1$, $i=1,\dots ,n,k=1,\dots ,p,j=1,\dots ,m$, such that

$$|G\left(u\right)\left(y\right)-\sum _{k=1}^p\underset{\mathrm{branch}}{\underbrace{\sum _{i=1}^n{c}_i^k\sigma \left(\sum _{j=1}^m{\xi }_{ij}^{k}u\left(x_j\right)+{\theta }_i^k\right)}}\underset{\mathrm{trunk}}{\underbrace{\sigma \left(w_k·y+{\zeta }_k\right)}}|<ϵ.$$

(14)

holds for all $u\in U$ and $y\in K_2$.

In DeepONet, the operator G is approximated by taking the inner product of two components, which can be expressed as follows:

$$G\left(u\right)\left(y\right)\approx \mathcal{G}\left(u\right)\left(y\right):=\sum _{k=1}^p\underset{\mathrm{branch}}{\underbrace{b_k\left(u\right)}}\underset{\mathrm{trunk}}{\underbrace{t_k\left(y\right)}},$$

(15)

where $b_k\left(u\right)$ is the output of the trunk network for a given input function u in U, and $t_k\left(y\right)$ is the output of the branch network for a given y in $K_2$. Figure 1 illustrates this architecture.

In practical applications, the input function u is vectorized as ${\left[u\left(x_1\right),\dots ,u\left(x_m\right)\right]}^T$, where the sample points ${[x_1,x_2\dots x_m]}^T$ are referred to as sensors. The input of the trunk network takes P specific values $y_1^{\left(i\right)},\dots ,y_P^{\left(i\right)}$ in $K_2$ for each $G\left(u^{\left(i\right)}\right)$. The neural network can be trained by using the training data:

$$\mathcal{T}=\left\{\left(u^{\left(1\right)},G\left(u^{\left(1\right)}\right)\right),\left(u^{\left(2\right)},G\left(u^{\left(2\right)}\right)\right),\cdots ,\left(u^{\left(N\right)},G\left(u^{\left(N\right)}\right)\right)\right\},$$

(16)

and by minimizing the following loss function:

$$\mathcal{L}\left(\mathrm{\Theta }\right)=\frac{1}{NP}\sum _{l=1}^P\sum _{i=1}^N{\parallel G_{\mathrm{\Theta }}\left(u^{\left(i\right)}\right)\left(y_l^{\left(i\right)}\right)-G\left(u^{\left(i\right)}\right)\left(y_l^{\left(i\right)}\right)\parallel }_2,$$

(17)

where the neural network $G_{\mathrm{\Theta }}$ with parameter $\mathrm{\Theta }$ approximates the operator G.

3.2. Neural Operator Hybrid Algorithm

Neural operator learning involves functions as both inputs and outputs, requiring us to reframe our problem accordingly. Let U be the collection of all functions defined on $[0,1]$ such that

$$u\left(x\right)=\overline{Z}-k\overline{\sigma }+2k\overline{\sigma }x,\mathrm{for}x\in [0,1],$$

(18)

where k is a selective parameter, and $\overline{Z}$ and $\overline{\sigma }$ are defined as:

$$\overline{Z}=\frac{Z_1+\dots +Z_{n_z}}{n_z},\overline{\sigma }=\frac{{\sigma }_1+\dots +{\sigma }_{n_z}}{n_z}.$$

(19)

Here, ${\sigma }_1,\dots ,{\sigma }_{n_z}$ are the variances of random variables $Z_1,\dots ,Z_{n_z}$, respectively. We can then define an operator G fromm U to V as follows:

$$G:u\mapsto G\left(u\right)\in V,\mathrm{for}u\in U,$$

(20)

where $V=\mathrm{span}\left\{g\right(x\left)\right\}$, and $G\left(u\right)$ is defined by

$$G\left(u\right):y\mapsto g\left(y\right)\in \mathbb{R},\mathrm{for}y\in {\mathbb{R}}^{n_z}.$$

(21)

Here, g is the limit state function discussed in Section 2.1. Then, designing a surrogate model for G is a standard operator learning problem.

The inspiration for this reframing is the establishment of a relationship between the input function $u\left(x\right)$ and the random variable Z. It is important to note that the prior distribution of $u\left(x\right)$ is entirely known, which enables us to generate training data by using the following process: Firstly, we randomly sample $z^{\left(i\right)}$ according to the random distribution Z, where $i=1,\dots ,N$. Next, we define $u^{\left(i\right)}\left(x\right)$ by using the following equation:

$$u^{\left(i\right)}\left(x\right)={\overline{z}}^{\left(i\right)}-k\overline{\sigma }+2k\overline{\sigma }x,x\in [0,1],$$

(22)

where

$${\overline{z}}^{\left(i\right)}=\frac{z_1^{\left(i\right)}+\dots +z_{n_z}^{\left(i\right)}}{n_z}.$$

(23)

In practical implementation, we vectorize the input function $u^{\left(i\right)}\left(x\right)$ on a uniform grid of the interval $[0,1]$. Specifically, the vectorized input function is given by $[u^{\left(i\right)}\left(x_1\right),\dots ,u^{\left(i\right)}\left(x_m\right)]$, where $x_j$ denotes the j-th sensor and is defined by

$$x_j=\frac{j-1}{m-1},j=1,\dots ,m.$$

(24)

Suppose that there are P observations $y_l^{\left(i\right)}\in {\mathbb{R}}^{n_z}$, $l=1,\dots ,P$ for $G\left(u^{\left(i\right)}\right)$; then, by Equation (21), we have $G\left(u^{\left(i\right)}\right)\left(y_l^{\left(i\right)}\right)=g\left(y_l^{\left(i\right)}\right)$. Once the dataset is generated, the model is trained by minimizing the following loss function:

$$\mathcal{L}\left(\mathrm{\Theta }\right)=\frac{1}{NP}\sum _{l=1}^P\sum _{i=1}^N{\parallel G_{\mathrm{\Theta }}\left(u^{\left(i\right)}\right)\left(y_l^{\left(i\right)}\right)-g\left(y_l^{\left(i\right)}\right)\parallel }_2,$$

(25)

where $G_{\mathrm{\Theta }}$ is a neural network with parameters $\mathrm{\Theta }$ that approximates the operator G.

After constructing the surrogate for G by using the neural network $G_{\mathrm{\Theta }}$, we can integrate it into a hybrid algorithm to estimate the failure probability. This whole process is called the neural operator hybrid (NOH) method, and it is shown in Figure 2.

As discussed in Section 2.2, the convergence of Algorithm 1 depends on the norm measurement of the difference between the surrogate and the limit state function. Therefore, it is crucial to have an accurate approximation $\widehat{g}\left(Z\right)$ for reliable estimation. The surrogate model constructed for the reformulated operator learning problem using DeepONet may achieve higher accuracy than that of the surrogate model constructed by using neural networks that do not incorporate information from random variables, as the former model utilizes additional information from random distribution functions. Moreover, DeepONet exhibits less generalization error than that of simple neural networks [26].

4. Numerical Experiments

In this section, we present three numerical examples to demonstrate the efficiency and effectiveness of the proposed neural operator hybrid (NOH) method. Furthermore, we compare the NOH method with the neural hybrid (NH) method. For the purpose of clarity in presentation, we refer to the surrogate model constructed by using fully connected neural networks for g in the NH method as the neural surrogate and the surrogate constructed by using DeepONet for g in the NOH method as the neural operator surrogate. Both surrogate models are designed to approximate limit state function g, and their main difference is the structure of neural networks utilized.

For the NOH method, we use the simplest unstacked DeepONet to construct the neural operator surrogate for the operator G, with the branch and trunk networks implemented as fully connected neural networks (FNNs). The trunk network is employed with a depth of 2 and a width of 40 FNNs, while the branch network has a depth of 2 and a width of 40 FNNs. To facilitate a comparative analysis with the NH method, we built a neural surrogate for g by using a simple FNN with a parameter size comparable to that of the NOH method. Specifically, in the NH method, the FNN utilized for the neural surrogate has a depth of 3, and its width is adjusted to achieve a similar number of parameters to that in the DeepONet. Both models were optimized by using the Adam optimizer [32] with a learning rate of 0.001 on identical datasets.

The code was run by using PyTorch [33] and MATLAB 2019b on a workstation with an Nvidia GTX 1080Ti graphics card and an Intel Core i5-7500 processor with 16 GB of RAM. It is noteworthy that the evaluation of time complexity is based on the performance function (PF) calls $N_{call}$, which refers to the number of system simulations that need to be executed, rather than the running time of the programs, as program running speeds may vary significantly across different programming languages and platforms. The PF calls consist of the evaluation of the hybrid algorithm in line 6 of Algorithm 1 and simulations for generating training data in Equation (16). We do not evaluate the computational time required for the neural surrogate or the neural operator surrogate, as a model trained by using batch techniques can evaluate ${10}^5$ samples in less than a second.

4.1. Ordinary Differential Equation

In this test problem, we consider a random ordinary differential equation (ODE) proposed in [7]. The ODE is given by:

$$\frac{\mathrm{d}s}{\mathrm{d}t}=-Zs,s\left(0\right)=s_0,$$

(26)

where $s_0=1$, and $Z\sim \mathcal{N}\left(\mu ,{\sigma }^2\right)$ is a Gaussian random variable with a mean of $\mu =-2$ and standard deviation of $\sigma =1$. The limit state function is defined as $g\left(Z\right)=g\left(s(t,Z)\right)=s(t,Z)-s_d$, where $s_d=0.5$ and $t=1$. The exact failure probability $P_f=0.003539$ is regarded as the reference solution, which can be computed by using the analytic solution $s(t,Z)=s_0{\mathrm{e}}^{-Zt}$.

To demonstrate the efficiency and effectiveness of the proposed NOH method, we compare it with a Monte Carlo simulation (MCS) and the NH method. We used DeepONet to train the neural operator surrogate in the NOH method and set the parameter k in Equation (22) to 4, the number of input functions for training N to 500, P to 500, and the number of sensors m to 100. In the NH method, we used the FNN as the neural surrogate.

Both surrogates in the NH and NOH methods were trained with identical datasets, epochs, and optimizers. Additionally, in the MCS, ${10}^6$ samples were generated to estimate the failure probability.

Table 1. Comparison of a Monte Carlo simulation (MCS), the neural hybrid (NH) method, and the neural operator hybrid (NOH) method. In the hybrid algorithm, we set $\delta M$ to 25 and $ϵ$ to 0, and we terminated the iterative procedure when $\delta P\le ϵ$ five times. The relative error is denoted by ${ϵ}_e$.

Method	${\mathit{P}}_{\mathit{f}}^{\mathit{h}}$	${\mathit{N}}_{\mathbf{call}}$	${\mathit{ϵ}}_{\mathit{e}}$
MCS	$3.578\times {10}^{-3}$	${10}^6$	$0.11\%$
NOH	$3.578\times {10}^{-3}$	500 (Training) + 1750 (Evaluating)	0.11%
NH	-	-	-

presents the performance of the MCS, the NOH method, and the NH method. As shown in the table, the NOH method outperformed MCS by achieving the same level of estimation precision with only approximately $O(N_{call}/1000)$ or $0.23\%$ of the PF calls required by the MCS. The NH method failed to estimate the failure probability, as all of the outputs of the neural surrogate were greater than 0. In this special case, the hybrid iterative procedure always terminated too early, while the estimated failure probability remained at 0.

Figure 3 illustrates the convergence of the NOH method and the NH method. In order to compare the two methods, the iterative procedure in the hybrid algorithm was not terminated until the limit state function g was recomputed for at least ${10}^5$ samples. The figure shows that the estimate of the failure probability by the NH method remained at 0 until around 100 iterations, and it converged after approximately 7000 iterations. In contrast, the NOH method converged after only 70 iterations, demonstrating its superior efficiency compared to that of the NH method.

In Figure 4, we compare the performance of the neural surrogate and the neural operator surrogate in predicting the limit state function g. We observed that all of the outputs of the neural surrogate were greater than 0, which led to the failure of the NH method in estimating the failure probability. It is evident that the neural operator surrogate outperformed the neural surrogate in predicting the limit state function g.

4.2. Multivariate Benchmark

Next, we consider a high-dimensional multivariate benchmark problem (dimensionality: $n=50$) in the field of structural safety in [19,34]:

$$g\left(Z\right)=\beta n^{\frac{1}{2}}-\sum _{i=1}^n{Z}_i,$$

(27)

where $\beta =3.5$ and each random variable $Z_i\sim \mathcal{N}(0,1),i=1,\cdots ,n$. $g\left(Z\right)$ is the limit state function. In this test problem, the reference failure probability is $P_f^{mc}=2.218\times {10}^{-4}$, which was obtained by using MCS with $5\times {10}^6$ samples.

The proposed NOH method is compared with the NH method in terms of accuracy and efficiency. For the NOH method, we set the parameter k in Equation (22) to 4, the number of input functions N to 1000, P to 1000, and the number of sensors m to 100. In comparison, a naive neural surrogate employing an FNN with a similar number of parameters was also constructed and trained under conditions identical to those for the NH method.

The performance of the MCS, the NOH method, and the NH method are illustrated in

Table 2. A performance evaluation was conducted to compare the MCS, the NH, and the NOH approaches. The NOH method was found to outperform the other methods, and it only evaluated $3\%$ of $N_{call}$ compared to NH method. The NOH method also achieved the best relative error of $0.81\%$ while requiring the lowest number of samples with respect to the other methods.

Method	${\mathit{P}}_{\mathit{f}}^{\mathit{h}}$	${\mathit{N}}_{\mathbf{call}}$	${\mathit{ϵ}}_{\mathit{e}}$
MCS	$2.22\times {10}^{-4}$	$5\times {10}^6$	-
NOH	$2.20\times {10}^{-4}$	1000 (Training) + 150 (Evaluating)	0.81%
NH	$2.02\times {10}^{-4}$	1000 (Training) + 4175 (Evaluating)	8.92 %

. Both the NOH method and the NH method demonstrated a substantial reduction in the number of samples required—approximately $0.1\%$ of the computational cost of MCS. Notably, the NOH method outperformed the NH method by evaluating only $3\%$ of the $N_{call}$ while achieving a superior relative error $0.81\%$ compared to the NH method’s relative error of $8.92\%$. This indicated that the NOH method achieved higher accuracy with significantly fewer samples, making it a more efficient and effective approach for the given task.

In Figure 5, the convergence of the NOH method is depicted and compared with that of the NH method. Figure 5a demonstrates that the NOH method achieved an estimation of $P_f^h=2.2\times {10}^{-4}$ with a relative error of ${ϵ}_e=0.81\%$ in less than six iterations. Figure 5b provides a comparison of convergent behaviors between the NH and NOH methods, clearly demonstrating that the NOH method converged in significantly fewer iterations. As a consequence, the NOH method required only $3\%$ of the total evaluations $N_{call}$. These findings strongly suggest that neural operator surrogates offer improved precision and ease of training when compared to FNNs. The reduced iteration times and lower number of evaluations highlight the superior efficiency and accuracy of neural operator surrogates in approximating complex functions or operators.

Figure 6 depicts the superior accuracy of the neural operator surrogates. It compares the neural surrogate and the neural operator surrogate approximations from 50 randomly selected samples. As illustrated in the figure, the predictions of the limit function g by the neural operator surrogate are more accurate than those of the neural surrogate, as the former closely approximated the ground truth.

The experimental results provide evidence of the precision exhibited by the neural operator surrogate. The combination of reduced iteration times and a lower number of evaluations further accentuates the efficiency and accuracy of neural operator surrogates in approximating complex functions or operators. These findings emphasize that the NOH method achieved higher levels of accuracy while utilizing significantly fewer samples.

4.3. Helmholtz Equation

We consider the Helmholtz equation on a disk with a square hole [19]. The equation is given by:

$$-\Delta u-{\kappa }^{2}u=0,$$

(28)

where coefficient $\kappa$ is a Gaussian random variable with a mean of $\mu =60$ and variance of $\sigma =1$, i.e, $\kappa \sim \mathcal{N}\left(60,1\right)$. The system was set with a homogeneous term, and Dirichlet boundary conditions ($u=0$) were applied on the edges of the square hole, while generalized Neumann conditions ($\overrightarrow{\xi }·\nabla r-i\kappa r=0$, and $\overrightarrow{\xi }$ is the radial distance from the object) were applied on the edge of the disk. The system was numerically solved by using the MATLAB PDE solver to obtain an accurate solution. A snapshot of the solution of Helmholtz is shown in Figure 7. A point sensor was placed at $x_p=[0.7264;0.4912]$, and the failure probability was defined as $Prob(u(x_p,\kappa )>1.00)$. The reference solution was $P_f^{mc}=2.70\times {10}^{-4}$, which was obtained with a Monte Carlo simulation with ${10}^5$ samples.

With a setup similar to that in the previous experiment, we used DeepONet to train the neural operator surrogate in the NOH method and set the parameter k in Equation (22) to 4, the number of input functions N to 1000, P to 1000, and the number of sensors m to 100. We used a fully connected neural network (FNN) as the neural surrogate in the NH method and trained both models under identical conditions.

In

Table 3. A performance evaluation was conducted to compare the NH and the NOH approaches. The NOH method was found to outperform the NH method in both efficiency and accuracy. Specifically, the NOH method achieved a relative error of just $3.70\%$ while requiring fewer $N_{call}$ than the NH method did.

Method	${\mathit{P}}_{\mathit{f}}^{\mathit{h}}$	${\mathit{N}}_{\mathbf{call}}$	${\mathit{ϵ}}_{\mathit{e}}$
MCS	$2.70\times {10}^{-4}$	${10}^5$	-
NOH	$2.80\times {10}^{-4}$	1000 (Training) + 100 (Evaluating)	3.70%
NH	$3.00\times {10}^{-4}$	1000 (Training) + 875 (Evaluating)	11.11%

, we present a performance analysis of the Monte Carlo simulation (MCS), the NOH method, and the NH method. Similarly to the previous experiments, the results indicate that the NOH method required fewer $N_{call}$—about $11\%$—than the NH method did while providing a more accurate estimation with $3.70\%$ relative error versus $11.11\%$.

The convergence of the NOH method is illustrated and compared with that of the NH method in Figure 8. Although both methods converged quickly, NOH converged in noticably fewer iterations compared to the NH method. With only 100 evaluations, the NOH method could accurately estimate the failure probability as $P_f^h=2.80\times {10}^{-4}$, with a relative error of $3.70\%$, while the NH method only achieved $11.11\%$ while utilizing 875 evaluations. The faster convergence and lower relative error observed in the NOH method signify the precision and capabilities of the neural operator surrogate when compared to the neural surrogate.

These results highlight the potential of neural operator surrogates to significantly enhance computational efficiency and accuracy in a variety of applications. Consequently, the NOH method emerges as a more efficient and effective approach for estimating failure probability.

5. Conclusions

This paper introduced a neural operator hybrid method for the estimation of failure probability. Instead of approximating the limit state function directly, we reframe the problem as an operator learning task. This allows us to construct a highly efficient and precise surrogate operator model that can accurately estimate the limit state function. By integrating the surrogate operator model into the hybrid algorithm, we created the neural operator hybrid method. The numerical results demonstrate that the proposed method provides an efficient strategy for estimating failure probability, particularly in systems governed by ODEs, multivariate functions, and the Helmholtz equation. Our proposed method exhibited superior performance to that of the basic MCS approach, particularly in terms of efficiency. Furthermore, it surpassed the previous neural hybrid method in both efficiency and accuracy. Consequently, it is applicable and beneficial for addressing general failure probability estimation problems. The obtained results not only demonstrate the efficacy of neural operator learning frameworks in the context of failure probability estimation, but also imply their promising potential in other areas, such as Bayesian inverse problems and partial differential equations with random inputs. In our future work, techniques such as importance sampling (IS) [8,35] or adaptive learning [20,36] can further reduce the sample size required in the estimation process.