A virtual-real combined urban rail train fault simulation and intelligent evaluation method and system

Abstract

The present application relates to the field of rail transit technology, and discloses a virtual-real combined urban rail train fault simulation and intelligent evaluation method and system. The method constructs a multi-physical domain digital twin of the urban rail train, maps the real train operation data to the digital twin, injects cross-physical domain faults, obtains a fault mechanism constraint set, generates a global diagnosis model using federal incremental learning, extracts fault feature representation, calculates root cause contribution through a causal strength quantification model, feeds back to the digital twin to drive a new round of fault injection, and feeds back samples generated by each round of fault injection carrying fault labels to the federal incremental learning framework to update the global diagnosis model, forming a closed-loop iteration of fault simulation and root cause positioning, and improving the authenticity of fault simulation and the accuracy of root cause positioning.

Description

Technical Field

[0001] This invention relates to the field of rail transit technology, specifically to a virtual-real combined urban rail train fault simulation and intelligent assessment method and system. Background Technology

[0002] Existing urban rail train driver training systems primarily construct a driving environment and fault simulation scenarios consistent with real trains through a simulated driver's cab, electrical cabinet, and instructor management platform. These systems can realistically simulate various fault phenomena during train operation, such as brake failure and door failure, and allow instructors to inject faults through preset or real-time methods to train drivers' emergency response capabilities.

[0003] However, existing training systems still have significant shortcomings in fault simulation and assessment. On the one hand, fault injection largely relies on pre-set fault lists and simple logic triggers, lacking in-depth simulation of the complex coupling relationships between multiple physical domain systems of a train, and making it difficult to realistically reflect the cross-domain transmission effects of faults between subsystems such as traction, braking, auxiliary power supply, and running gear.

[0004] On the other hand, the system's evaluation of the driver's troubleshooting process is mainly based on preset scoring rules and operation records, failing to make full use of real vehicle operation data and simulation data to achieve automated and intelligent tracing from fault phenomena to root causes.

[0005] Furthermore, the distribution of fault data varies across different vehicle depots, and existing systems lack efficient data collaboration and model generalization mechanisms, resulting in poor transferability of diagnostic models. Therefore, there is an urgent need for a method and system capable of deep virtual-real fusion, accurate fault simulation across physical domains, and intelligent root cause localization. Summary of the Invention

[0006] To address the aforementioned technical shortcomings, the purpose of this invention is to provide a virtual-real integrated urban rail train fault simulation and intelligent assessment method and system, in order to solve the problem that existing technologies struggle to accurately pinpoint the root causes of faults across physical domains.

[0007] To solve the above-mentioned technical problems, the present invention adopts the following technical solution: In a first aspect, the present invention provides a method for simulating and intelligently evaluating urban rail train faults by combining virtual and real methods, the method comprising: Step S1: Construct a multi-physical domain digital twin of the urban rail train. Map the actual vehicle operation data of traction, braking, auxiliary power supply and running gear to the digital twin through the data distribution service channel to form a virtual-physical mapping relationship. Based on the fault knowledge base, inject cross-physical domain faults into the digital twin to obtain a fault mechanism constraint set with fault labels. Step S2: Using the fault mechanism constraint set as a supervision signal, perform class-balanced weighted training on each vehicle depot client using the federated incremental learning framework. The server generates a global diagnostic model through federated aggregation. In the initial learning stage, the model is weighted and averaged according to the proportion of the number of samples. In the incremental learning stage, the model is dynamically weighted and aggregated according to the diagnostic accuracy of each client, and transferable fault feature representations are extracted. Step S3: Input the fault feature representation and the virtual-real mapping relationship into the causal strength quantification model, calculate the causal strength score of the potential root cause to the fault feature, and output the root cause contribution. Step S4: Feed back the root cause contribution and fault mechanism constraint set to the virtual and real fault simulation end, drive the digital twin to perform a new round of fault injection for cross-physical domain faults, and feed back the samples with fault labels generated by each round of fault injection to the federated incremental learning framework to update the global diagnostic model, forming a closed-loop iteration of fault simulation and root cause localization.

[0008] Preferably, in one possible implementation of the first aspect, the process of constructing the multi-physical domain digital twin of the urban rail train in step S1 includes: The motor torque and rectifier-inverter electrical quantities of the traction system, the cylinder pressure and brake pad gap of the braking system, the voltage and current harmonics of the auxiliary power supply system, and the axle box vibration and wheel-rail force of the running gear are each abstracted into independent twin units. Each independent twin unit subscribes to real-vehicle operation data topics through the data distribution service channel and performs spatiotemporal alignment based on timestamps and vehicle identifiers; A cross-physical domain digital fault tree is constructed based on a fault knowledge base. The top-level nodes of the fault tree represent subsystem-level fault modes, the intermediate nodes represent the energy transfer and signal transmission relationships between physical domains, and the leaf nodes are bound to the corresponding independent twin unit state variables.

[0009] Preferably, in one possible implementation of the first aspect, the injection of the cross-physical domain fault includes: Based on the fault modes defined in the fault knowledge base, a perturbation bias is applied at the corresponding leaf node of the fault tree and published to the bound independent twin unit in the form of a message through the data distribution service channel. The independent twin unit updates its internal state variables according to the physical domain dynamics equations and sends the updated state variables back to the fault tree engine via the data distribution service channel; The fault tree engine performs multi-hop propagation along the causal relationship edge, calculates the fault propagation strength of each causal relationship edge, and marks it as an abnormal causal relationship when the fault propagation strength exceeds the preset propagation threshold of the causal relationship edge, and recursively activates the downstream independent twin unit to continue to apply the perturbation bias. The recursive activation process continues until the top node of the fault tree or the propagation depth reaches the limit level. It summarizes the state variables of all independent twin units with marked abnormal causal relationships and their fault labels, and outputs the fault mechanism constraint set.

