Optimal Diagnosis Strategy via Functional Extremum Transformation and Fault Elimination Neural Network: A Minimum Diagnosis-Cost Approach for Complex Systems

Abstract

For complex systems with complex structures and limited fault data, expert knowledge-based methods are often preferred. The multi-signal flow graph model is a representative qualitative approach, but generating a minimum-cost diagnostic strategy under this model becomes increasingly difficult as system scale grows, leading to excessive diagnostic cost or unacceptable computation time. To address this issue, this paper reformulates the minimum-cost diagnostic strategy generation problem (MDP) as a functional extremum value problem (FEVP) through a multipartite graph model, which decomposes the recursive strategy-generation process into deterministic combination and nondeterministic elimination. This reformulation is motivated by the observation that only a small fraction of generated fault subsets contributes to the optimal strategy. Based on this insight, a fault elimination neural network with an intelligent algorithm (ENI) structure is proposed to learn an elimination function that retains promising subsets while discarding redundant ones. The neural network scores candidate fault subsets from fixed-dimensional statistical features, while the intelligent algorithm optimizes the non-differentiable objective. Simulation and real-case results show that the proposed method reduces diagnostic cost by more than 30% while maintaining acceptable computation time, with greater advantages on larger-scale systems.

1. Introduction

1.1. Motivation

Fault diagnosis typically involves three main approaches: analytical model-based [1], signal processing-based [2], and expert knowledge-based methods [3]. For complex systems, the intricate structures make it difficult to develop accurate analytical models and acquire sufficient signal data. Consequently, expert knowledge-based diagnostic methods have emerged as the preferred choice [4,5]. The Multi-Signal Flow Graph model is a representative approach in this category [6,7]. It characterizes the relationships between faults and tests (“related” or “unrelated”) as a binary matrix, and isolates faults with a test strategy (diagnostic strategy) based on the matrix. This model closely reflects the real physical structure and exhibits convenience for construction and versatility in application, making it widely used in complex systems such as aerospace, telecommunications, and weaponry [8]. To enhance diagnostic efficiency, diagnosticians must solve a minimum-cost diagnostic strategy generation problem (MDP) under this model to minimize test costs [9]. However, with the growing complexity of system functionality and structure, the number of faults to be diagnosed has grown from under 20 to over 50, and the MDP has evolved from small-scale to large-scale problems. While existing methods prove adequate for small-scale MDPs, they lack scalability and perform poorly for large-scale problems. This has resulted in persistently high diagnostic costs for current complex systems, significantly impacting system operability and reliability [10].

1.2. Previous Research

According to the direction of strategy generation [11,12,13], the research can be categorized into top-down, horizontal, and bottom-up methods.

The top-down method starts from the full set of faults and searches downward until each fault is isolated. AO* is a typical class of direct backtracking algorithms that selects the length of Huffman coding, information gain, or information entropy as the heuristic function [14,15,16]. After the current node is expanded, the search path is corrected based on the synthesis cost. This ensures that each decision step is optimal, so the result is minimal. However, too many redundant computations leads to extremely long computation time. The rollout algorithm [17,18,19] sets parameters to adjust the frequency of backtracking based on AO*. It discards some operations to decrease the time complexity, but it will have a slight deviation from the ideal solution. Moreover, backtracking still takes a long time, and parameter setting becomes very difficult when facing complex systems. In the second class, indirect backtracking is performed via metaheuristic functions, where the diagnosis strategy is optimized via an intelligent algorithm. Ref. [20] encoded branches and optimized codes via a quantum genetic algorithm (QGA) to avoid the complex generation process. Ref. [21] utilized the self-adaptive binary particle swarm optimization (SADPSO) algorithm to find the optimal solution based on the greedy algorithm. Similarly, Refs. [22,23,24] used heuristic particle swarm optimization (HPSO), genetic algorithm, and cuckoo algorithm. These algorithms are limited by the randomness of intelligent algorithms and tend to fall into local optimal solutions. Unlike the above algorithms, the greedy algorithm [25] discards backtracking and selects the test with the least expansion cost for the current node; thus, it is extremely computationally efficient and has a similar cost to the ideal solution on small- and medium-scale systems. However, its performance is limited for large-scale systems because it lacks global consideration.

The horizontal method generates branches for each fault and integrates them into a strategy. Little research has been done on this topic. Ref. [26] generated each sequence independently according to the prior probability. Some costly errors are caused by ignoring the correlation among the branches, and the error further increases when the prior probabilities of each fault are close.

The bottom-up method arranges and combines all faults into multiple subsets and builds a full set. It enumerates all situations to obtain the least costly diagnosis strategy. Ref. [27] logically denies the possibility of partial permutations and proposes a look-ahead heuristic function to optimize the bottom-up process. Ref. [28] classified and selected the subsets according to the possibility of the Support Vector Machine (SVM) reducing unnecessary operations. The cost of these algorithms is almost optimal; however, when dealing with a complex system, the complexity of the enumeration operation is exponentially increased, and the computation time is too long.

Overall, existing methods can generate good diagnosis strategies for handling small-scale systems. However, when dealing with large-scale MDP of complex systems [29,30], some existing algorithms require unacceptable computation time due to combinatorial explosion, while others are prone to local optimal solutions due to the accumulation of errors from multiple decisions, resulting in a significant cost deviation between the generated strategy and the ideal strategy, leading to a large amount of additional test costs. To further improve the capability of fault-related analysis and optimization in complex systems, some recent studies have started to introduce deep-learning-based diagnosis, advanced signal-driven diagnosis, and neural-network-based fault estimation mechanisms [31,32]. These studies suggest that learning-based structures can provide additional flexibility and adaptability for complex fault-related problems.

1.3. Scope and Organization of the Paper

To overcome the above shortcomings of existing algorithms, this paper proposes a novel method for MDP based on fault combination and optimized elimination. Firstly, a multipartite graph model is established, which equates the generation of a strategy to a recursive process of faults from subsets to the entire set. The recursive function consists of a deterministic combination and a nondeterministic elimination. Therefore, the original optimization problem is transformed into a functional extremal value problem (FEVP) for elimination, which is much easier. Then, the elimination function is hard to analyze, so a fault elimination neural network with an intelligent algorithm (ENI) structure is proposed to decompose it into three parts: scoring function, retention, and criterion, and solution methods were provided separately. Finally, the optimal elimination function obtained is used to guide the recursive process. The experiment shows that the proposed method can generate a strategy with a lower test cost within an acceptable time. The innovations of this paper are as follows:

• The proposal of a multipartite graph model transforms the MDP into a FEVP, which is much easier to solve.
• As the optimization objective of FEVP is recursive, an ENI structure is established to overcome the difficulty in analyzing the unknown function.
• The neural network and intelligent algorithm in the ENI structure can be arbitrary.
• The proposed method can generate a diagnosis strategy with a lower test cost, and this advantage becomes prominent as the system size increases.

The paper is organized as follows. Section 2 describes the MDP based on the multi-signal flow graph model, and Section 3 elaborates on the proposed method. Simulations and experiments are presented in Section 4, and Section 5 provides the conclusion.

2. Problem Description

2.1. The Multi-Signal Flow Graph Model

The composition of the multi-signal flow graph model is as follows [33,34,35]:

• A finite set of $m$ system states, $S=\{s_1,s_2,\cdots ,s_m\}$, in which $s_i$ represent the different faulty states of the system;
• The corresponding set of $m$ known probabilities, $P=\{p_1,p_2,\cdots ,p_m\}$, satisfies $0\le p_i\le 1$, where $p_i$ is the a priori probability that the system is in state $s_i$, and $\sum _{i=1}^m{p}_i=1$;
• A finite set of $n$ binary tests to choose from, $T=\{t_1,t_2,\cdots ,t_n\}$;
• The corresponding set of $n$ test costs is $C=\{c_1,c_2,\cdots ,c_n\}$, where $c_j$ is the comprehensive cost of time and economy incurred when test $t_j$ is applied;
• The dependency matrix $D=\left[d_{i,j}\right]$, where $d_{i,j}$ is 1 if test $t_j$ detects a failure state $s_i$ and 0 otherwise; to describe the distributions of 0 and 1 in $D$, $r$ is defined as

  $$r={\displaystyle \frac{1}{n}}\sum _{j=1}^n{\displaystyle \frac{\mathit{max}\left(m-\sum _{i=1}^m{d}_{ij},\sum _{i=1}^m{d}_{ij}\right)}{\mathit{min}\left(m-\sum _{i=1}^m{d}_{ij},\sum _{i=1}^m{d}_{ij}\right)}}$$

  (1)

In engineering applications, the functions of some tests are repetitive, and due to the limited types of tests that can be conducted, some fuzzy sets of faults that cannot be separated are formed. Therefore, it is necessary to reduce the dimensionality of the original D; an example is shown in Figure 1.

Figure 1. An example of dimensionality reduction.

Notably, this paper discusses the reduced $D$ and the diagnostic strategy with a 100% fault isolation rate, which satisfies