[0010] Preferably, in one possible implementation of the first aspect, the extraction process of fault feature representation in step S2 includes: Each depot's client reads fault-labeled samples from the fault mechanism constraint set and constructs a category-balanced weighted loss function; Each depot client performs initial training on its local model using a class-balanced weighted loss function. After each round of initial training, reference samples of each class are randomly selected from the training samples and saved to the reference sample storage as old class reference samples for the subsequent incremental learning stage. The server collects the local models trained by each client, aggregates and updates them to obtain the global model for the initial learning stage. During the incremental learning phase, the category-balanced weighted loss function incorporates a relation consistency distillation term, which measures the difference in output distribution between the current local model and the previous optimal global model on the samples stored in the old reference sample memory. Each client performs incremental training using the fused loss function and uploads its local model parameters to the server. The server generates a global diagnostic model through dynamic weighted aggregation and extracts the penultimate hidden state as a fault feature representation.

[0011] Preferably, in one possible implementation of the first aspect, the aggregation of the global diagnostic model includes: The server adaptively calculates the aggregation weight based on the diagnostic accuracy of each vehicle depot client in the current fault category, and aggregates the local model parameters uploaded by each client according to the dynamic weighted federated average strategy. After the initial learning phase, the incremental learning phase begins. The local loss function constructed in the incremental learning phase includes a category balancing weighting term and a relation consistency distillation term. The local loss function is used to collaboratively train the client models and aggregate them to the server. The server uses the dynamically weighted aggregated global model as the optimal global model for this phase.

[0012] Preferably, in one possible implementation of the first aspect, the structure of the causal strength quantification model in step S3 includes: Using independent twin units defined by the virtual-real mapping relationship as nodes and the transmission relationship of cross-physical domain faults between independent twin units as causal relationship edges, a dynamic temporal causal graph is constructed, with each causal relationship edge carrying causal direction attributes and propagation weights. Sliding window extraction of sub-time series is performed on the state variable time series of each independent twin unit in normal mode, and the normal fluctuation range of each causal relationship edge is calculated using the causal network constructed from the sub-time series in normal mode. The state variable sub-time series and fault feature representation of each independent twin unit under the fault mode are input into the dynamic temporal causal graph. The multi-hop message passing is performed along the causal relationship edge by a graph attention network and weighted according to the propagation weight to calculate the root cause probability score of each node. The Granger causality test statistic of each causal relationship edge in the failure mode is compared with the normal fluctuation range of the same causal relationship edge in the normal mode. The source node corresponding to the causal relationship edge that exceeds the normal fluctuation range is given a causal strength score.

[0013] Preferably, in one possible implementation of the first aspect, the fusion of the causal strength scores includes: Sliding window extraction is performed on the time series of state variables of each independent twin unit in normal mode and fault mode to extract sub-time series. The causal network constructed using the sub-time series in normal mode is used to calculate the normal fluctuation range of each causal relationship edge. For each causal network constructed from fault mode sub-time series, determine whether the causal strength of each causal relationship edge exceeds the normal fluctuation range, mark the abnormal causal relationships, and weight them according to the number of abnormal causal relationship edges in each sub-time series. Count the frequency of each node being judged as an abnormal root cause node, and obtain the fused causal strength score of each node. This fused causal strength score is used as a component of the root cause score in the calculation of the root cause score.

[0014] Preferably, in one possible implementation of the first aspect, the root cause contribution output process includes: Based on the root cause probability score of each node in the dynamic temporal cause-effect graph, nodes whose root cause probability scores exceed the preset root cause probability score threshold are marked as candidate root cause nodes. Obtain the state variable offset of the independent twin unit corresponding to each candidate root cause node in the fault mode, compare the state variable offset with the normal fluctuation range of the candidate root cause node in the normal mode, and normalize the comparison result to obtain the normalized abnormal deviation degree. The root cause score of each candidate root cause node is determined by the weighted sum of the root cause probability score, the normalized degree of abnormal deviation, and the causal strength score after fusion. The independent twin unit corresponding to the node with the largest root cause score among all candidate root cause nodes is identified as the root cause of the fault, and the root cause score of the root cause is output as the root cause contribution.

[0015] Preferably, in one possible implementation of the first aspect, the closed-loop iterative process of fault simulation and root cause localization in step S4 includes: The root cause contribution and fault mechanism constraint set are fed back to the virtual and real fault simulation end. The digital twin is used to capture the abnormal trigger signal, track the propagation trajectory of the abnormal trigger signal between each independent twin unit, and construct an event deconstruction chain that includes the location of the abnormal source, the hierarchy of the affected independent twin units, and the fault propagation intensity. The digital twin performs a new round of fault injection for cross-physical domain faults based on the event deconstruction chain, performs multi-hop propagation along the causal relationship edge, and calculates the fault propagation strength of each path through the causal relationship edge; The fault feature representation generated by the new round of fault injection is re-input into the causal strength quantification model, the causal strength score of the potential root cause to the fault feature is calculated, and the updated root cause contribution is output. The updated root cause contribution and fault mechanism constraint set are fed back to the virtual and real fault simulation end to drive the digital twin to perform the next round of fault injection for cross-physical domain faults. Meanwhile, the samples with fault labels generated in each round of fault injection are fed back to the federated incremental learning framework as new incremental tasks to perform incremental training on the local models of each vehicle segment client, and the server dynamically re-weights and aggregates them to update the global diagnostic model and fault feature representation. The iteration continues until the change in the root cause contribution between two adjacent rounds is less than a preset threshold or the maximum number of iterations is reached, thus forming a closed-loop iteration of fault simulation and root cause localization. Based on the abnormal causal relationships marked in the new round of fault injection, update the fault mechanism constraint set as the basis for the next round of fault injection.

[0016] Secondly, the present invention provides a virtual-real integrated urban rail train fault simulation and intelligent assessment system, the system being used to implement the virtual-real integrated urban rail train fault simulation and intelligent assessment method as described in the first aspect, comprising: The digital twin construction module constructs a multi-physical domain digital twin of an urban rail train. It maps real-vehicle operation data of traction, braking, auxiliary power supply, and running gear to the digital twin through a data distribution service channel, forming a virtual-real mapping relationship. Based on the fault knowledge base, cross-physical domain faults are injected into the digital twin to obtain a fault mechanism constraint set with fault labels. The federated incremental learning module uses the fault mechanism constraint set as a supervision signal and performs class-balanced weighted training on each vehicle depot client using the federated incremental learning framework. The server generates a global diagnostic model through federated aggregation. In the initial learning stage, the model is weighted and averaged according to the sample size ratio. In the incremental learning stage, the model is dynamically weighted and aggregated according to the diagnostic accuracy of each client and the transferable fault feature representation is extracted. The causal intensity quantification module inputs the fault feature representation and the virtual-real mapping relationship into the causal intensity quantification model, calculates the causal intensity score of the potential root cause to the fault feature, and outputs the root cause contribution. The closed-loop iteration module feeds back the root cause contribution and fault mechanism constraint set to the virtual and real fault simulation end, driving the digital twin to perform a new round of fault injection for cross-physical domain faults, and feeds back the samples with fault labels generated by each round of fault injection to the federated incremental learning framework to update the global diagnostic model, forming a closed-loop iteration of fault simulation and root cause localization.

[0017] The beneficial effects of this invention are as follows: by constructing a multi-physical domain digital twin of an urban rail train, high-fidelity virtual-real mapping of the operating data of key subsystems such as traction, braking, auxiliary power supply and running gear can be achieved, which can accurately simulate the transmission process of faults across physical domains and improve the realism and coverage of fault scenarios.

[0018] By leveraging the federated incremental learning framework, while protecting the data privacy of each vehicle segment, a global diagnostic model with strong generalization ability is generated through class-balanced weighted training and dynamic weighted aggregation strategies. This effectively solves the problems of uneven distribution of fault categories and data silos, and significantly improves the model's adaptability and diagnostic accuracy in different operating environments.

[0019] By introducing a causal intensity quantification model and constructing a dynamic temporal causal graph, combined with the direction-aware message passing of a graph attention network, the contribution of each potential root cause can be accurately quantified from complex fault characteristics. This enables automated and intelligent tracing from fault phenomena to root causes, significantly reducing the difficulty and time cost of manual investigation.

[0020] By feeding back the root cause contribution and fault mechanism constraint set to the virtual and real fault simulation end, a closed-loop iterative mechanism for fault simulation and root cause localization is formed, enabling the system to continuously optimize the fault injection strategy and diagnostic model, and continuously improve the realism of fault simulation and the accuracy of root cause localization. Attached Figure Description

[0021] To more clearly illustrate the technical solutions in the embodiments of the present invention or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are only some embodiments of the present invention. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0022] Figure 1 This application provides a flowchart of a virtual-real combined urban rail train fault simulation and intelligent evaluation method. Detailed Implementation

[0023] The technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0024] Example 1: As Figure 1 As shown, this invention provides a virtual-real combined urban rail train fault simulation and intelligent assessment method, including: Step S1: Construct a multi-physical domain digital twin of the urban rail train. Map the actual vehicle operation data of traction, braking, auxiliary power supply and running gear to the digital twin through the data distribution service channel to form a virtual-physical mapping relationship. Based on the fault knowledge base, inject cross-physical domain faults into the digital twin to obtain a fault mechanism constraint set with fault labels.

[0025] In this embodiment, a multi-physical domain digital twin of an urban rail train is constructed. The motor torque and rectifier / inverter electrical quantities of the traction system, the cylinder pressure and brake pad clearance of the braking system, the voltage and current harmonics of the auxiliary power supply system, and the axle box vibration and wheel-rail force of the running gear are each abstracted as an independent twin unit. Each independent twin unit subscribes to real-vehicle operation data topics through a data distribution service channel, performs spatiotemporal alignment based on timestamps and vehicle identifiers, and maps the real-vehicle operation data of traction, braking, auxiliary power supply, and running gear to the digital twin, forming a virtual-real mapping relationship. A cross-physical domain digital fault tree is constructed based on a fault knowledge base. The top-level nodes of the fault tree represent subsystem-level fault modes, the intermediate nodes represent energy transfer and signal transmission relationships between physical domains, and the leaf nodes are bound to the corresponding independent twin unit state variables.