$$\{\begin{array}{c}\forall s_i,s_k\in S, \exists t_j\in T, d_{i,j}\ne d_{k,j}\\ \forall t_j,t_h\in T, \exists s_i\in S, d_{i,j}\ne d_{i,h}\end{array}$$

(2)

$D$ is obtained by sequential fault simulation. For example, $t_1$ is a voltage test performed at a certain point of the system, and the amplitude waveform of $t_1$ is ${wave}_1$ in the normal state, and the amplitude waveform of $t_1$ is ${wave}_2$ in the $s_3$ fault state in the simulation of $s_3$, if

$${\displaystyle \frac{|{wave}_1-{wave}_2|}{{wave}_1}}>emax$$

(3)

It indicates that if the occurrence of $s_3$ will affect $t_1$, then $s_3$ and $t_1$ are correlated, and $d_{31}=0$; otherwise, they are not correlated and $d_{31}=0$. $emax$ is a specified upper limit of error, usually 5%.

Fault diagnosis is realized based on fusion analysis of the difference between normal and fault states and the correlation between tests and faults. If a test set $T^{\prime }=\{t_{j_1},t_{j_2},\dots ,t_{j_l},\dots ,t_{j_L}\}$ is selected by the system for testing, and its result is $\{z_{j_1},z_{j_2},\dots ,z_{j_l},\dots ,z_{j_L}\}$, $z_{j_l}=1$ indicates that the test data of $t_{j_l}$ is different from the normal data, and $z_{j_l}=0$ otherwise. Then the state of the system can be described as a fuzzy set $S\prime$, which satisfies

$$S^{\prime }=\bigcup _{l=1}^L\left\{s_i\right|d_{i{j}_l}=z_{j_l}\}$$

(4)

For example, following the reduced $D$ of Figure 1, if $T^{\prime }=\{t_1,t_2\}$ and the test result is $\left\{\mathrm{0,1}\right\}$, then $S^{\prime }=\{s_2,s_3\}$, that is, the system either fails $s_2$ or $s_3$. The multi-signal flow graph model uses a diagnosis strategy (fault strategy) to describe the isolation of each fault and test order. As shown in Figure 2, the tester performs tests successively according to the instructions of the diagnosis strategy until the fault is located. $t_2$ is carried out first; if $z_2=0$, the fault is $s_1$, if $z_2=1$, the system status is $\{s_2,s_3\}$ and $t_3$ is performed. If $z_3=0$, the fault is $s_2$; otherwise, it is $s_3$.

Figure 2. An example of a diagnosis strategy ($B$ is defined in $\left(5\right)$).

2.2. Combinatorial Explosion of MDP

One $D$ can generate multiple diagnosis strategies, and expected cost is the key index to evaluate them:

$$cost=\sum _{i=1}^m\sum _{j=1}^n{c}_j·b_{ij}·p_i$$

(5)

where $B=\left[b_{i,j}\right]$ is a binary matrix with dimensions of $m\times n$; $b_{i,j}=1$ means that test $t_j$ is selected to identify fault state $s_i$; and otherwise, $b_{i,j}=0$. The lower the cost, the better the diagnosis strategy. Therefore, under the multi-signal flow graph model, the optimal fusion object problem can be described as an MDP:

$$\{\begin{array}{c}\min cost\\ subject to \left(4\right)\end{array}$$

(6)

According to $\left(2\right)$, a diagnosis strategy (binary strategy) must use $m-1$ tests; thus, the type of strategy $ty$ is the cumulative product of the number of choices for each test. Taking $S$ as the first layer, $s_l\left(u\right)$ represents the U-th fault subset of the L-th layer of the strategy; obviously, $u\le 2^{l-1}$. $l-1$ tests are used, and $n-(l-1)$ tests are unused from $S$ to $s_l\left(u\right)$. The probability that $s_l\left(u\right)$ cannot be separated by any unused test is $r^{\left|s_l\left(u\right)\right|}+{(1-r)}^{\left|s_l\left(u\right)\right|}$, and this value is almost 0 when $\left|s_l\left(u\right)\right|>4$. If $m=2^L$ and the diagnosis strategy is a full binary strategy, it has $L+1$ layers; then, its type ${ty}_0$ can be approximated as

$${ty}_0\approx {\left\{\left[1-r^4-{\left(1-r\right)}^4\right]·\left(n-L+2\right)\right\}}^{\frac{m}{4}}·{\left\{\left[1-r^2-{\left(1-r\right)}^2\right]·\left(n-L+1\right)\right\}}^{\frac{m}{2}}·\prod _{l=1}^{L-2}{\left(n-l+1\right)}^{2^{l-1}}$$

(7)

The combination of full binary strategies is simpler, so $ty>{ty}_0$. $r=0.5$ is taken to minimize $\left(7\right)$ for estimation: when $m=n=16$, ${ty}_0\approx 2.6\times {10}^6$; when $m$ and $n$ increase to 32 and 64, ${ty}_0$ increases to $9.3\times {10}^{39}$ and $2.6\times {10}^{101}$. As the complexity of the system continues to increase, the increase in $m$ and $n$ leads to an exponential increase in $ty$, making it extremely difficult to select the optimal one from so many types of diagnosis strategies. The deviation between the generated strategy of traditional algorithms and the ideal optimal solution will also increase, which is also called an NP-hard problem.

3. The Proposed Method

According to the analysis in the previous section, solving $\left(6\right)$ is extremely hard due to the extremely complex constraints, and the increase in $m$ and $n$ leads to an NP-hard problem. As shown in Figure 3, first, a multipart graph model is established, and the generation of the diagnosis strategy is described as a recursive process of $m-1$ calls, from faults subsets to an entire set. The recursive function consists of a deterministic combination and a nondeterministic elimination. Based on this model, $\left(6\right)$ is transformed into a FEVP for the elimination. As the elimination is only a part of the recursive function and has no constraints, the difficulty of solving this FEVP is much lower, and it is less affected by $m$ and $n$.

Figure 3. The concept diagram of the proposed method.

This FEVP is relatively simple and different from typical common extremum problems [36]. The objective function is recursive and there is no analytical requirement for the unknown function. Therefore, an ENI structure is proposed to solve the optimal elimination function, which includes three parts: a score function, retention, and criterion. The score function is used to grade each element in the set to be eliminated based on their features. Retention refers to retaining elements with higher scores based on a ratio matrix $R$. The criterion $Cr$ refers to the condition in which elimination is needed. $R$ and $Cr$ are estimated by the multipartite graph model. A neural network $ANN(w,b)$ is used to fit the score function, and the optimal $w,b$ are trained through an intelligent algorithm. Unlike in general optimization problems, the decision variables of the ENI are the parameters of the neural network and do not participate directly in the calculation of the fitness function. In addition, since $ANN\left(w,b\right)$ is used only to fit the score function and an intelligent algorithm is used only to optimize $w$ and $b$, they are not limited to a specific intelligent algorithm [37] or a neural network structure [38]. For different $D$, the generation methods of their diagnosis strategies are consistent, so a converged $ANN(w,b)$ can be trained through a sufficient $D$, and the obtained $(\alpha ,\beta )$ can be applied to another $D$.

3.1. The Multipartite Graph Model

A multipartite graph model is established and it includes $\{q_i,p\left(q_i\right),cost\left(q_i\right),Q_i(u),ID\left(q_i\right),OD\left(q_i,Q_k\left(u\right)\right)\}$ and two actions $\{\alpha ,\beta \}$.

$S_i$ represents a fault subset of $S$ with a size $i$, satisfying $S_i\in 2^s,\left|S_i\right|=i$. The reasonability criterion sequence ${tt}_i$ is a vector of $S_i$ with dimensions $1\times n$, whose j-th element satisfies

$$\{\begin{array}{c}{tt}_{i,j}=1 \forall s_h\in S_i, d_{h,j}=1\\ {tt}_{i,j}=0 \forall s_h\in S_i,d_{h,j}=0\\ {tt}_{i,j}=x other\end{array}$$

(8)

where $x$ refers to the irrelevant term. If $S_i$ satisfies $\left(9\right)$, $S_i$ can be isolated from $S$ through a finite number of tests; $S_i$ is reasonable and may become part of the optimal diagnosis strategy, denoted by $q_i$.

$$\forall s_h\in S-S_i,\exists t_j,d_{h,j}+{tt}_{i,j}=1$$

(9)

According to $\left(8\right)$, all $s_i$s are reasonable and satisfy ${tt}_{1,j}=d_{i,j}$. $p\left(q_i\right)$ refers to the sum of prior probabilities of all faults in $q_i$, namely, $p\left(q_i\right)=\sum _{s_h\in q_i}{p}_h$. $cost\left(q_i\right)$ represents the minimum cost required to isolate all elements in $q_i$, specifically, $cost\left(q_1\right)=0$ and $cost\left(q_m\right)=J$. $Q_i$ refers to the set composed of all $q_i$. Specifically, $\left|Q_1\right|=m$, $Q_m=S$ and $\left|Q_m\right|=1$. $Q_i$ is eliminated to $Q_i\left(1\right)$ after $Q_i$ is generated, $Q_i(k-i)$ is eliminated to $Q_i(k-i+1)$ after $Q_k$ is generated, and $Q_i(m-i)$ is ultimately eliminated, where $Q_i\left(u\right)$ represents the result of $Q_i$ being eliminated for the U-th time. The family of sets $X_k$ is defined as $X_k=\left\{Q_1\right(k-1),Q_2(k-2),\dots ,Q_{k-1}(1\left)\right\}$.

$\alpha$ represents a combination action, which refers to the process in which $X_k$ combines all elements in $Q_1(k-1)$ and $Q_{k-1}\left(1\right)$, $Q_2(k-2)$ and $Q_{k-2}\left(2\right)$, …, $Q_{\frac{k-1}{2}}(\frac{k+1}{2})$ and $Q_{\frac{k+1}{2}}(\frac{k-1}{2})$ (taking $k$ as an odd number) and generate $Q_k$. If $q_i$ and $q_{k-i}(k>i)$ are disjoint fault subsets and $t_j$ meets

$${tt}_{i,j}+{tt}_{k-i,j}=1$$

(10)

then $q_k=q_i\cup q_{k-i}$ exists, and $q_i$ and $q_{k-i}$ constitute a coupling of $q_k$. The cost of this coupling is

$$cost\left(q_i,q_{k-i}\right)=c_j+p\left(q_i\right)·cost\left(q_i\right)+p\left(q_{k-i}\right)·cost\left(q_{k-i}\right)$$

(11)

If the cost of this coupling is the least among all couplings, there is an edge between $q_k$ and $q_i$ and an edge between $q_k$ and $q_{k-i}$; then, $cost\left(q_k\right)=cost\left(q_i,q_{k-i}\right)$. Considering $q_i$ as a vertex in a graph, $Q_i$ is a vertex set and $X_k$ constitute an $k-1$-partite graph [30]. As shown in Figure 4, edges and couplings exist only in different partite graphs. So $\alpha$ is a certain process selecting edges from all couplings according to $\left(10\right)$ and $\left(11\right)$; that is,

$$Q_k=\alpha \left(X_k\right)=\left\{q_k\right|cost\left(q_k\right)=\min {\bigcup }_{i=1}^{\frac{k-1}{2}}{\bigcup }_{q_i\in Q_i\left(k-i\right),q_{k-i}\in Q_{k-i}\left(i\right)}cost\left(q_i,q_{k-i}\right)\}$$

(12)

Figure 4. The $m$-partite Graph.

$\beta$ represents an elimination action, which refers to the process that eliminates all sets of $X_k^{\prime }=\{X_k,Q_k\}$ and obtains a new family of sets $X_{k+1}$. Due to the uncertainty of the elimination method, $\beta$ is an uncertain process, that is,

$$X_{k+1}=\beta \left(X_k^{\prime }\right)=\beta \left[X_k,\alpha \left(X_k\right)\right]$$

(13)

$ID\left(q_i\right)$ refers to the number of edges directing to $q_i$ and satisfies:

$$\{\begin{array}{c}i=1,ID\left(q_i\right)=0\\ i\ne 1,ID\left(q_i\right)=2\end{array}$$

(14)

$\overline{ID}\left(q_i\right)$ refers to the number of couplings directing to $q_i$ and indicates the number of combinations constituting $q_i.$ $\overline{ID}\left(Q_i\right)=\sum _{q_i\in Q_i}\overline{ID}\left(q_i\right)$ is the total number of couplings directing to $Q_i$. $OD[q_i,Q_k\left(u\right)]$ and $\overline{OD}[q_i,Q_k\left(u\right)]$ refer to the number of edges and couplings of $q_i$ directing to $Q_k\left(u\right)$. The reduced $D$ in Figure 1 is taken as an example. As shown in Figure 5, $S=\{s_1,s_2,s_3\}$ can be composed of three combinations. Since the reasonability criterion sequence of $S_2=\{s_1,s_2\}$ is $0\times \times$ there is no $t_j$ for $s_3$ to meet $d\left(3,j\right)+{tt}_{2,j}=1$, so $\{s_1,s_2\}$ does not satisfy $\left(10\right)$. $S$ has only two couplings: $q_1=\left\{s_1\right\},q_2=\{s_2,s_3\}$ and $q_1=\left\{s_2\right\},q_2=\{s_1,s_3\}$. $cost\left(q_i,q_{k-i}\right)$ are 2.66 and 2.39 according to $\left(11\right)$, so there is an edge between $S$ and $\left\{s_2\right\}$ and an edge between $S$ and $\{s_1,s_3\}$.

Figure 5. An example of a tripartite graph model.

${best}_i$ is used to represent the set consisting of all $q_i$ that belong to the optimum diagnosis strategy. If $q_k$ can be expanded by a test, its subsets are denoted as $f\left(q_k\right)$.

$$f\left(q_k\right)=e_{1,k}·q_1+e_{2,k}·q_2+\cdots +e_{i,k}·q_i+\cdots +e_{k-1,k}·q_{k-1}$$

(15)

where $e_{i,k}$ refers to the expected number of $q_i$ generated by expanding $q_k$, specifically, $f\left(q_1\right)=2·q_1$. $q_k$ is expanded into two subsets each time, so $\sum _{i=1}^{k-1}{e}_{i,k}=2$. Generally, $d_{i,j}$ is independent, so

$$e_{i,k}=2·{\displaystyle \frac{C_k^i·r^i{·\left(1-r\right)}^{k-i}+C_k^i·{\left(1-r\right)}^i·r^{k-i}}{1-2·{\left(1-r\right)}^k-2·r^k}}$$

(16)

Then, fault expansion can be represented in polynomial form by $f\left(q_k\right)$; if $q_k$ is expanded by $l$ tests,

$$F\left[f\left(q_k\right),l\right]=\underset{l times}{\underbrace{f\left(\dots f\left(f\left(q_k\right)\right)\right)}}=\sum _{i=1}^{k-l}{e}_{i,k,l}·q_i$$

(17)

where

$$e_{i,k,l}=\sum _{\gamma }{e}_{k-a_1,k}·e_{k-a_1-a_2,k-a_1}·\cdots ·e_{i,i+a_l}$$

(18)

where $\gamma$ refers to all the combinations that meet $k-i=a_1+a_2+\cdots +a_l\left(a_1,a_2,\dots ,a_l\in N+\right)$ and $\left|\gamma \right|=C_{k-i-1}^l$. Completely isolating $q_m$ into $q_1$ requires at most $m-1$ iterations. For different $i,k$ and $l$, each $e_{i,k,l}$ is independent,

$$F\left[f\left(q_m\right),1\right]+F\left[f\left(q_m\right),2\right]+\cdots +F\left[f\left(q_m\right),m-1\right]=\sum _{i=1}^{m-1}\sum _{k=i+1}^m\sum _{l=1}^{m-1}{e}_{i,k,l}·q_i$$

(19)

Therefore, the expected number of $q_i$ can be estimated as $\left|{best}_i\right|=\sum _{l=1}^{m-1}\sum _{k=i+1}^m{e}_{i,k,l}$. Taking an example of $m=n=50,r=0.5$, the estimation values of $\left|{best}_i\right|$ are shown in Table 1. According to the above analysis, it can be inferred that $\left|{best}_i\right|$ is extremely small, so the vast majority of $q_i$s do not participate in constructing the optimal diagnosis strategy. By eliminating these $q_i\mathrm{s}$ properly and reasonably, many redundant operations can be reduced while minimizing the cost of the generated diagnosis strategy.

Table 1. The estimation value of $\left|{best}_i\right|$.

$\mathit{i}$	1	2	3	4	5	6	7	8
$\left|{\mathit{b}\mathit{e}\mathit{s}\mathit{t}}_{\mathit{i}}\right|$	50	18.04	9.02	5.25	3.38	2.35	1.70	1.25
$\mathit{i}$	8	9	10	11	12	13	>14
$\left|{\mathit{b}\mathit{e}\mathit{s}\mathit{t}}_{\mathit{i}}\right|$	1.25	0.95	0.77	0.67	0.60	0.54	<0.50

3.2. Transformation to an FEVP

As shown in Figure 6, based on $\left(12\right)$ and $\left(13\right)$, the generation of a diagnosis strategy is equated to a state transition process whose transition action includes combination and elimination. $X_k$ has two states, $\{{st}_1,{st}_2\}$, where ${st}_1$ indicates that the elements belonging to the optimum diagnosis strategy of $X_k$ have not been mistakenly eliminated, namely, $\bigcup _{i=1}^{k-1}{best}_i\subseteq X_k$, and ${st}_2$ are the opposite state to ${st}_1$. $X_k^{\prime }$ also has two states: $\{{st}_3,{st}_4\}$, where ${st}_3$ represents $\bigcup _{i=1}^{k-1}{best}_i\subseteq X_k^{\prime }$ and ${st}_4$ is the opposite state to ${st}_3$. $TP$ is the state transition matrix of the four states, where ${tp}_{uv}$ refers to the probability of ${st}_u$ transferring to ${st}_v$. The state can only transfer between $X_k$ and $X_k^{\prime }$, so ${tp}_{12}={tp}_{21}={tp}_{34}={tp}_{43}={tp}_{11}={tp}_{22}={tp}_{33}={tp}_{44}=0$. Based on the deterministic combination, if the elements in ${best}_i$ are mistakenly eliminated, the father node $q_k(q_k\in {best}_k)$ of $q_i$ cannot be generated. Therefore, ${tp}_{13}={tp}_{24}={tp}_{42}=1$ and ${tp}_{23}={tp}_{14}={tp}_{41}=0$ and ${tp}_{31}$ and ${tp}_{32}$ are two probabilities affected by $\beta$

$$TP=\left[\begin{array}{cccc}0& 0& 1& 0\\ 0& 0& 0& 1\\ {tp}_{31}\left(\beta \right)& {tp}_{32}\left(\beta \right)& 0& 0\\ 0& 1& 0& 0\end{array}\right]$$

(20)

Figure 6. The state transition process.

According to $\left(20\right)$, the optimal solution cannot be obtained once the state transfers to ${st}_2$ or ${st}_4$. The ideal $\beta$ meets ${tp}_{31}\left(\beta \right)=1-{tp}_{32}\left(\beta \right)=1$ and can eliminate all the redundant $q_i$s and retain all the elements of ${best}_i$, making the calculation speed extremely fast and $cost\left(q_m\right)$ optimal. Therefore, the generation of a diagnosis strategy can be described as a recursive process of $m-1$ calls, and the original optimization problem $\left(6\right)$ is transformed into an FEVP:

$$\{\begin{array}{c}\min cost\left(Q_m\right)\\ Q_k=\alpha \left[\beta \left(X_k,Q_{k-1}\right)\right]\end{array}$$

(21)

The objective function of $\left(21\right)$ is recursive and the unknown function is a nondeterministic elimination. Because the elimination is only a part of the objective function and has no constraints, $\left(21\right)$ is easier to solve.

3.3. ENI Structure

An ENI structure is proposed to determine the optimal $\beta$, as shown in Figure 7, $\beta$ is described by $SF,R$ and $Cr$. When the elimination criterion $Cr$ is in effect, all $q_i$s of $Q_i\left(k-i\right)$ are scored according to $SF$ and those with higher scores are retained, with a retention ratio $R_{i,k}$, that is:

$${\displaystyle \genfrac{}{}{0pt}{}{\hspace{1em}\hspace{1em} Q_i\left(k-i+1\right)=Q_i\left(k-i\right)\hspace{1em}\hspace{1em} Cr \mathrm{is} \mathrm{not} \mathrm{in} \mathrm{effect}\hspace{1em}\hspace{1em}}{\{\begin{array}{c}\left|Q_i\left(k-i+1\right)\right|=R_{i,k}\cdot \left|Q_i\left(k-i\right)\right|\\ \forall q_i\in Q_i\left(k-i\right)-Q_i\left(k-i+1\right)\\ \forall q_h\in Q_i\left(k-i+1\right)\\ SF\left(q_i\right)<SF\left(q_h\right)\end{array}Cr \mathrm{is} \mathrm{in} \mathrm{effect}}}$$

(22)

Figure 7. A schematic diagram of the ENI structure.

A neural network is used to fit the score function of $q_i$. The input features are the knowledge of $q_i,Q_k,D$ and $C$, including $p\left(q_i\right),cost\left(q_i\right),ID\left(q_i\right),\overline{ID}\left(q_i\right),OD\left(q_i,Q_k\right),\overline{OD}\left(q_i,Q_k\right),r,C$ and the prediction cost of $S-q_i$ (obtained through the greedy algorithm based on an entropy heuristic function [18]). The fitness value $cost\left(q_m\right)$ of the current score function can be obtained based on the multipartite graph model. Initially, $w$ and $b$ are random, so the score function is unreasonable and leads to a high $cost\left(q_m\right)$. Then, $w$ and $b$ are optimized continuously by the update method based on an intelligent algorithm. Finally, a score function that can generate a lower $cost\left(q_m\right)$ is trained. For different $D$, the generation methods of their fault subsets according to $\left(12\right)$ and the calculations of their fitness values according to $\left(11\right)$ are consistent, so $ANN(w,b)$ trained on one $D$ can be transferred to another $D$ to continue training until $ANN(w,b)$ converges. A sufficient number of $D$ matrices are used for training, and the well-trained $ANN(w,b)$, i.e., the optimized $\beta (SF,R,Cr)$, can be applied to other $D$.

It should be noted that $(w,b)$ are not trained by standard gradient descent, because the fitness function of ENI is not differentiable with respect to ANN parameters. After $ANN(w,b)$ outputs the scores of all $q_{i}s$, the following ranking, retention, elimination, and multipartite-graph reconstruction are all discrete operations. As a result, the mapping from $(w,b)$ to $cost\left(q_m\right)$ is nonanalytic and nondifferentiable, so backpropagation cannot be directly applied. Therefore, $ANN(w,b)$ is used to fit the scoring function, while intelligent algorithms are adopted for parameter optimization under the final diagnosis-cost objective.

To avoid ambiguity, the input of the ANN is not the raw dependency matrix $D$ itself. Instead, for each candidate fault subset to be evaluated during elimination, a fixed-length feature vector is constructed from aggregated statistical features derived from the current subset and its diagnostic context. Therefore, the input dimension of the ANN remains constant and is fully decoupled from the system scale $(m,n)$. In other words, the ANN does not learn a direct mapping from a variable-sized matrix to an elimination decision; rather, it learns a mapping from a scale-invariant statistical representation of a candidate subset to its elimination score. This provides the mathematical basis for the transferability of the ENI structure across different problem sizes.

3.4. Training and Convergence of $ANN(w,b)$

For any $k$ and $i$, the statistics and operation methods of the features are consistent when $Q_i\left(k-i\right)$ is eliminated; therefore, $Q_i\left(k-i\right)$ uses the same neural network $ANN(w,b)$. The $ANN(w,b)$ training process is stated in Algorithm 1.

Algorithm 1 The $ANN(w,b)$ training process
1	Select any intelligent algorithm and neural network structure.
2	Set the number of particles and the number of iterations as $z_{max}$ and ${it}_{max}$.
3	Initialize $W=\{w_1,w_2,\dots ,w_{z_{max}}\}$ and $b=\left\{b_1,b_2,\dots ,b_{z_{max}}\right\}$, where $w_z$ and $b_z$ represent the weight of the neural network for the $z$-th particle. Randomly generate one $D$.
4	for $it=1:{it}_{max}$ do
5		Update $\mathit{W}$ and $\mathit{b}$ using intelligent algorithms.
6		for $z=1:z_{max}$ do
7			Use $ANN(w_z,b_z)$ to calculate $cost\left(q_m\right)$ of $D$ based on $\left(11\right)$ and $\left(12\right)$.
8		end
9		Update $w_z$ and $b_z$ using the intelligent algorithms based on $cost\left(q_m\right)$ of all particles. Record the smallest $cost\left(q_m\right)$ in this iteration as $cost\left(q_m,it\right)$.
10	end

If $cost\left(q_m,it\right)=cost\left(q_m,1\right)$, this indicates that training on this $D$ did not improve $W$ or $b$. If this situation occurs continuously on ten $D$, then $W$ and $b$ have converged, and

$$w,b=\mathrm{a}\mathrm{r}\mathrm{g} \underset{W,b}{\min } cost\left(q_m\right)$$

(23)

3.5. Estimation of $\mathit{R}$

To quantify the proportion of elimination, the retention ratio $R$ (an upper triangular matrix) is defined, where $R_{i,k}$ represents that the proportion of elimination is $1-R_{i,k}$ when eliminating $Q_i\left(k-i\right)$. Ideally, the final retention of $Q_i$ is ${best}_i$. Considering the errors caused by the estimation and fitting function, the actual retention is $\theta$ times that of $\left|{best}_i\right|$; that is,

$$R_{i,i}·R_{i,i+1}·\cdots ·R_{i,m-1}·\left|Q_i\right|=\theta ·\left|{best}_i\right|$$

(24)

The value of $\theta$ is discussed in Experiment 1. If no elimination is implemented, the probability of taking each value for ${tt}_{i,j}$ of any $S_i$ is:

$$\{\begin{array}{c}p\left({tt}_{i,j}=0\right)=p\left(\forall s_h\in S_i,d_{h,j}=0\right)=r^i\\ p\left({tt}_{i,j}=1\right)=p\left(\forall s_h\in S_i,d_{h,j}=1\right)={\left(1-r\right)}^i\\ p\left({tt}_{i,j}=x\right)=1-r^i-{\left(1-r\right)}^i\end{array}$$

(25)

According to $\left(8\right)$ and $\left(9\right)$, if $s_h\in S-S_i$ exists and all the non $x$ terms of ${tt}_1$ are the same as ${tt}_i$, then ${tt}_i$ cannot meet the reasonability criterion. Therefore, the scale of $Q_i$ without elimination (${\left|Q_i\right|}^{\prime }$) can be estimated as follows:

$${\left|Q_i\right|}^{\prime }\approx C_m^i·{\left[1-\prod _{j=1}^{n}p\left({tt}_{1,j}={tt}_{i,j}\ne x\right)\right]}^{m-i}=C_m^i·{\left\{{1-\left(r^{i+1}+{\left(1-r\right)}^{i+1}\right)}^n\right\}}^{m-i}$$

(26)

According to $\left(12\right)$, the number of couplings $Q_k$ generated by $Q_i$ or $Q_{k-i}$ is estimated as follows:

$$\sum _{q_i\in Q_i}\overline{OD}\left(q_i,Q_k\right)={\left|Q_i\right|}^{\prime }·{\left|Q_{k-i}\right|}^{\prime }·{\displaystyle \frac{C_{m-i}^{k-i}}{C_m^{k-i}}}·{\displaystyle \frac{\left|Q_k\right|\prime }{C_m^k}}$$

(27)

where $C_{m-i}^{k-i}/C_m^{k-i}$ refers to the probability that $q_i$ and $q_{k-i}$ are disjointed and ${\left|Q_k\right|}^{\prime }/C_m^k$ refers to the probability that $S_i=q_i$. If the elimination is implemented, $S_k$ is separated into $S_i$ and $S_{k-i}$, and the probability that both are reasonable is $u_{i,k-i}$.

$$u_{i,k-i}\approx {\displaystyle \frac{\left|Q_i\left(k-i\right)\right|}{C_m^i}}·{\displaystyle \frac{\left|Q_{k-i}\left(i\right)\right|}{C_m^{k-i}}}$$

(28)

$S_i$ and $S_{k-i}$, respectively, have $C_m^i$ and $C_m^{k-i}$ combinations. If all the separating forms of $S_k$ are unreasonable, then $S_k$ is unreasonable. Thus, $\left|Q_k\right|$ can be estimated as the product of combination type $C_m^k$ and the probability of reasonability.

$$\left|Q_k\right|\approx C_m^k·\left[1-\prod _{i=1}^{\frac{k-1}{2}}{\left(1-u_{i,k-i}\right)}^{C_k^i}\right]$$

(29)

Corresponding to $\left(27\right)$, the number of couplings $Q_k$ generated by $Q_i(k-i)$ or $Q_{k-i}\left(k\right)$ is estimated as follows:

$$\sum _{q_i\in Q_i\left(k-i\right)}\overline{OD}\left(q_i,Q_k\right)=\left|Q_i\left(k-i\right)\right|·\left|Q_{k-i}\left(i\right)\right|·{\displaystyle \frac{C_{m-i}^{k-i}}{C_m^{k-i}}}·{\displaystyle \frac{\left|Q_k\right|}{C_m^k}}$$

(30)

To minimize the change in combination type caused by elimination, the proportion of the combination form of $q_i$ and $q_{k-i}$ must remain unchanged; that is, for $\forall i<k$,

$${\displaystyle \frac{\sum _{q_i\in Q_i\left(k-i\right)}\overline{OD}\left(q_i,Q_k\right)}{\sum _{q_i\in Q_i}\overline{OD}\left(q_i,Q_k\right)}}=b$$

(31)

where $b$ is a constant. According to $\left(24\right)$, $\left(27\right)$ and $\left(30\right)$,

$${\displaystyle \frac{\left|Q_i\right|·\left|Q_{k-i}\right|·\left|Q_k\right|}{\left|Q_i\right|\prime ·\left|Q_{k-i}\right|\prime ·\left|Q_k\right|\prime }}·\prod _{h=i}^{k-1}{R}_{i,h}·\prod _{h=k-i}^{k-1}{R}_{k-i,h}=b$$

(32)

Therefore, $R_{i,k}$ is any feasible solution that satisfies $\left(24\right)$ and $\left(32\right)$.

3.6. Determination of $\mathit{C}\mathit{r}$

Eliminating $X_k^{\prime }$ can reduce the time required for diagnosis strategy generation based on the multipartite graph model. However, the steps required for $\beta (SF,R,Cr)$, including calculating the statistics of the features, scoring each $q_i$ by $ANN\left(w,b\right)$ and sorting, increase the operation time. It is necessary to analyze whether eliminating $X_i^{\prime }$ would be beneficial for improving operation efficiency after $Q_i$ is generated. According to $\left(29\right)$, $\overline{ID}\left(Q_k\right)=\sum _{i=1}^{\frac{k-1 }{2}}\sum _{q_i\in Q_i\left(k-i\right)}\overline{OD}\left(q_i,Q_k\right)$, so the time needed to generate $\{Q_{i+1},Q_{i+2},\dots ,Q_m\}$ is:

$$time={∆}_1·\sum _{k=i+1}^m\sum _{i=1}^{\frac{k-1 }{2}}\sum _{q_i\in Q_i\left(k-i\right)}\overline{OD}\left(q_i,Q_k\right)$$

(33)

where ${∆}_1$ refers to the time required to generate a coupling. If elimination is not executed, $Q_i\left(k-i+1\right)=Q_i\left(k-i\right)$. If elimination is executed, $\left|Q_i\left(k-i+1\right)\right|=R_{i,k}·\left|Q_i\left(k-i\right)\right|$. ${time1}_i$ is the difference between the two results calculated based on $\left(32\right)$ and refers to the temporal benefit of elimination. ${time2}_i$ is used to indicate the time needed to eliminate $X_k^{\prime }$, which is proportional to the number of all fault subsets contained in $X_k^{\prime }$:

$${time2}_i={∆}_2·\sum _{h=1}^i\left|Q_h\left(i-h\right)\right|$$

(34)

where ${∆}_2$ refers to the time required for $q_i$ to be scored by a neural network and sorted. ${∆}_1/{∆}_2$ is related to $m,n$ and obtained through Monte Carlo simulation, as shown in Table 2.

Table 2. ${∆}_1/{∆}_2$ under different $m,n$.

$\mathit{m},\mathit{n}$	30	40	50	60	70	80
${\mathbf{∆}}_{\mathbf{1}}/{∆}_{\mathbf{2}}$	0.0772	0.0816	0.0874	0.0917	0.1492	0.2435

Therefore, the criterion for eliminating the virus was ${time1}_i>{time2}_i$. If the criterion loses efficacy after $Q_i$ is generated, then ${time1}_i\le {time2}_i$. After $Q_k$ is generated, the number of sets to be generated is reduced, so ${time1}_k<{time1}_i$. Moreover, as the number of generated sets increases, ${time2}_k>{time2}_i$. Thus, ${time1}_k<{time2}_k$, and each fault set will no longer be eliminated after the criterion loses efficacy.

3.7. Computational Complexity Analysis

To provide a more rigorous quantitative comparison, the computational complexity of the proposed method is analyzed from the two actions in the multipartite graph model, namely, combination $\alpha$ and elimination $\beta$. Let

$$N_k=\sum _{\left\{i=1\right\}}^{k-1}\left|Q_{i\left(k-i\right)}\right|+\left|Q_k\right|$$

(35)

denote the total number of candidate subsets involved when generating the (k)-th layer. In the combination stage, all candidate couplings between $Q_i\left(k-i\right)$ and $Q_{k-i}\left(i\right)$ must be checked according to $\left(10\right)$, and their costs must be evaluated according to $\left(11\right)$. Therefore, the complexity of $\alpha$ at layer $k$ is

$$T_{\mathrm{\alpha }}\left(k\right)=O\left(n\sum _{i=1}^{\lfloor \left(k-1\right)/2\rfloor }\left|Q_i\left(k-i\right)\right|\left|Q_{k-i}\left(i\right)\right|\right)$$

(36)

After $Q_k$ is generated, the elimination action $\mathrm{\beta }$ computes the features of all subsets in $X_k^{\prime }=X_k,Q_k$, scores them by ANN, and sorts them for retention. If the forward complexity of ANN is denoted by $C_{ANN}$, then the complexity of $\beta$ at layer $k$ is

$$T_{\mathrm{\beta }}\left(k\right)=O\left(N_k{C}_{ANN}+N_k\log N_k\right)$$

(37)

Accordingly, the total complexity of one strategy-generation process is

$$T_{\mathrm{prop}}=O\left(\sum _{k=2}^m\left[n\sum _{i=1}^{\lfloor \left(k-1\right)/2\rfloor }\left|Q_i\left(k-i\right)\right|\left|Q_{k-i}\left(i\right)\right|+N_k{C}_{ANN}+N_k\log N_k\right]\right)$$

(38)

If no elimination is performed, i.e., all subsets are retained, then $Q_i\left(u\right)=Q_i$, and the dominant term degenerates to

$$T_{\mathrm{no}-\mathrm{\beta }}=O\left(\sum _{k=2}^{m}n\sum _{i=1}^{\lfloor \left(k-1\right)/2\rfloor }\left|Q_i\right|\left|Q_{k-i}\right|\right)$$

(39)

Therefore, the main contribution of ENI is to reduce $\left|Q_i\right|$ to $\left|Q_{i}u\right|$, so that the dominant coupling-enumeration term is significantly compressed in subsequent layers. Although $\beta$ introduces additional scoring and sorting overhead, this extra cost is much smaller than the reduction in redundant couplings for large-scale systems.

4. Experiments

To verify the effectiveness of the proposed method, we use a sufficient $D$ of different sizes as the training set until $ANN(w,b)$ converges, and the trained $\beta$ are applied to three experiments. Experiment 1 simulates the impact of $\theta$. Experiment 2 compared the results of the proposed method with those of existing algorithms at different scales. The performances of different combinations of neural network structures and intelligent algorithms on the ENI are also discussed. Experiment 3 selected two typical complex circuit systems as real cases (a control moment gyro system [20] and a two-channel multiple-input multiple-output (MIMO) terminal system).

Four comparative algorithms are selected, and their parameters are adjusted to the best values. The population size and number of iterations of the QGA [20] and HPSO [22] are 200 and 200, respectively, and both of their mutation rates are less than 5%. The third and fourth algorithms selected are the Growing [26] and Hybrid [28] algorithms, respectively. The $D$ used in Experiments 1 and 2 were randomly generated according to $r=0.5$, with $C$ and $P$ following a uniform distribution from 0 to 2 and a normalized uniform distribution from 0 to 1. The software used for the experiments was MATLAB2022b in Windows 11, and the processor used was an AMD R9 CPU @ 2.50 GHz.

4.1. Sensitivity Analysis

The cost of the generated strategy is related to $\theta$ and $r_g$ when applying the trained $\beta$ to test samples.

When $\theta$ is small, there may be errors in the estimation of $\left|{best}_i\right|$, resulting in unreasonable elimination of $Q_i$, and the reserved fault set cannot be used to generate $q_m$. When $\theta$ gradually increases to a certain value to meet $X_m^{\prime }\cap \left\{\bigcup _{i=1}^m{best}_i\right\}\approx \left\{\bigcup _{i=1}^m{best}_i\right\}$, a better test cost can be generated (denoted as cost convergence). If $\theta$ continues to increase, the additional $q_i$ retained does not participate in constructing the optimal diagnosis strategy, meaning that $X_m^{\prime }\cap \left\{\bigcup _{i=1}^m{best}_i\right\}$ remains almost unchanged and that the cost remains largely unchanged.

In addition to $\theta$, another practical parameter is introduced in the implementation of the baseline GA strategy generator, namely the proportional factor $r_g$, which controls the optimization budget by setting the iteration number and population size as $IT=POP=m·r_g$. Since the system scale increases with $m$, using $r_g$ instead of directly assigning fixed values to $IT$ and $POP$ provides a normalized way to compare different scales under comparable computational intensity.

For sensitivity analysis of $\theta$, 10 samples for each scale range from $30\times 30$ to $80\times 80$ are randomly generated. Then, the number of converged samples among 10 random samples is counted, and the average computation time is recorded for different $\theta$s. The results are shown in Figure 8 and Figure 9.

Figure 8. The impact of $\theta$ on cost convergence at different scales.

Figure 9. The impact of $\theta$ on the computation time at different scales.

For sensitivity analysis of $r_g$, 10 samples for each scale range from $30\times 30$ to $80\times 80$ are randomly generated. The average cost was calculated over 10 randomly generated samples. Then, for each fixed system scale, the value of $r_g$ at which the cost tended to converge as $r_g$ varied was identified, and the corresponding convergence point was marked in black. And the average computation time is recorded for different $r_g$s. The results are shown in Figure 10 and Figure 11.

Figure 10. The impact of $r_g$ on cost convergence at different scales (Convergence points of different scales are connected by the black line).

Figure 11. The impact of $r_g$ on the computation time at different scales.

The larger the system scale is, the larger its corresponding $\left|Q_i\right|$. Due to the randomness of intelligent algorithms, there is a small deviation between the trained $\beta$ and the ideal $\beta$, which increases the difficulty of retaining $Q_i(m-1+i)\cap {best}_i$. Therefore, a greater $\theta$ is required to converge, and the computation time also increases.

When $r_g$ is too small, the search space cannot be explored sufficiently, and the generated diagnosis strategy is likely to have a relatively high cost. As $r_g$ increases, the search becomes more adequate, and the diagnosis cost decreases accordingly. However, when $r_g$ exceeds a certain range, the improvement in cost becomes marginal. In the experiments, it was observed that when $r_g$ is around 0.5, the cost tends to become nearly stable for most scales.

4.2. Performance Differences of Algorithms at Different Scales

Ten samples at each scale are generated and the average computation time and expected cost of the proposed method with those of existing algorithms are compared. To analyze the impact of the neural network and intelligence algorithm on the ENI, three neural network structures are selected: a multilayer perceptron (MLP) with one or two hidden layers and a long short-term memory (LSTM) network. Three intelligent algorithms are selected: particle swarm optimization (PSO), the genetic algorithm (GA), and the cuckoo bird algorithm (CS). $\theta ,r_g$ is set based on the results of Experiment 1 while considering both computation time and convergence. The experimental results for the 9 ENIs and comparative algorithms are shown in Table 3 and Table 4, where the cost of PSO_MLP1 is given in units of “1”.

Table 3. Normalized test cost and computation time (s) of existing algorithms.

Existing Algorithm
$\mathit{m},\mathit{n}$	QGA	HPSO	Growing	Hybrid
30	1.26/13.70	1.51/4.92	1.29/0.01	1.08/134.36
40	1.47/19.18	1.64/9.64	1.22/0.02	1.07/552.51
50	1.57/25.05	1.64/13.34	1.30/0.04	1.11/2761.98
60	1.56/31.71	1.93/18.48	1.31/0.06	1.05/>1 d
70	1.83/38.35	1.96/24.74	1.42/0.09	/>7 d
80	1.85/46.48	2.02/27.30	1.44/0.17	/>30 d

Table 4. Normalized test cost and computation time (s) of the proposed method.

Proposed Method (Various Intel-Ligent Algorithms and Neural Networks on the ENI)
$\mathit{m},\mathit{n}.$	$\mathit{\theta }$	PSO MLP1	PSO MLP2	PSO LSTM	GA MLP1	GA MLP2	GA LSTM	CS MLP1	CS MLP2	CS LSTM
		${\mathit{r}}_{\mathit{g}}=0.5$
30	$3$	1.00/0.58	0.96/0.54	1.00/0.58	1.03/0.60	1.02/0.61	1.01/0.65	0.97/0.54	0.90/0.60	1.06/0.60
40	$3$	1.00/1.78	1.02/2.09	1.03/2.08	1.01/2.15	1.07/2.21	0.97/2.35	1.04/1.95	0.93/2.16	1.09/2.07
50	$4$	1.00/6.45	1.04/7.51	1.05/8.60	0.98/7.50	0.91/8.57	1.03/8.36	1.08/7.36	1.01/7.61	0.91/10.40
60	$4$	1.00/17.76	0.98/15.93	1.12/18.41	1.01/16.64	1.03/16.45	1.08/19.22	0.91/17.45	1.09/16.86	0.98/18.26
70	$5$	1.00/48.59	1.01/51.76	0.96/51.55	0.96/49.94	0.91/52.88	1.10/52.01	1.09/51.07	1.03/53.82	1.09/57.50
80	$5$	1.00/84.93	1.03/92.24	0.92/91.99	0.98/90.06	0.97/89.01	0.98/91.05	1.05/87.72	0.96/89.99	1.01/97.01

Due to the long computation time, Hybrid is almost impossible to carry out on a scale greater than $70\times 70$. In terms of cost, the proposed method and Hybrid method yield lower costs at all scales, and our method outperforms the other methods. At 80 × 80, the test cost is only 69.4% of the Growing algorithm. In terms of time, the Growing algorithm has the shortest time, and the proposed method is shorter than the QGA, HPSO, and Hybrid algorithms at small to medium scales. As the scale increases, the computation time of the proposed method can reach 97 s at $80\times 80$, which is shorter than that of the Hybrid. However, since the diagnosis strategy is generated during the design phase and does not have real-time requirements, 97 s is acceptable. In addition, any neural network structure has the ability to fit the score function theoretically, and its parameters are optimized by intelligent algorithms; thus, the optimization ability of these ENIs is the same. The complex structure will expand the optimized decision space, so MLP2 and LSTM will slightly increase the computational time, but the costs are almost the same.

To clarify the robustness of the proposed ENI structure, three aspects should be emphasized. First, ENI does not operate directly on the raw dependency matrix $D$. Instead, it learns a scoring function from fixed-dimensional aggregated features extracted from the current candidate fault subset. Therefore, the input dimension of the network is decoupled from the system scale $\left(m,n\right)$, and the statistical meaning of the input remains consistent across different problem sizes. This scale-decoupled representation improves the stability when it is transferred across different dependency matrices. Second, the role of ENI is not to generate a complete diagnosis strategy directly, but to rank candidate fault subsets. As a result, ENI mainly needs to preserve a reliable relative ordering among candidate subsets, rather than predict an exact physical quantity, which reduces the sensitivity of the final strategy cost to fluctuations in network architecture and initialization. Third, the neural network and the intelligent algorithm play different roles in ENI: the former approximates the scoring function, whereas the latter searches for favorable parameters under a non-differentiable objective. This separation makes the ENI framework compatible with different neural-network structures and different intelligent algorithms.

The hyperparameter selection is also not arbitrary, but consistent with the functional decomposition of ENI. For the neural network, the input is a low-dimensional statistical feature vector, and the task is to learn a coarse-grained priority score for candidate subsets. Therefore, a shallow MLP is already expressive enough for this purpose. More complex architectures enlarge the parameter space, but do not necessarily improve the final diagnosis cost, while they do increase the training and inference overhead. For the intelligent algorithm, the population size and the number of iterations should balance search sufficiency and offline computational burden: too small a setting leads to insufficient exploration, whereas too large a setting yields marginal performance gain at the cost of substantially increased computation time.

4.3. Real-Case Verification

The first case is a control moment gyro system [20], which is an important execution structure for controlling spacecraft flight attributes. This system consists of 28 different tests and 36 failure states (reduced $D$), and all the test costs are 1. Under the premise of ensuring a 100% fault isolation rate, a diagnostic strategy with minimal cost needs to be designed for the system. Based on Experiments 1 and 2, PSO_MLP1 is selected with $\theta =4$ and $r_g=0.5$. The computation time and cost of each algorithm are shown in Table 5.

Table 5. The comparison results of the control moment gyro system.

Algorithm	Direction of Generating	FIR	Cost	Computation Time (s)	Peak CPU Usage
PSO_MLP1	bottom-up	100%	5.459	0.658	18.3%
QGA	top-down	100%	5.909	25.902	21.9%
HPSO	top-down	100%	5.939	5.699	22.8%
Growing	horizontal	100%	5.571	0.035	18.6%
Hybrid	bottom-up	100%	5.478	126.355	24.1%

A two-channel MIMO circuit is selected as the second real case, as shown in Figure 12. This is the signal transmission and reception frontend module of a complex radar. Under the premise of ensuring a 100% fault isolation rate, a diagnosis strategy is required to isolate faults as quickly as possible. This system consists of 45 modules and 11 test points. Based on theoretical analysis and knowledge, all 73 faults of the system were identified by analyzing the possible fault modes of each module and their impact on system function. And 50 tests have been determined that can be used to detect all fault signals, as shown in the Appendix A.

Figure 12. Two channels are used for testability design verification.

Tests are performed by injecting signals at one test point (or two test points) and detecting the output at another test point. There are three methods for injecting faults, including plugging and unplugging jumper caps, rotating and sliding rheostats, and circuit simulation. The outputs before and after fault injection are compared to obtain $D,P,C$. An example is shown in Figure 13. We inject fault $s_5$ and carry out $t_{12}$; a decrease in the signal-to-noise ratio from 60 dB to 10 dB is detected while carrying out the symmetry test $t_{37}$. The signal-to-noise ratio is kept at 60 dB, so $d_{\mathrm{5,12}}=1,d_{\mathrm{5,37}}=0$. Information on the faults and tests, the system schematic diagram, and $D$ are provided in the Appendix A.

Figure 13. An example of fault injection.

Based on Experiments 1 and 2, PSO_MLP1 is selected with $\theta =4$ and $r_g=0.5$. The computation time and cost of each algorithm are shown in Table 6.

Table 6. The comparison results of the MIMO system.

Algorithm	Direction of Generating	FIR	Cost	Computation Time (s)	Peak CPU Usage
PSO_MLP1	bottom-up	100%	3.480	26.045	17.8%
QGA	top-down	100%	5.521	34.889	22.5%
HPSO	top-down	100%	5.724	28.249	24.8%
Growing	horizontal	100%	5.444	0.092	20.7%
Hybrid	bottom-up	100%	3.537	>7 d	\

Consistent with the simulation results, the cost of PSO_MLP1 outperforms that of the other algorithms in two real cases, and it yields more significant advantages in the second case $D$, which has a larger scale (only 63.9% of the Growing algorithm). The computation time of PSO_MLP1 is shorter than that of the QGA, HPSO, and Hybrid. And this advantage is not significant in the large system of the second case. Although the Growing algorithm has a shorter calculation time, the testability design does not have real-time requirements, so 26.045 s is completely acceptable. This demonstrates the effectiveness of the multipartite graph model and ENI structure. The strategy of PSO_MLP1 is shown in the Appendix A. Following this strategy for fault isolation, 300 faults are injected based on $P$. All the diagnostic results were consistent with those of the injection, and the average cost was consistent with the expected cost. This indicates that the proposed method can generate a better diagnosis strategy, which is feasible for improving testing efficiency and reducing comprehensive test costs.

In the current real-case verification, the injected fault samples were used to check the consistency between the observed test outcomes and the binary dependency matrix D. Since the proposed strategy is derived from D rather than learned from data, these samples serve as consistency-verification samples instead of training/testing samples in the conventional machine-learning sense.

The present study is based on a deterministic binary dependency matrix $D$. Such a formulation is appropriate for systems in which the test responses are highly repeatable and strongly separable as shown in $\left(3\right)$, i.e., repeated executions of the same test under the same fault state produce stable binary outcomes. In cases where the discrimination capability of a test is weak or the test design is not sufficiently informative, the same test may provide only partial separation for certain faults, and the corresponding dependency relation is more appropriately represented by a fractional or probabilistic value between 0 and 1. Moreover, in more complex industrial scenarios, the outcome of a test may also be affected by sensor noise, measurement error, environmental disturbance, parameter drift, intermittent faults, or overlap between fault signatures, so that the same test under the same fault state does not always yield an identical result. This issue is especially relevant when the discrimination is based on waveform similarity, spectral features, or analog quantities near a threshold, where repeated tests may produce results that are distinguishable in most cases but not in all cases. Therefore, the difference between binary and probabilistic dependency relations reflects not only different forms of test-result representation, but also differences in test design quality and engineering application scenarios.

5. Conclusions

Based on the multi-signal flow graph model, minimizing the diagnostic cost is described as an MDP. Due to the combinatorial explosion, most existing algorithms are hard to solve this problem in complex systems. Therefore, this paper transforms the complex MDP into a simpler FEVP for nondeterministic elimination. Based on the ENI structure, the unknown function of FEVP is decomposed into three parts and solved separately. The simulation results show that different neural network structures and intelligent algorithms can establish the proposed ENI structure. Compared to existing algorithms, it offers greater advantages when applied to large-scale systems. The experiment results show that within an acceptable time, the cost can be reduced to 69.4% of comparison algorithms and can reach 63.9% on the testability design case of a two-channel MIMO system.

The present model is mainly suitable for testability-design problems with highly deterministic test responses. For systems with significant test uncertainty, the modeling stage itself should be adjusted by introducing probabilistic dependency matrices, robust strategy-generation rules, or joint cost–risk optimization criteria. In other words, whether test uncertainty should be explicitly incorporated into the MDP depends on the test mechanism, the signal-to-noise ratio, and the repeatability of the test outcomes in the target system. In this paper, we focus on the deterministic setting in order to clearly demonstrate the advantage of the multipartite graph model and the ENI structure for large-scale minimum-cost strategy generation, while the uncertainty-aware extension will be investigated in future work.

In our future work, we plan to implement the following three extensions to the proposed method: The first item is to improve the universality of the ENI structure and expand its application scope to the top-down and horizontal methods. The second item is to develop an adaptive method based on the ENI structure to improve the robustness of elimination action applied on different distributions of $D$. The third item is to integrate with test uncertainty modeling, so that the proposed framework can be extended to probabilistic or weighted test-response representations for more engineering scenarios.