[0026] Cross-physical domain faults are injected into the digital twin based on the fault knowledge base, resulting in a fault mechanism constraint set with fault annotations. Based on the fault modes defined in the fault knowledge base, perturbation biases are applied to the corresponding leaf nodes of the fault tree, and messages are published to the bound independent twin units via the data distribution service channel. The independent twin units update their internal state variables according to the physical domain dynamics equations. The traction system independent twin unit updates the motor torque and electrical quantities based on the motor electromagnetic torque equation and the rectifier-inverter switching function; the braking system independent twin unit updates the cylinder pressure and brake pad clearance based on the aerodynamic equation and tribological model; the auxiliary power supply system independent twin unit updates the voltage and current harmonics based on the power electronic converter topology and harmonic analysis model; and the running gear independent twin unit updates the axle box vibration and wheel-rail force based on the multibody dynamics equation and wheel-rail contact mechanics model. The independent twin units transmit the updated state variables back to the fault tree engine via the data distribution service channel. The fault tree engine performs multi-hop propagation along the causal relationship edges, calculating the fault propagation strength at each path along the causal relationship edge. ,in For the source node offset of the state variable For causal relationship The propagation weight (initial value is 0.5, and can be updated in the closed-loop iteration based on the results of the new round of Granger causality test). For the target node The standard deviation of state variables in normal mode. When the fault propagation strength exceeds the preset propagation threshold of the causal relationship edge, it is marked as an abnormal causal relationship, and downstream independent twin units are recursively activated to continue applying perturbation biases. The recursive activation process continues until the top node of the fault tree or the propagation depth reaches a limited level, which is set to five levels. The state variables and fault labels of all independent twin units marked with abnormal causal relationships are summarized, and the fault mechanism constraint set is output.

[0027] Step S2: Using the fault mechanism constraint set as a supervision signal, perform class-balanced weighted training on each vehicle depot client using the federated incremental learning framework. The server generates a global diagnostic model through federated aggregation. In the initial learning stage, the model is weighted and averaged according to the proportion of the number of samples. In the incremental learning stage, the model is dynamically weighted and aggregated according to the diagnostic accuracy of each client, and transferable fault feature representations are extracted.

[0028] In this embodiment, each depot client first reads sample data carrying fault labels from the fault mechanism constraint set. Each sample contains state variables of multiple physically independent twin units and corresponding fault category labels. To address the problem of uneven fault category distribution, a class-balanced weighted loss function is constructed. This loss function adopts a weighted cross-entropy form based on class frequency. For each sample, its weight is inversely proportional to the frequency of the class to which the sample belongs in the training set, specifically expressed as:

[0029] in This represents the total number of fault categories. The first one-hot encoding of the real label Quantity, The first output of the model kind Probability, weight , The total number of samples, For the first The number of samples per class. Each depot client uses the class-balanced weighted loss function to perform initial training on the local model. The local model employs a multi-layer convolutional neural network structure, containing three convolutional layers and three fully connected layers. The kernel size of the first convolutional layer is [missing information]. The number of channels is 32, and the kernel size of the second convolutional layer is [missing information]. The number of channels is 64, and the kernel size of the third convolutional layer is [missing information]. The number of channels is 128, and each convolutional layer is followed by a batch normalization layer and... Activate the function and add a max pooling layer with a pooling window size of [size missing]. The step size is 2. The number of neurons in the three fully connected layers are 256, 128, and... The output dimension of the last fully connected layer is equal to the total number of fault categories. ,use The activation function yields the class probability distribution. The optimizer is selected. The initial learning rate was set to 0.001, and the batch size was set to 64. After each round of initial training, 20 reference samples for each class were randomly selected from the training samples and saved as old class reference samples in the old reference sample storage for relation consistency distillation in the subsequent incremental learning phase. The server collected the local model parameters trained by all clients and aggregated them using a federated averaging algorithm, that is, it calculated a weighted average of the model parameters of each client according to the proportion of the number of samples to obtain the global model in the initial learning phase.

[0030] After the initial learning phase, the incremental learning phase begins. In the incremental learning phase, a class-balanced weighted loss function is fused with a relation consistency distillation term. The relation consistency distillation term measures the difference in output distribution between the current local model and the previous optimal global model on the samples stored in the old reference sample memory. The divergence is calculated, and the relational consistency distillation term is expressed as:

[0031] in The optimal global model in the previous stage is based on the old reference samples. On Output, temperature parameters Used to soften the output distribution, i.e. , ;in The optimal global model of the previous stage is based on the old class reference samples. Output The One portion, For the current local model in the same sample Output The There are several components. The fused local loss function is:

[0032] Balance coefficient Each client performs incremental training using the fused loss function, with each incremental training iteration containing 5... The learning rate decays to 0.0005, and the optimizer still uses... The batch size is kept at 64. After incremental training is completed, each client uploads its local model parameters to the server.

[0033] After receiving the local model parameters uploaded by each client, the server adaptively calculates the aggregation weight based on the diagnostic accuracy of each depot client in the current fault category. Specifically, for each client... Calculate its average diagnostic accuracy across all fault categories. That is, the number of correctly classified samples divided by the total number of samples. Then through Function normalization yields aggregate weights:

[0034] in Total number of clients, temperature coefficient The server aggregates the model parameters from each client using a dynamic weighted federated average strategy. The aggregated global model parameters are as follows:

[0035] in For the client The local model parameters are then calculated. After aggregation, the server uses the dynamically weighted aggregation-derived global model as the optimal global model for this stage and saves its parameters. This optimal global model also serves as the old model referenced for the relationship consistency distillation in the next incremental stage. The hidden state of the penultimate fully connected layer is extracted from this optimal global model as a transferable fault feature representation. This hidden state has 128 dimensions and is used for causal strength quantification analysis in subsequent steps. The entire federated incremental learning process is repeated until all incremental tasks are completed, and the final generated global diagnostic model has generalized diagnostic capabilities across vehicle segments and fault types.

[0036] Step S3: Input the fault feature representation and the virtual-real mapping relationship into the causal intensity quantification model, calculate the causal intensity score of the potential root cause on the fault feature, and output the root cause contribution.

[0037] In this embodiment, the causal strength quantification model uses independent twin units defined by the virtual-real mapping relationship as nodes, and uses the propagation relationship of cross-physical domain faults between independent twin units as causal relationship edges to construct a dynamic temporal causal graph. Each causal relationship edge carries a causal direction attribute and a propagation weight. The value ranges between 0 and 1, with an initial propagation weight set to 0.5, and can be updated in the closed-loop iteration based on the results of the next Granger test. The set of nodes in the dynamic temporal causal graph is denoted as... , The total number of independent twin units; the edge set is denoted as This indicates that the fault originated from the node. Transmission to nodes The causal relationship.

[0038] In this embodiment, the virtual-real mapping relationship is used to determine the graph structure; the time series of the state variables of each independent twin unit are used for Granger causality testing and node feature construction; the 128-dimensional fault feature representation is used as a graph-level global context vector, which is concatenated with the node hidden state in the final scoring stage.

[0039] (1) Determination of normal fluctuation range. For each independent twin unit's state variable time series in normal mode, a sliding window extraction of sub-time series was performed. The sliding window length was set to 100 time steps, and the sliding step size was set to 10 time steps, resulting in 50 sub-time series. A causal network was constructed using the sub-time series of normal mode, and the normal fluctuation range of each causal relationship edge was calculated using a method based on Granger causality test. For each edge... Establish an autoregressive model:

[0040] in For the target node At any moment The state variable value, and The target node and the source node are respectively in lag. The state variable value at time t. The constant intercept term, These are the autoregressive coefficients. represents the causal transmission coefficient of the source node features to the target node features. For the error term, This is the lag order, with a value of 5. (Passed...) Test and judgment Is it significantly non-zero? The statistic is defined as:

[0041] in For the constrained model (excluding) The sum of squared residuals of the terms. For the sum of squared residuals of the unrestricted model, Let be the length of the time series. Calculate the length of each edge under all normal sub-time series. mean of the statistic with standard deviation Normal fluctuation range is defined as .

[0042] (2) Abnormal causal relationship edges and causal strength scores under failure mode. The same sliding window extraction is performed on the time series of state variables under failure mode to obtain... The fault sub-time series. For the ... Each edge in the fault sub-time series Calculate its F-statistic ;like or If the edge is an abnormal causal relationship edge, its source node is determined to be an abnormal causal relationship edge. In the The causal strength score is obtained from each window:

[0043] node In the The causal strength score in each window is taken as the maximum value among all the anomalous edges of the source node, i.e. , It is the set of causal relationship edges in a dynamic temporal cause-effect graph. Indicates that by node Pointing to node The causal relationship edge represents the fault represented by independent twin units. Towards The causal relationship of conduction; For all Belongs to the edge set subscript Simultaneously set binary indicator parameters ,otherwise , A binary indicator parameter, used to characterize the first... In a causal network constructed from the time series of each failure mode, the nodes Whether it is determined to be an abnormal root cause node.

[0044] (3) Root cause reliability fusion. For all Each fault sub-time series is determined based on the number of anomaly edges in each sub-time series. Perform weighted fusion to obtain nodes The causal strength score after fusion:

[0045] in For the first The number of anomalous causal relationship edges in a fault sub-time series is represented by this formula, which indicates the number of anomalous edges as the weight of each node. The weighted frequency of the abnormal root causes is used as a component of the root cause score in the fusion result.

[0046] (4) Root cause probability scoring based on graph attention network. Node features are obtained by encoding the sub-time series of state variables of each independent twin unit under the fault mode. Given a dynamic temporal causal graph, a graph attention network is used to perform direction-aware multi-hop message passing along the causal edges. The graph attention network consists of two graph attention layers: the first layer has a hidden dimension of 64 and 4 multi-head attention heads; the second layer has a hidden dimension of 32 and 2 multi-head attention heads. Each layer employs... The activation function has a negative slope of 0.2. The direction-aware mechanism ensures that messages are passed only along the causal edges, i.e., only when... hour Only then are they considered nodes upstream neighbors ( For nodes (The set of upstream neighbors). The attention coefficient is:

[0047] in For nodes The input feature vector, It is a learnable linear transformation matrix. For attention vectors, This represents vector concatenation. For nodes The set of upstream neighbor nodes (i.e., the set of nodes with edges) (Nodes). The number of hops for multi-hop message passing is set to 2. In each hop, the node aggregates information from its upstream neighbors and propagates it according to the propagation weights of the causal edges. Weighting. To avoid disrupting normalization by directly multiplying the propagation weights and attention coefficients, the two are multiplied first, then re-normalized, and the node's own transformation term is added to update the hidden state:

[0048]

[0049] in For ELU activation function, To integrate the propagation weights and renormalize the attention coefficients, satisfying , This is a self-loop term used to preserve the node's own characteristics. After two layers of propagation, each node obtains its final hidden state. The hidden state is concatenated with the graph-level global context vector formed by the 128-dimensional fault feature representation. This concatenation is then input into a single-layer fully connected network, resulting in an output dimension of 1. Activation function yields root cause probability scores .

[0050] (5) Root cause contribution output. Based on the root cause probability score of each node in the dynamic temporal causal graph. ,Will The nodes are marked as candidate root cause nodes. The state variable offsets of the independent twin units corresponding to each candidate root cause node in the fault mode are obtained. ,in Nodes in fault mode The mean of the state variable. This is the mean value under normal conditions. For nodes In normal mode, the standard deviation of the state variable time series and the normal fluctuation range are determined by the mean and standard deviation of the state variable at that node in normal mode, i.e. To eliminate dimensional differences, the degree of abnormal deviation is normalized as follows:

[0051] The root cause score of a candidate root cause node is determined by a weighted sum of the root cause probability score, the normalized outlier deviation, and the fused causal strength score.

[0052] The independent twin unit corresponding to the node with the highest root cause score among all candidate root cause nodes is identified as the root cause of the fault, and the root cause score of this root cause is output as the root cause contribution. The root cause contribution includes the fault root cause parameter name and the root cause score. The independent twin unit number corresponding to this node and its fusion causality strength score. .

[0053] Step S4: Feed back the root cause contribution and fault mechanism constraint set to the virtual and real fault simulation end, drive the digital twin to perform a new round of fault injection for cross-physical domain faults, and feed back the samples with fault labels generated by each round of fault injection to the federated incremental learning framework to update the global diagnostic model, forming a closed-loop iteration of fault simulation and root cause localization.

[0054] In this embodiment, the root cause contribution and the fault mechanism constraint set are fed back to the virtual-real fault simulation terminal. After receiving the root cause contribution, the virtual-real fault simulation terminal uses a digital twin to monitor the changes in the state variables of each independent twin unit in real time. When the state variable of any independent twin unit deviates from the normal fluctuation range by more than three standard deviations, an anomaly trigger signal is triggered. After capturing the anomaly trigger signal, the digital twin traces back along the causal relationship edges recorded by the fault tree engine to track the propagation trajectory of the anomaly trigger signal among the independent twin units, constructing an event deconstruction chain that includes the anomaly source location, the level of the affected independent twin unit, and the fault propagation intensity.

[0055] The digital twin performs a new round of fault injection for cross-physical domain faults based on the event deconstruction chain, performs multi-hop propagation along the causal relationship edges and calculates the fault propagation strength of each path of the causal relationship edge; the fault feature representation generated by the new round of fault injection is re-input into the causal strength quantification model, calculates the causal strength score of the potential root cause to the fault feature, and outputs the updated root cause contribution; the updated root cause contribution and the fault mechanism constraint set are fed back to the virtual and real fault simulation end again, driving the digital twin to perform the next round of fault injection for cross-physical domain faults.

[0056] Simultaneously, the samples carrying fault labels generated in each round of fault injection are fed back to the federated incremental learning framework as new incremental tasks to perform incremental training on the local models of each vehicle segment client. The server then dynamically re-weights and aggregates these samples to update the global diagnostic model and fault feature representation. The iteration continues until the change in root cause contribution between two adjacent rounds is less than a preset threshold or the maximum number of iterations is reached, forming a closed-loop iteration of fault simulation and root cause localization. Furthermore, based on the abnormal causal relationships marked in the new round of fault injection, the fault mechanism constraint set is updated as the basis for the next round of fault injection.

[0057] The iteration terminates when either of the following conditions is met: the change in the root cause score corresponding to the fault root cause parameter is less than a preset threshold of 0.05 in two adjacent rounds of root cause contribution, or the number of closed-loop iteration rounds reaches the maximum number of iteration rounds of 10. The iteration terminates when either of the above conditions is met, and the final fault root cause parameter and root cause contribution are output.

[0058] Example 2: This invention provides a virtual-real integrated urban rail train fault simulation and intelligent assessment system, comprising: The digital twin construction module constructs a multi-physical domain digital twin of an urban rail train. It maps real-vehicle operation data of traction, braking, auxiliary power supply, and running gear to the digital twin through a data distribution service channel, forming a virtual-real mapping relationship. Based on the fault knowledge base, cross-physical domain faults are injected into the digital twin to obtain a fault mechanism constraint set with fault labels. The federated incremental learning module uses the fault mechanism constraint set as a supervision signal and performs class-balanced weighted training on each vehicle depot client using the federated incremental learning framework. The server generates a global diagnostic model through federated aggregation. In the initial learning stage, the model is weighted and averaged according to the sample size ratio. In the incremental learning stage, the model is dynamically weighted and aggregated according to the diagnostic accuracy of each client and the transferable fault feature representation is extracted. The causal intensity quantification module inputs the fault feature representation and the virtual-real mapping relationship into the causal intensity quantification model, calculates the causal intensity score of the potential root cause to the fault feature, and outputs the root cause contribution. The closed-loop iteration module feeds back the root cause contribution and fault mechanism constraint set to the virtual and real fault simulation end, driving the digital twin to perform a new round of fault injection for cross-physical domain faults, and feeds back the samples with fault labels generated by each round of fault injection to the federated incremental learning framework to update the global diagnostic model, forming a closed-loop iteration of fault simulation and root cause localization.

[0059] Obviously, those skilled in the art can make various modifications and variations to this invention without departing from its spirit and scope. Therefore, if these modifications and variations fall within the scope of the claims of this invention and their equivalents, this invention also intends to include these modifications and variations.

Claims

1. A method for simulating and intelligently evaluating urban rail train faults by combining virtual and real methods, characterized in that, The method includes: Step S1: Construct a multi-physical domain digital twin of the urban rail train. Map the actual vehicle operation data of traction, braking, auxiliary power supply and running gear to the digital twin through the data distribution service channel to form a virtual-physical mapping relationship. Based on the fault knowledge base, inject cross-physical domain faults into the digital twin to obtain a fault mechanism constraint set with fault labels. Step S2: Using the fault mechanism constraint set as a supervision signal, perform class-balanced weighted training on each vehicle depot client using the federated incremental learning framework. The server generates a global diagnostic model through federated aggregation. In the initial learning stage, the model is weighted and averaged according to the proportion of the number of samples. In the incremental learning stage, the model is dynamically weighted and aggregated according to the diagnostic accuracy of each client, and transferable fault feature representations are extracted. Step S3: Input the fault feature representation and the virtual-real mapping relationship into the causal strength quantification model, calculate the causal strength score of the potential root cause to the fault feature, and output the root cause contribution. Step S4: Feed back the root cause contribution and fault mechanism constraint set to the virtual and real fault simulation end, drive the digital twin to perform a new round of fault injection for cross-physical domain faults, and feed back the samples with fault labels generated by each round of fault injection to the federated incremental learning framework to update the global diagnostic model, forming a closed-loop iteration of fault simulation and root cause localization.

2. The method for simulating and intelligently evaluating urban rail train faults using a combination of virtual and real methods as described in claim 1, characterized in that, The process of constructing the multi-physical domain digital twin of the urban rail train in step S1 includes: The motor torque and rectifier-inverter electrical quantities of the traction system, the cylinder pressure and brake pad gap of the braking system, the voltage and current harmonics of the auxiliary power supply system, and the axle box vibration and wheel-rail force of the running gear are each abstracted into independent twin units. Each independent twin unit subscribes to real-vehicle operation data topics through the data distribution service channel and performs spatiotemporal alignment based on timestamps and vehicle identifiers; A cross-physical domain digital fault tree is constructed based on a fault knowledge base. The top-level nodes of the fault tree represent subsystem-level fault modes, the intermediate nodes represent the energy transfer and signal transmission relationships between physical domains, and the leaf nodes are bound to the corresponding independent twin unit state variables.

3. The method for simulating and intelligently evaluating urban rail train faults using a combination of virtual and real methods as described in claim 2, characterized in that... The injection of cross-physical domain faults includes: Based on the fault modes defined in the fault knowledge base, a perturbation bias is applied at the corresponding leaf node of the fault tree and published to the bound independent twin unit in the form of a message through the data distribution service channel. The independent twin unit updates its internal state variables according to the physical domain dynamics equations and sends the updated state variables back to the fault tree engine via the data distribution service channel; The fault tree engine performs multi-hop propagation along the causal relationship edge, calculates the fault propagation strength of each causal relationship edge, and marks it as an abnormal causal relationship when the fault propagation strength exceeds the preset propagation threshold of the causal relationship edge, and recursively activates the downstream independent twin unit to continue to apply the perturbation bias. The recursive activation process continues until the top node of the fault tree or the propagation depth reaches the limit level. It summarizes the state variables of all independent twin units with marked abnormal causal relationships and their fault labels, and outputs the fault mechanism constraint set.

4. The method for simulating and intelligently evaluating urban rail train faults using a combination of virtual and real methods as described in claim 1, characterized in that, The process of extracting fault feature representations in step S2 includes: Each depot's client reads fault-labeled samples from the fault mechanism constraint set and constructs a category-balanced weighted loss function; Each depot client performs initial training on its local model using a class-balanced weighted loss function. After each round of initial training, reference samples of each class are randomly selected from the training samples and saved to the reference sample storage as old class reference samples for the subsequent incremental learning stage. The server collects the local models trained by each client, aggregates and updates them to obtain the global model for the initial learning stage. During the incremental learning phase, the category-balanced weighted loss function incorporates a relation consistency distillation term, which measures the difference in output distribution between the current local model and the previous optimal global model on the samples stored in the old reference sample memory. Each client performs incremental training using the fused loss function and uploads its local model parameters to the server. The server generates a global diagnostic model through dynamic weighted aggregation and extracts the penultimate hidden state as a fault feature representation.

5. The method for simulating and intelligently evaluating urban rail train faults using a combination of virtual and real methods as described in claim 4, characterized in that... The aggregation of the global diagnostic model includes: The server adaptively calculates the aggregation weight based on the diagnostic accuracy of each vehicle depot client in the current fault category, and aggregates the local model parameters uploaded by each client according to the dynamic weighted federated average strategy. After the initial learning phase, the incremental learning phase begins. The local loss function constructed in the incremental learning phase includes a category balancing weighting term and a relation consistency distillation term. The local loss function is used to collaboratively train the client models and aggregate them to the server. The server uses the dynamically weighted aggregated global model as the optimal global model for this phase.

6. The method for simulating and intelligently evaluating urban rail train faults using a combination of virtual and real methods as described in claim 1, characterized in that, The structure of the causal strength quantification model in step S3 includes: Using independent twin units defined by the virtual-real mapping relationship as nodes and the transmission relationship of cross-physical domain faults between independent twin units as causal relationship edges, a dynamic temporal causal graph is constructed, with each causal relationship edge carrying causal direction attributes and propagation weights. Sliding window extraction of sub-time series is performed on the state variable time series of each independent twin unit in normal mode, and the normal fluctuation range of each causal relationship edge is calculated using the causal network constructed from the sub-time series in normal mode. The state variable sub-time series and fault feature representation of each independent twin unit under the fault mode are input into the dynamic temporal causal graph. The multi-hop message passing is performed along the causal relationship edge by a graph attention network and weighted according to the propagation weight to calculate the root cause probability score of each node. The Granger causality test statistic of each causal relationship edge in the failure mode is compared with the normal fluctuation range of the same causal relationship edge in the normal mode. The source node corresponding to the causal relationship edge that exceeds the normal fluctuation range is given a causal strength score.

7. The method for simulating and intelligently evaluating urban rail train faults using a combination of virtual and real methods as described in claim 6, characterized in that, The fusion of the causal strength scores includes: Sliding window extraction is performed on the time series of state variables of each independent twin unit in normal mode and fault mode to extract sub-time series. The causal network constructed using the sub-time series in normal mode is used to calculate the normal fluctuation range of each causal relationship edge. For each causal network constructed from fault mode sub-time series, determine whether the causal strength of each causal relationship edge exceeds the normal fluctuation range, mark the abnormal causal relationships, and weight them according to the number of abnormal causal relationship edges in each sub-time series. Count the frequency of each node being judged as an abnormal root cause node, and obtain the fused causal strength score of each node. This fused causal strength score is used as a component of the root cause score in the calculation of the root cause score.

8. The method for simulating and intelligently evaluating urban rail train faults using a combination of virtual and real methods as described in claim 7, characterized in that, The root cause contribution output process includes: Based on the root cause probability score of each node in the dynamic temporal cause-effect graph, nodes whose root cause probability scores exceed the preset root cause probability score threshold are marked as candidate root cause nodes. Obtain the state variable offset of the independent twin unit corresponding to each candidate root cause node in the fault mode, compare the state variable offset with the normal fluctuation range of the candidate root cause node in the normal mode, and normalize the comparison result to obtain the normalized abnormal deviation degree. The root cause score of each candidate root cause node is determined by the weighted sum of the root cause probability score, the normalized degree of abnormal deviation, and the causal strength score after fusion. The independent twin unit corresponding to the node with the largest root cause score among all candidate root cause nodes is identified as the root cause of the fault, and the root cause score of the root cause is output as the root cause contribution.

9. The method for simulating and intelligently evaluating urban rail train faults using a combination of virtual and real methods as described in claim 1, characterized in that, The closed-loop iterative process of fault simulation and root cause localization in step S4 includes: The root cause contribution and fault mechanism constraint set are fed back to the virtual and real fault simulation end. The digital twin is used to capture the abnormal trigger signal, track the propagation trajectory of the abnormal trigger signal between each independent twin unit, and construct an event deconstruction chain that includes the location of the abnormal source, the hierarchy of the affected independent twin units, and the fault propagation intensity. The digital twin performs a new round of fault injection for cross-physical domain faults based on the event deconstruction chain, performs multi-hop propagation along the causal relationship edge, and calculates the fault propagation strength of each path through the causal relationship edge; The fault feature representation generated by the new round of fault injection is re-input into the causal strength quantification model, the causal strength score of the potential root cause to the fault feature is calculated, and the updated root cause contribution is output. The updated root cause contribution and fault mechanism constraint set are fed back to the virtual and real fault simulation end to drive the digital twin to perform the next round of fault injection for cross-physical domain faults. The samples with fault labels generated in each round of fault injection are fed back to the federated incremental learning framework. As a new incremental task, they are used to perform incremental training on the local models of each vehicle segment client. The server then dynamically re-weights and aggregates the samples to update the global diagnostic model and fault feature representation. The iteration continues until the change in the root cause contribution between two adjacent rounds is less than a preset threshold or the maximum number of iterations is reached, thus forming a closed-loop iteration of fault simulation and root cause localization. Based on the abnormal causal relationships marked in the new round of fault injection, update the fault mechanism constraint set as the basis for the next round of fault injection.

10. A virtual-real integrated urban rail train fault simulation and intelligent assessment system, characterized in that, The system is used to implement a virtual-real combined urban rail train fault simulation and intelligent assessment method as described in any one of claims 1 to 9, including: The digital twin construction module constructs a multi-physical domain digital twin of an urban rail train. It maps real-vehicle operation data of traction, braking, auxiliary power supply, and running gear to the digital twin through a data distribution service channel, forming a virtual-real mapping relationship. Based on the fault knowledge base, cross-physical domain faults are injected into the digital twin to obtain a fault mechanism constraint set with fault labels. The federated incremental learning module uses the fault mechanism constraint set as a supervision signal and performs class-balanced weighted training on each vehicle depot client using the federated incremental learning framework. The server generates a global diagnostic model through federated aggregation. In the initial learning stage, the model is weighted and averaged according to the sample size ratio. In the incremental learning stage, the model is dynamically weighted and aggregated according to the diagnostic accuracy of each client and the transferable fault feature representation is extracted. The causal intensity quantification module inputs the fault feature representation and the virtual-real mapping relationship into the causal intensity quantification model, calculates the causal intensity score of the potential root cause to the fault feature, and outputs the root cause contribution. The closed-loop iteration module feeds back the root cause contribution and fault mechanism constraint set to the virtual and real fault simulation end, driving the digital twin to perform a new round of fault injection for cross-physical domain faults, and feeds back the samples with fault labels generated by each round of fault injection to the federated incremental learning framework to update the global diagnostic model, forming a closed-loop iteration of fault simulation and root cause localization.

Images