Cascade failure prediction and self-healing method and device for edge computing system
By combining causal graph neural networks and digital twin models with a multi-agent collaborative self-healing module, the problem of low accuracy in predicting cascading failures in edge computing systems is solved, achieving proactive self-healing and improved system reliability.
Patent Information
- Application Number
- CN202511331156.2
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Filing Date
- 2025-09-17
- Publication Date
- 2025-12-05
AI Technical Summary
Edge computing systems have low accuracy in predicting cascading failures, and the passive defense strategy leads to low system reliability.
By using a pre-trained causal graph neural network model, state change prediction data and a pre-set causal graph are used to determine cascading failure paths and confidence levels, generate processing strategies to achieve self-healing, and combine a digital twin model and a multi-agent collaborative self-healing module for proactive defense.
It significantly improves the accuracy of cascading failure prediction, enables early warning, and enhances system robustness and reliability through proactive self-healing.
Smart Images

Figure CN121077876A_ABST
Abstract
Description
TECHNICAL FIELD
[0001] The present application relates to the field of edge computing, in particular, to a cascading failure prediction and self-healing method and device of an edge computing system. BACKGROUND
[0002] The cascading failure of the edge computing system refers to a phenomenon that when a node fails, the failure is propagated through the interdependence relationship in the system, causing a series of normally running nodes to fail in succession. The related art mainly has the following limitations in dealing with the cascading failure of the edge computing system: the prediction model is mainly based on data correlation analysis, resulting in insufficient prediction accuracy; the passive defense strategy is used for post-reaction, which can only repair after the failure occurs, resulting in low system reliability.
[0003] In view of the problems of low prediction accuracy of the cascading failure of the edge computing system in the related art and low system reliability caused by the passive defense strategy, no effective solution has been proposed so far. SUMMARY
[0004] The main purpose of the present application is to provide a cascading failure prediction and self-healing method and device of an edge computing system, to solve the problems of low prediction accuracy of the cascading failure of the edge computing system in the related art and low system reliability caused by the passive defense strategy.
[0005] In order to achieve the above-mentioned purpose, according to one aspect of the present application, a cascading failure prediction and self-healing method of an edge computing system is provided. The method comprises: in the case of detecting state change prediction data of a target edge computing node of the edge computing system, determining a prediction result corresponding to the target edge computing node by a pre-trained causal graph neural network model according to the state change prediction data and a preset causal graph, wherein the state change prediction data is used to represent the future state change of the target edge computing node, the preset causal graph is used to represent the causal relationship between the edge computing nodes in the edge computing system, and the prediction result at least includes a cascading failure path associated with the target edge computing node and a confidence of the cascading failure path; determining a target processing strategy according to the prediction result, and executing the target processing strategy to realize the cascading failure self-healing of the edge computing system.
[0006] Further, the determining, by the pre-trained causal graph neural network model according to the state change prediction data and the preset causal graph, of the prediction result corresponding to the target edge computing node comprises: performing encoding processing on the state change prediction data by the causal graph neural network model to obtain encoded data; determining, according to the encoded data and the preset causal graph, an influence degree of the target edge computing node on a neighboring node of the target edge computing node, and determining, according to the influence degree and the preset causal graph, a cascading failure path; determining a confidence degree of the cascading failure path based on a preset algorithm, and determining the prediction result according to the cascading failure path and the confidence degree of the cascading failure path.
[0007] Further, the determining, by the pre-trained causal graph neural network model according to the state change prediction data and the preset causal graph, of the prediction result corresponding to the target edge computing node comprises: performing encoding processing on the state change prediction data by the causal graph neural network model to obtain encoded data; determining, according to the encoded data and the preset causal graph, an influence degree of the target edge computing node on a neighboring node of the target edge computing node, and determining, according to the influence degree and the preset causal graph, a cascading failure path; determining a confidence degree of the cascading failure path based on a preset algorithm, and determining the prediction result according to the cascading failure path and the confidence degree of the cascading failure path.
[0008] Further, before detecting the state change prediction data of the target edge computing node of the edge computing system, the method further comprises: acquiring, by the target edge computing node, multi-source heterogeneous state data of the target edge computing node, and constructing an initial state tensor according to the multi-source heterogeneous state data; performing compression processing on the initial state tensor to obtain a compressed state tensor, and constructing a digital twin model of the target edge computing node according to the compressed state tensor; and predicting, by the digital twin model, a state change of the target edge computing node to obtain the state change prediction data.
[0009] Further, after obtaining the state change prediction data, the method further comprises: evaluating, by the target edge computing node, the state change prediction data to obtain an evaluation result, wherein the evaluation result is used to represent an importance degree of the state change prediction data; comparing the evaluation result with a preset threshold value, and if the evaluation result is greater than the preset threshold value, forwarding, by the target edge computing node, the state change prediction data to a neighboring node of the target edge computing node.
[0010] Further, the causal graph neural network model is obtained by the following steps: acquiring a training sample set, wherein the training sample set comprises historical state data of a plurality of edge computing nodes; constructing an initial causal graph neural network model according to a preset causal graph, and training the initial causal graph neural network model according to the training sample set until a predetermined training target is reached to obtain the causal graph neural network model.
[0011] Further, the preset causal graph is obtained by the following steps: determining a constraint condition according to the target domain knowledge information of the edge computing system, constructing a target optimization function according to the constraint condition, solving the target optimization function by using a preset solving algorithm, and obtaining an initial causal adjacency matrix, wherein the target optimization function is used to determine the causal relationship between the edge computing nodes in the edge computing system; performing time sequence expansion on the initial causal adjacency matrix to obtain a time-varying causal adjacency matrix, and determining the preset causal graph according to the time-varying causal adjacency matrix.
[0012] To achieve the above-mentioned purpose, according to another aspect of the present application, a cascade failure prediction and self-healing device of an edge computing system is provided. The device comprises: a first determination unit configured to, in a case where state change prediction data of a target edge computing node of the edge computing system is detected, determine a prediction result corresponding to the target edge computing node by a pre-trained causal graph neural network model according to the state change prediction data and a preset causal graph, wherein the state change prediction data is used to represent a future state change of the target edge computing node, the preset causal graph is used to represent a causal relationship between edge computing nodes in the edge computing system, and the prediction result at least includes a cascade failure path associated with the target edge computing node and a confidence of the cascade failure path; and a first processing unit configured to determine a target processing strategy according to the prediction result, and execute the target processing strategy to realize cascade failure self-healing of the edge computing system.
[0013] Further, the first determination unit comprises: a first processing subunit configured to perform encoding processing on the state change prediction data by the causal graph neural network model to obtain encoded data; a first determination subunit configured to determine an influence degree of the target edge computing node on a neighboring node of the target edge computing node according to the encoded data and the preset causal graph, and determine the cascade failure path according to the influence degree and the preset causal graph; and a second determination subunit configured to determine the confidence of the cascade failure path based on a preset algorithm, and determine the prediction result according to the cascade failure path and the confidence of the cascade failure path.
[0014] Further, the first processing unit comprises: a third determination subunit configured to determine a plurality of intervention nodes from the edge computing nodes included in the cascade failure path according to the cascade failure path and the confidence of the cascade failure path; and a fourth determination subunit configured to determine an intervention strategy corresponding to each intervention node and a strategy execution order, and compose the target processing strategy according to the intervention strategy corresponding to each intervention node and the strategy execution order.
[0015] Further, the apparatus further comprises: a first obtaining unit, configured to obtain, before detecting the state change prediction data of the target edge computing node of the edge computing system, multi-source heterogeneous state data of the target edge computing node through the target edge computing node, and construct an initial state tensor according to the multi-source heterogeneous state data; a second processing unit, configured to perform compression processing on the initial state tensor to obtain a compressed state tensor, and construct a digital twin model of the target edge computing node according to the compressed state tensor; and a third processing unit, configured to predict the state change of the target edge computing node through the digital twin model to obtain the state change prediction data.
[0016] Further, the apparatus further comprises: a fourth processing unit, configured to evaluate the state change prediction data through the target edge computing node after obtaining the state change prediction data to obtain an evaluation result, wherein the evaluation result is used to represent the importance of the state change prediction data; and a fifth processing unit, configured to compare the evaluation result with a preset threshold value, and if the evaluation result is greater than the preset threshold value, forward the state change prediction data to a neighboring node of the target edge computing node through the target edge computing node.
[0017] Further, the apparatus further comprises the following units for obtaining the causal graph neural network model through the following steps: a second obtaining unit, configured to obtain a training sample set, wherein the training sample set comprises historical state data of a plurality of edge computing nodes; and a sixth processing unit, configured to construct an initial causal graph neural network model according to a preset causal graph, and train the initial causal graph neural network model according to the training sample set until a predetermined training target is reached to obtain the causal graph neural network model.
[0018] Further, the apparatus further comprises the following units for obtaining the preset causal graph through the following steps: a seventh processing unit, configured to determine a constraint condition according to target domain knowledge information of the edge computing system, construct a target optimization function according to the constraint condition, and solve the target optimization function by using a preset solving algorithm to obtain an initial causal adjacency matrix, wherein the target optimization function is used to determine the causal relationship between the edge computing nodes in the edge computing system; and an eighth processing unit, configured to perform time sequence expansion on the initial causal adjacency matrix to obtain a time-varying causal adjacency matrix, and determine the preset causal graph according to the time-varying causal adjacency matrix.
[0019] According to another aspect of the embodiments of the present application, an electronic device is also provided, comprising: a memory storing an executable program; and a processor configured to run the program, wherein the program performs the cascade failure prediction and self-healing method of the edge computing system according to any one of the above aspects when running.
[0020] According to another aspect of the embodiments of the present application, a computer readable storage medium is also provided, which stores a program, wherein the program controls a device where the storage medium is located to perform the cascade failure prediction and self-healing method of the edge computing system according to any one of the above aspects when the program is running.
[0021] In the embodiments of the present application, the following steps are adopted: in a case where state change prediction data of a target edge computing node of the edge computing system is detected, a pre-trained causal graph neural network model is used to determine a prediction result corresponding to the target edge computing node according to the state change prediction data and a preset causal graph, wherein the state change prediction data is used to represent a future state change of the target edge computing node, the preset causal graph is used to represent a causal relationship between edge computing nodes in the edge computing system, and the prediction result at least includes a cascade failure path associated with the target edge computing node and a confidence degree of the cascade failure path; a target processing strategy is determined according to the prediction result, and the target processing strategy is executed to realize the cascade failure self-healing of the edge computing system. The technical problem that the cascade failure prediction accuracy of the edge computing system is low and the system reliability is low due to the passive defense strategy in the related art is solved. In the present solution, the prediction accuracy can be significantly improved by fusing causal reasoning and graph neural networks, early warning of the cascade failure is realized, an intervention strategy is generated by combining dynamic risk prediction, active self-healing is realized, the system robustness is enhanced, and the system reliability is improved. BRIEF DESCRIPTION OF DRAWINGS
[0022] The accompanying drawings, which form a part of the present application, are intended to provide further understanding of the present application, and the illustrative embodiments of the present application and their description serve the purpose of explaining the present application. The accompanying drawings should not be regarded as a limitation of the present application. In the accompanying drawings:
[0023] Figure 1 Fig. 1 shows a hardware structure block diagram of a computer terminal for implementing the cascade failure prediction and self-healing method of the edge computing system;
[0024] Figure 2 Fig. 2 is a flowchart of the cascade failure prediction and self-healing method of the edge computing system according to the embodiments of the present application;
[0025] Figure 3 Fig. 3 is an architecture schematic diagram of the cascade failure prediction and self-healing system of the edge computing system according to the embodiments of the present application;
[0026] Figure 4 Fig. 4 is a schematic diagram of the cascade failure prediction and self-healing device of the edge computing system according to the embodiments of the present application;
[0027] Figure 5 Fig. 5 is a structure block diagram of an electronic device according to the embodiments of the present application. DETAILED DESCRIPTION
[0028] In order to better understand the technical scheme of the present application, the technical scheme in the embodiments of the present application will be clearly and completely described below in conjunction with the drawings in the embodiments of the present application. Obviously, the described embodiments are only a part of the embodiments of the present application, rather than all the embodiments of the present application. Based on the embodiments in the present application, all other embodiments obtained by those skilled in the art without creative effort should fall within the scope of the present application.
[0029] It should be noted that the terms "first", "second" and the like in the description and claims of the present application and the above drawings are used to distinguish similar objects, and do not necessarily indicate a specific order or sequence. It should be understood that the data thus used can be interchanged under appropriate circumstances, so that the embodiments of the present application described herein can be implemented in an order other than that illustrated or described herein. In addition, the terms "include" and "have" and any variations thereof are intended to cover non-exclusive inclusion, for example, a process, method, system, product or device including a series of steps or units need not be limited to those steps or units clearly listed, but can include other steps or units not clearly listed or inherent to these processes, methods, products or devices.
[0030] It should be noted that the collected information (including but not limited to user equipment information, user personal information, etc.) and data (including but not limited to data for display, analyzed data, etc.) involved in the present application are information and data authorized by the user or authorized by all parties, and the collection, storage, use, processing, transmission, provision, disclosure and application of related data comply with relevant laws, regulations and standards, necessary security measures are taken, do not violate public order and good customs, and provide corresponding operation portal for user to choose authorization or refusal. For example, the system and related users or institutions are provided with an interface to provide the user with a corresponding operation portal for the user to choose to agree or refuse the automatic decision result; if the user chooses to refuse, the expert decision process is entered.
[0031] Embodiment 1
[0032] According to the embodiments of the present application, a method embodiment of cascade failure prediction and self-healing of an edge computing system is also provided. It should be noted that the steps shown in the flowchart of the drawings can be executed in a computer system such as a set of computer executable instructions, and although a logical order is shown in the flowchart, in some cases, the steps shown or described herein can be executed in an order different from that shown herein.
[0033] The method embodiment provided by the embodiment of the present application can be executed in a mobile terminal, a computer terminal or a similar computing device. Figure 1A hardware structure block diagram of a computer terminal (or mobile device) for implementing a cascading failure prediction and self-healing method of an edge computing system is shown. As shown in Figure 1 The computer terminal 10 (or mobile device) can include one or more processors 102 (the processor 102 can include, but is not limited to, a microprocessor MCU or a programmable logic device FPGA processing device), a memory 104 for storing data, and a transmission device 106 for communication functions. In addition, it can also include a display, an input / output interface (I / O interface), a universal serial bus (USB) port (which can be included as one of the ports of the BUS bus), a network interface, a power supply and / or a camera. Those skilled in the art can understand that Figure 1 The structure shown is only schematic, which does not limit the structure of the above-mentioned electronic device. For example, the computer terminal 10 can include more or less components than those shown in Figure 1 or have a different configuration than that shown in Figure 1 .
[0034] It should be noted that the one or more processors 102 and / or other data processing circuits described above can be referred to herein as "data processing circuits" in general. The data processing circuit can be embodied in whole or in part as software, hardware, firmware or any combination thereof. In addition, the data processing circuit can be a single independent processing module, or any one of the other elements combined into the computer terminal 10 (or mobile device) in whole or in part. As referred to in the embodiments of the present application, the data processing circuit serves as a processor control (for example, selection of a variable resistance terminal path connected to an interface).
[0035] The memory 104 can be used to store software programs and modules of application software, such as program instructions / data storage devices corresponding to the cascading failure prediction and self-healing method of the edge computing system in the embodiments of the present application. The processor 102 executes various functional applications and data processing by running the software programs and modules stored in the memory 104, that is, implements the cascading failure prediction and self-healing method of the edge computing system described above. The memory 104 can include a high-speed random access memory, and can also include a non-volatile memory such as one or more magnetic storage devices, flash memory, or other non-volatile solid state memory. In some examples, the memory 104 can further include a memory remotely disposed with respect to the processor 102, which can be connected to the computer terminal 10 through a network. Examples of the above-mentioned network include, but are not limited to, the Internet, an intranet, a local area network, a mobile communication network and a combination thereof.
[0036] The transmission device 106 is configured to receive or send data via a network. The network can include a wireless network provided by a communication provider of the computer terminal 10. In one example, the transmission device 106 includes a network interface controller (NIC) that can connect to other network devices through a base station to communicate with the Internet. In one example, the transmission device 106 can be a radio frequency (RF) module that is configured to communicate with the Internet wirelessly.
[0037] The display can be a touch screen liquid crystal display (LCD) that enables a user to interact with the user interface of the computer terminal 10 (or mobile device).
[0038] In the above operating environment, the present application provides a cascading failure prediction and self-healing method for an edge computing system as shown in Figure 2 Figure 2 is a flowchart of a cascading failure prediction and self-healing method for an edge computing system according to an embodiment of the present application. The cascading failure prediction and self-healing method for the edge computing system includes:
[0039] In step S201, when state change prediction data of a target edge computing node of the edge computing system is detected, a pre-trained causal graph neural network model is used to determine a prediction result corresponding to the target edge computing node based on the state change prediction data and a preset causal graph, wherein the state change prediction data is used to represent a future state change of the target edge computing node, the preset causal graph is used to represent a causal relationship between edge computing nodes in the edge computing system, and the prediction result includes at least a cascading failure path associated with the target edge computing node and a confidence level of the cascading failure path.
[0040] Optionally, the target edge computing node can be any edge computing node in the edge computing system. For example, the edge computing node predicts the state change prediction data through a behavior prediction model of a digital twin model maintained by the edge computing node, and determines to perform state synchronization with a neighbor node after synchronization. The cascading failure prediction and self-healing system of the edge computing system detects the synchronization information, and determines the prediction result corresponding to the target edge computing node through the pre-trained causal graph neural network model based on the state change prediction data and the preset causal graph.
[0041] Optionally, in the cascading failure prediction and self-healing method for edge computing systems provided in this application embodiment, determining the prediction result corresponding to the target edge computing node based on state change prediction data and a preset causal graph using a pre-trained causal graph neural network model includes: encoding the state change prediction data using the causal graph neural network model to obtain encoded data; determining the degree of influence of the target edge computing node on its neighboring nodes based on the encoded data and the preset causal graph, and determining the cascading failure path based on the degree of influence and the preset causal graph; determining the confidence level of the cascading failure path based on a preset algorithm, and determining the prediction result based on the cascading failure path and the confidence level of the cascading failure path.
[0042] In an optional embodiment, the state change prediction data is encoded using a causal graph neural network model to obtain encoded data. For example, firstly, time encoding is performed using positional encoding technology to embed time information into node features. Then, based on the encoded data and a preset causal graph, the influence of the target edge computing node on its neighboring nodes is determined. Based on the influence and the preset causal graph, cascading failure paths are determined. Then, the confidence level of the cascading failure paths is determined based on a preset algorithm (such as the Monte Carlo dropout algorithm), and the prediction result is determined based on the cascading failure paths and their confidence levels. Specific embodiments are described below, but will not be elaborated upon here.
[0043] In an alternative embodiment, Figure 3 This is a schematic diagram of the architecture of a cascaded failure prediction and self-healing system for an edge computing system provided in an embodiment of this application, as shown below. Figure 3 As shown, it includes a distributed data acquisition and twin modeling module, a causal graph structure learning and construction module, a causal graph neural network prediction module, and a multi-agent collaborative self-healing module. These will be described in detail below with reference to specific embodiments, and will not be elaborated here.
[0044] Step S202: Determine the target processing strategy based on the prediction results and execute the target processing strategy to achieve cascading failure self-healing of the edge computing system.
[0045] Optionally, a multi-agent collaborative self-healing module determines the target processing strategy based on the prediction results and executes the target processing strategy to achieve cascading failure self-healing of the edge computing system. Specifically, a hierarchical multi-agent reinforcement learning framework is adopted, dividing the agents into the following three layers:
[0046] Regional Coordinating Agent (RCA): Responsible for macro-level strategy formulation and inter-regional coordination;
[0047] Node Control Agent (NCA): Responsible for the specific control decisions of a single node;
[0048] Service Migration Agent (SMA): responsible for service and task migration decision.
[0049] Optionally, the state space is designed as follows:
[0050] RCA state space: S R = {G causal , R global , L region , C inter}, respectively, the causal graph structure, global risk assessment, regional load, and inter-regional communication state;
[0051] NCA state space: S N = {S local , R local , N nbr , P policy}, respectively, the local state, local risk assessment, neighbor state, and upper-level policy guidance;
[0052] SMA state space: S M = {T info , H avail , N state , P constr}, respectively, task information, available hosts, network state, and policy constraints.
[0053] Optionally, the action space is designed as follows:
[0054] RCA action space: A R = {P region , R alloc , C coord}, respectively, regional defense policy, resource allocation policy, and coordination signal;
[0055] NCA action space: A N = {M isol , R adj , L reconf , S degrade}, respectively, isolation mode, resource adjustment, link reconstruction, and service degradation;
[0056] SMA action space: A M = {H select , P sched , B alloc , C check}, respectively, host selection, priority scheduling, bandwidth allocation, and consistency check.
[0057] Optionally, a hierarchical reinforcement learning framework is adopted, with the upper-level policy guiding the lower-level execution, represented as follows:
[0058]
[0059] wherein π R , π N , π M are the strategies of RCA, NCA and SMA, respectively, r R , r N , r M are the corresponding reward functions, γ is the discount factor, and τ is the trajectory. s t denotes the state of the environment perceived by the agent at time step t, which is a set containing all the information needed for decision making. For RCA, s t is S R ; for NCA, s t is S N ; for SMA, s t is S M . a t denotes the action selected by the agent at time step t according to the current state s t . For RCA, a t is A R , which can be a resource allocation strategy or a coordination signal; for NCA, a t is A N , which can be a specific operation such as performing isolation or adjusting resources; for SMA, a t is A M , which can be a specific operation such as host selection or priority scheduling. The expected return formula denotes that the agent pursues the expected value of all cumulative rewards along a trajectory τ from the initial state to the final state.
[0060] Optionally, a Shapley value-based credit assignment mechanism is used to accurately evaluate the contribution of each agent to the global goal. First, the global value function V(s) is decomposed into individual contributions, denoted as follows:
[0061]
[0062] wherein V(s) is the global value of state s, φ i (s) is the contribution of agent i. n denotes the total number of agents in the system.
[0063] Further, the Shapley value of each agent is calculated, denoted as follows:
[0064]
[0065] wherein N is the set of all agents, C is a subset of agents, and V(C, s) is the value that subset C can obtain at state s.
[0066] Optionally, the Monte Carlo sampling method is used to approximate the calculation:
[0067]
[0068] wherein, is the set of agents before agent i in the mth sampling. M is the total number of samplings.
[0069] Further, based on the Shapley value, an individual reward function r i (s,a) is designed as follows:
[0070] r i (s,a) = φ i (s) - φ i (s') + r local (s,a i )
[0071] wherein, s' is the next state after performing the action, r local (s,a i ) is a local reward item.
[0072] Optionally, based on the prediction results of the causal graph neural network, a defense strategy generation mechanism based on causal intervention is designed. First, intervention point identification is performed, and based on the causal graph structure and node risk score, the best intervention point is identified, which is represented as follows:
[0073]
[0074] wherein, I is the set of intervention nodes, k is the maximum number of interventions, and Risk(v|do(I)) is the risk score of node v after intervention on the node set I.
[0075] Further, for each intervention point, the intervention strategy is optimized, which is represented as follows:
[0076]
[0077] wherein, a i is the intervention action on node i, and A i is the set of actionable actions.
[0078] Further, multiple intervention strategies are combined into an overall defense strategy, which is represented as follows:
[0079]
[0080] Further, strategy execution scheduling is performed. Based on the causal dependence relationship, the topological sorting algorithm is used to determine the strategy execution order, which is represented as follows:
[0081] Order(π defense) = TopologicalSort(G causal ,I * )
[0082] Determine the optimal intervention point set I by topological sorting algorithm * The execution order of each node in the set, so that the intervention strategy can be executed in the order of causality. Ensure that the intervention measures of the upstream nodes are executed before the intervention measures of the downstream nodes, avoid intervention conflicts and improve intervention effect.
[0083] Optionally, through the cooperative communication and negotiation mechanism, effective collaboration between agents is realized. First, design a trust-based communication filtering mechanism, which is expressed as follows:
[0084] T ij (t) = a · T ij (t-1) + (1-a) · Q ij (t)
[0085] Where T ij (t) is the trust degree of agent i to agent j at time t, Q ij (t) is the current interaction quality, which can be a value between 0 and 1; a is a smoothing factor, used to control the influence degree of historical trust and current interaction quality on current trust. Only when T ij (t) > θ trust or the message priority is higher than the threshold value, the message from agent j is received. Where θ trust is the trust threshold.
[0086] Further, a conflict detection and resolution mechanism is designed to handle decision conflicts between agents, which is expressed as follows:
[0087]
[0088] Where Impact(a i ,a j ) quantifies the mutual influence between actions a i and a j . θ conflict is the impact threshold.
[0089] When a conflict is detected, it is resolved by the following rules:
[0090] Priority rule: the decision of high-priority agent is preferred;
[0091] Resource competition rule: allocate resources based on marginal benefit;
[0092] Negotiation rule: reach consensus through offer-accept mechanism.
[0093] Further, based on node status and network topology, dynamically assign agent roles, represented as follows:
[0094] Role(i) = arg max r∈R Score(i, r)
[0095] Where Score(i, r) is the fitness score of agent i assuming role r, considering node resources, location, and historical performance.
[0096] Optionally, the self-healing strategy library includes the following core strategies:
[0097] Task migration strategy: migrate tasks from high-risk nodes to low-risk nodes;
[0098] Resource reallocation strategy: dynamically adjust computing, storage, and network resource allocation;
[0099] Link reconstruction strategy: reconfigure network topology to isolate high-risk links;
[0100] Selective isolation strategy: temporarily isolate high-risk nodes to prevent fault propagation;
[0101] Service degradation strategy: provide degraded but usable services in resource-limited situations.
[0102] Optionally, parameterize each strategy to support fine-tuning, represented as follows:
[0103] π θ (s) = f π (s; θ)
[0104] Where θ is the strategy parameter, f π is the strategy function.
[0105] Optionally, design an execution monitoring mechanism to track the effectiveness of strategy execution in real time, represented as follows:
[0106]
[0107] Where Metric i (t) is the ith index value at time t, Target i is the target value, and w i is the weight.
[0108] Optionally, based on the execution monitoring results, adaptively adjust the strategy parameters, represented as follows:
[0109]
[0110] Where η is the learning rate, Performance(θ t ) is the strategy performance evaluation function.
[0111] Optionally, in the cascade failure prediction and self-healing method of the edge computing system provided in the embodiments of the present application, the determining the target processing strategy according to the prediction result comprises: determining a plurality of intervention nodes from the edge computing nodes contained in the cascade failure path according to the cascade failure path and the confidence of the cascade failure path; determining the intervention strategy corresponding to each intervention node and the strategy execution order, and composing the target processing strategy according to the intervention strategy corresponding to each intervention node and the strategy execution order.
[0112] In an optional embodiment, according to the aforementioned defense strategy generation mechanism based on causal intervention, a plurality of intervention nodes can be determined from the edge computing nodes contained in the cascade failure path according to the cascade failure path and the confidence of the cascade failure path, and then the intervention strategy corresponding to each intervention node and the strategy execution order are determined, and the target processing strategy is composed according to the intervention strategy corresponding to each intervention node and the strategy execution order, which will not be repeated here.
[0113] In summary, by fusing causal reasoning and graph neural networks, the prediction accuracy can be significantly improved, early warning of cascade failure can be realized, intervention strategies can be generated by combining dynamic risk prediction, active self-healing can be realized, system robustness is enhanced, and system reliability is improved.
[0114] Optionally, in the cascade failure prediction and self-healing method of the edge computing system provided in the embodiments of the present application, before detecting the state change prediction data of the target edge computing node of the edge computing system, the method further comprises: obtaining the multi-source heterogeneous state data of the target edge computing node through the target edge computing node, and constructing an initial state tensor according to the multi-source heterogeneous state data; compressing the initial state tensor to obtain a compressed state tensor, and constructing a digital twin model of the target edge computing node according to the compressed state tensor; predicting the state change of the target edge computing node through the digital twin model to obtain the state change prediction data.
[0115] In an optional embodiment, a distributed digital twin model is first efficiently constructed and maintained in a resource-constrained edge computing environment by a distributed data collection and twin modeling module. Optionally, multi-dimensional heterogeneous state tensor collection and compression is first performed, and the edge computing node continuously collects multi-dimensional heterogeneous state data (i.e., multi-source heterogeneous state data) including computing resource indicators (such as central processing unit utilization, memory usage, storage usage), network indicators (such as bandwidth occupancy, communication delay, packet loss rate), application layer indicators (such as task queue length, service response time, request failure rate), and environmental indicators (such as temperature, power status) through built-in sensors, and organizes these raw data into a four-order state tensor (i.e., an initial state tensor), and then performs compression processing on the initial state tensor using a tensor decomposition method to obtain a compressed state tensor, thereby reducing storage and computing overhead.
[0116] Optionally, a digital twin model of the target edge computing node is constructed based on the compressed state tensor, and state change prediction data is obtained by predicting the state change of the target edge computing node through the digital twin model. For example, a lightweight and dynamic digital twin model is locally maintained on each edge computing node, which can describe the node's own information, depict its dependence relationship with neighbor nodes, and perform short-term prediction. The digital twin model includes three key components: a local state model, a neighborhood relationship model, and a behavior prediction model. The local state model stores the compressed state tensor G self and its factor matrix, which reflects the node state change in real time through an incremental update mechanism. The neighborhood relationship model maintains a dynamic weighted directed graph G local = (V local ,E local ,W local ), where V local includes the node itself and its one-hop neighbors, E local represents the physical connection and functional dependence relationship between nodes, and W local is the edge weight matrix, representing the dependence strength. The weight w ij (t) is updated in real time through an adaptive learning algorithm, which is as follows:
[0117] w ij (t) = a · w ij (t-1) + (1-a) · MI(X i (t-τ:t), X j (t:t+τ))
[0118] where a is a smoothing factor, w ij (t-1) is the historical weight, and MI(X i , X j) represents mutual information, used to quantify the statistical dependency between the historical state of node i and the future state of node j, τ is the time window size, X i (t-τ:t) represents the historical state sequence of node i from time t-τ to time t, X j (t:t+τ) represents the future state sequence of node j from time t to time t+τ.
[0119] The behavior prediction model predicts the future short-term state change based on the node historical state sequence, and obtains state change prediction data. Optionally, the behavior prediction model adopts a lightweight gated recurrent unit, denoted as follows:
[0120] z t =σ(W z ·[h t-1 ,x t ]+b z )
[0121] r t =σ(W r ·[h t-1 ,x t ]+b r )
[0122]
[0123] wherein z t is an update gate, used to control the historical information retention ratio, and determines how much historical information 2 t-1 needs to be retained to the current state; r t is a reset gate, used to control the historical information forgetting ratio, and determines how much historical information needs to be forgotten in order to better integrate new information x t . is a candidate hidden state, h t is a current hidden state, σ is a sigmoid activation function, W z , W r , W is a weight matrix, b z , b r , b is a bias vector, tanh is a hyperbolic tangent activation function, and ⊙ represents element-level multiplication.
[0124] Optionally, a prediction-driven adaptive synchronization mechanism is adopted, which synchronizes only the data that is "necessary". First, the importance index Imp(t) of state change is defined by comprehensively considering the state change amplitude, change trend and node criticality, which is used to evaluate the importance of the state, and is denoted as follows:
[0125]
[0126] where S(t) is the current state vector, S(t-1) is the historical state vector, is the predicted state vector, C v is the node centrality index, β1, β2, β3 are weight coefficients, satisfying β1+β2+β3=1.
[0127] Further, network state awareness and adaptive synchronization threshold calculation are performed. Each node estimates the current network load L net (t) by passively monitoring network traffic, and predicts the network load L at future time t+Δt, denoted as L
[0128]
[0129] where θ base is the basic threshold, and γ is the adjustment coefficient.
[0130] Further, priority synchronization scheduling is performed, and the priority P of the synchronization message is determined by the following formula:
[0131]
[0132] When Imp(t)>θ(t), synchronization is triggered, and a priority P is calculated for the synchronization message. The system arranges the message transmission order according to the priority P, ensuring that important state changes are synchronized in a timely manner.
[0133] Optionally, a vector clock-based consistency maintenance mechanism is adopted to ensure the consistency of the distributed digital twin model, including the following contents:
[0134] (1) Vector clock maintenance: each node v i maintains a vector clock VC i , which records the latest known update timestamp.
[0135] (2) Incremental update propagation: when a node v i sends a state update to a neighbor node v j , it also sends the vector clock VC i and the incremental update ΔS i .
[0136] (3) Conflict detection and resolution: when a node receives multiple conflicting updates, a causal relationship-based conflict resolution strategy is adopted, denoted as follows:
[0137] S merged =∑ k w k ·S k
[0138] where Smerged denotes the final merged state, w k is a weight based on credibility and timestamp, S k are state updates from different sources.
[0139] Optionally, in the cascade failure prediction and self-healing method of the edge computing system provided in the embodiments of the present application, after obtaining the state change prediction data, the method further comprises: evaluating the state change prediction data by the target edge computing node to obtain an evaluation result, wherein the evaluation result is used to represent the importance of the state change prediction data; and comparing the evaluation result with a preset threshold, and if the evaluation result is greater than the preset threshold, forwarding the state change prediction data to a neighboring node of the target edge computing node by the target edge computing node.
[0140] In an optional embodiment, according to the prediction-driven adaptive synchronization mechanism described above, the target edge computing node first evaluates the state change prediction data to obtain an evaluation result, i.e., calculates the importance index value corresponding to the current change, and then compares the importance index value with an adaptive synchronization threshold (i.e., a preset threshold), and if the evaluation result is greater than the preset threshold, triggers synchronization and forwards the state change prediction data to a neighboring node of the target edge computing node.
[0141] Optionally, in the cascade failure prediction and self-healing method of the edge computing system provided in the embodiments of the present application, the preset causal graph is obtained by the following steps: determining a constraint condition according to target domain knowledge information of the edge computing system, constructing a target optimization function according to the constraint condition, solving the target optimization function by using a preset solving algorithm, and obtaining an initial causal adjacency matrix, wherein the target optimization function is used to determine the causal relationship between the edge computing nodes in the edge computing system; performing time sequence expansion on the initial causal adjacency matrix to obtain a time-varying causal adjacency matrix, and determining the preset causal graph according to the time-varying causal adjacency matrix.
[0142] In an optional embodiment, the causal graph structure learning and construction module learns accurate causal relationships from historical state data of the edge computing nodes and constructs a causal graph reflecting the real dependency structure of the system, laying a foundation for subsequent cascade failure prediction. First, a constraint condition is determined according to target domain knowledge information of the edge computing system, and a target optimization function is constructed according to the constraint condition, and the target optimization function is solved by using a preset solving algorithm to obtain an initial causal adjacency matrix. For example, a causal discovery framework with mixed domain knowledge constraints is used to integrate data-driven and knowledge-driven paradigms. First, the physical laws and prior knowledge of the edge computing system are represented as three types of constraints to formalize the domain knowledge, which is represented as follows:
[0143] Topology constraint: based on physical connection relationship, such as node v i and node vj If the physical connections are not connected, then v i →v j ;
[0144] Functional constraints: based on system functional dependencies, such as the calling relationships between service components;
[0145] Timing constraints: based on system laws, such as network latency must be greater than propagation time.
[0146] Furthermore, the causal discovery problem is transformed into a constrained optimization problem, yielding the constrained optimization objective function (i.e., the objective optimization function), as follows:
[0147] min W [L(W;D)+λ1·R acyclic (W)+λ2·R sparse (W)+λ3·R knowledge (W)]
[0148] Where L(W;D) is the data fitting loss, D is the training data (such as the compressed state tensor), and R is the loss function. acyclic (W) is an acyclic constraint regularization term, R sparse (W) is a sparsity regularization term, R knowledge (W) is the domain knowledge constraint regularization term, and λ1, λ2, and λ3 are tradeoff coefficients. W is the causal adjacency matrix, which defines the causal graph structure we are looking for. The entire optimization process is about finding an optimal W that minimizes the value of the objective function.
[0149] Furthermore, by designing knowledge constraint regularization terms R... knowledge (W) ensures that the learned causal graph is a directed acyclic graph, represented as follows:
[0150]
[0151] Among them, C forbid C is a set of node pairs that prohibit causal relationships. enforce It is a set of node pairs that must have a causal relationship, W ij This represents the degree of influence of node i on node j. Positive values indicate a positive influence, and negative values indicate a negative influence. The larger the absolute value, the stronger the influence. σ is the sigmoid function, and c is the scaling factor.
[0152] Optionally, the alternating direction multiplier method (i.e., the pre-defined solution algorithm) is used to solve the constrained optimization problem (i.e., the objective function), as follows:
[0153]
[0154] U k+1 =U k +Wk+1 -Z k+1
[0155] where k denotes the iteration number, W is the causal adjacency matrix, Z is the auxiliary variable, U is the Lagrange multiplier, ρ is the penalty parameter, ‖·‖ F denotes the Frobenius norm.
[0156] Further, the initial causal adjacency matrix is time-expanded to obtain a time-varying causal adjacency matrix, and a preset causal graph is determined according to the time-varying causal adjacency matrix. Alternatively, due to the changing running environment and workload of the edge computing system, the causal relationship between nodes presents non-stationary characteristics, therefore, a causal discovery algorithm capable of processing non-stationary time series data is adopted, first, time-varying causal relationship modeling is performed, it is assumed that the causal relationship changes smoothly over time, the causal adjacency matrix is expressed as a function of time W(t), and a kernel function expansion is adopted, expressed as follows:
[0157]
[0158] where φ l (t) is the basis function, L denotes the number of basis functions, α l is the coefficient matrix.
[0159] Further, local stationary window segmentation is performed, and an adaptive window technique is adopted to segment the non-stationary time series data into local stationary segments {S1, S2,..., S K}. Wherein S k = {X t : t k-1 <t≤t k} represents the kth local stationary segment, X t represents a multivariate time series data vector (or matrix) composed of the states of all nodes at time point t.
[0160] Further, the causal discovery of different time windows is regarded as a related task, and is jointly optimized through a multi-task learning framework, expressed as follows:
[0161]
[0162] where is a time series smoothing regularization term, defined as:
[0163]
[0164] Further, a non-parametric change point detection algorithm based on kernel maximum mean difference is adopted to identify time points at which the causal structure changes significantly, expressed as follows:
[0165]
[0166] where P t and P t+Δ are data distributions of different time windows, μ P is the mean embedding of distribution P in the reproducing kernel Hilbert space H. MMD 2 is the square of maximum mean discrepancy.
[0167] Optionally, to adapt to the dynamic changes of the edge computing system, an incremental Bayesian causal graph updating mechanism is adopted without relearning the entire causal graph. First, a Bayesian causal model is constructed, and the causal graph is represented as a Bayesian network G=(V,E,Θ), where V is the node set, E is the edge set, and Θ is the conditional probability parameter. Then, for new observation data D new , the marginal likelihood of each possible edge e ij is calculated:
[0168] p(D new |e ij ,G)=∫p(D new |e ij ,Θ,G)p(Θ|G)dΘ
[0169] where p(D new |e ij ,G) is a conditional probability, which represents the likelihood of observing new data D ij under the assumption that edge e new exists and the causal graph structure is G.
[0170] Further, the posterior confidence of each edge is updated based on the new data, represented as follows:
[0171] p(e ij |D all )∝p(e ij |D old )·p(D new |e ij ,G)
[0172] where D all =D old ∪D new represents the set of all historical data and new data. ∝ represents proportional to.
[0173] Further, structure pruning and expansion are performed. According to the updated edge confidence, the causal graph structure is dynamically adjusted to maintain the acyclic constraint of the graph, represented as follows:
[0174] When p(e ij |D all )<θ prune , edge e ij is pruned.
[0175] When p(e) ij |D all )>θ add and When adding edge e ij .
[0176] Where, θ prune θ is the pruning threshold. add Add a threshold.
[0177] Furthermore, incremental parameter updates are performed. The conditional probability parameters are updated incrementally using the variational Bayesian method, as shown below:
[0178] q * (Θ)=arg min q∈Q KL(q(Θ)‖p(Θ|D all ,G))
[0179] Where, q * (Θ) represents the optimal variational posterior distribution, q(Θ) is the variational posterior distribution of parameter Θ, Q is the family of variational distributions, and KL(·) represents the KL divergence.
[0180] Optionally, causal strength estimation is performed based on intervention entropy, and the uncertainty of the estimation is quantified. First, intervention entropy is calculated, defining node v. i For node v j Intervention entropy H i→j for:
[0181]
[0182] Where p(x) i ) is the variable X i Marginal probability distribution, do(X) i =x i ) represents the variable X i Intervene and set it to x i .
[0183] Furthermore, the causal strength S is defined based on the reduction in intervention entropy. i→j , means as follows:
[0184]
[0185] Wherein, H(X) j ) is node v j The marginal entropy.
[0186] Furthermore, the uncertainty of the causal strength estimation is quantified using a Bayesian method, as follows:
[0187] p(S i→j|D) = ∫p(S i→j |Θ)p(Θ|D)dΘ
[0188] where D denotes all observed data (i.e., training data).
[0189] Further, the posterior distribution is approximated by Monte Carlo sampling, and the confidence interval of the causal strength is obtained. Then the learned causal graph is visualized, for example, the thickness of the edge represents the causal strength, and the color depth represents the uncertainty, which can provide an intuitive display of the causal relationship for the relevant personnel.
[0190] Optionally, in the cascade failure prediction and self-healing method of the edge computing system provided in the embodiments of the present application, the causal graph neural network model is obtained by the following steps: obtaining a training sample set, wherein the training sample set includes historical state data of a plurality of edge computing nodes; constructing an initial causal graph neural network model according to a preset causal graph, and training the initial causal graph neural network model according to the training sample set until a predetermined training target is reached, to obtain the causal graph neural network model.
[0191] In an optional embodiment, the causal graph neural network model is constructed by the causal graph neural network prediction module, and the cascade failure risk in the edge computing system is accurately predicted, and an interpretable prediction result is provided, which provides a basis for self-healing decision. For example, first, a training sample set is obtained, an initial causal graph neural network model is constructed according to a preset causal graph, and the initial causal graph neural network model is trained according to the training sample set until a predetermined training target is reached, for example, the loss reaches a set threshold or a predetermined training round is completed, to obtain the causal graph neural network model.
[0192] Optionally, a counterfactual-intervention graph convolutional network is designed to explicitly model the causal relationship between nodes. First, a causal adjacency matrix A where A causal [i,j] = S i→j represents the causal strength of node v i to node v j . Then define the causal graph convolution operation to make the information propagate along the causal direction:
[0193]
[0194] where A is the causal adjacency matrix after adding a self-loop, I n is the identity matrix, is the degree matrix of A , H (l) is the node feature matrix of the l-th layer, and W (l)is a learnable weight matrix, and σ is a nonlinear activation function such as ReLU, Sigmoid, or tanh.
[0195] Further, a counterfactual reasoning module is designed to simulate the scenario of “if node v i fails, whether node v j will fail”, which is represented as follows:
[0196]
[0197] wherein, represents the node feature matrix obtained after counterfactual reasoning at the l+1 layer, is a counterfactual adjacency matrix, which simulates intervention by setting the weight of a specific edge in to zero.
[0198] Further, the intervention effect is calculated to quantify the impact of node v i failure on node v j , which is represented as follows:
[0199] E i→j =‖H j -H cf,j ‖2
[0200] wherein, H j is the representation of node v j in the actual scenario, and H cf,j is the representation of node v j in the counterfactual scenario.
[0201] Further, a multi-head attention mechanism is introduced to dynamically adjust the importance of different causal paths, which is represented as follows:
[0202]
[0203] wherein, represents the attention weight of node j on node i at the hth attention head. exp is the exponential function. LeakyReLU is the activation function. a (h)T represents the transpose of a (h) . W (h) represents the trainable weight matrix unique to the hth attention head. h′ i represents the final output of the new feature vector of node i after processing and merging through all attention heads.
[0204] ||represents vector concatenation, || h represents multi-head concatenation, a (h) is the parameter vector of the hth attention head, and N i is the causal neighbor set of node v i .
[0205] Further, since the cascading failure of edge computing systems involves dynamic processes at different time scales, a multi-scale temporal prediction architecture is adopted to capture both short-term and long-term failure propagation patterns. First, time encoding is performed to embed time information into node features using position encoding techniques, denoted as follows:
[0206]
[0207] where TE(t, d) denotes the position encoding value for feature dimension d at time step t. t is the time step, d is the feature dimension, D denotes the total feature dimension here, and even and odd represent whether the feature dimension d is even or odd, respectively.
[0208] Optionally, a causal graph convolution gated recurrent unit is adopted to capture short-term dependencies, denoted as follows:
[0209] z t =σ(W z ·[GC(h t-1 ),x t ]+b z )
[0210] r t =σ(W r ·[GC(h t-1 ),x t ]+b r )
[0211]
[0212] h t =(1-z t )⊙h t-1 +z t ⊙h t
[0213] where GC(·) denotes the causal graph convolution operation.
[0214] Optionally, a causal graph attention Transformer is adopted to capture long-term dependencies, denoted as follows:
[0215] Q=HW Q , K=HW K , V=HW V
[0216]
[0217] H′=AV
[0218] where Q, K, V are query matrix, key matrix and value matrix respectively. H represents the input feature matrix, i.e., the features of all nodes. W Q ,W K ,W V represent three trainable weight matrices, which are used to linearly project (transform) the input features H into query space, key space and value space respectively. A represents the computed attention weight matrix. d k is the dimension of K. M causal is a mask matrix constructed based on the causal graph, which ensures that the attention mechanism follows the causal structure. H' represents the output feature matrix after the attention mechanism aggregation.
[0219] Further, multi-scale fusion is performed to fuse short-term and long-term prediction results through an adaptive gating mechanism, which is represented as follows:
[0220] g = σ(W g · [h short ,h long ]+b g )
[0221] h fused = g ⊙ h short + (1-g) ⊙ h long
[0222] where W g is a trainable weight matrix, and b g is a trainable bias vector. h short is the output of the short-term prediction module, h long is the output of the long-term prediction module, and g is the fusion gate.
[0223] Further, cascading failure prediction not only needs to predict whether it will fail, but also needs to quantify the uncertainty of the prediction. The following uncertainty-aware risk assessment mechanism is adopted:
[0224] First, Monte Carlo dropout is performed, which keeps the dropout activation during the inference phase, estimates the uncertainty of the prediction by multiple sampling, and is represented as follows:
[0225]
[0226] where, represents the final prediction mean. T is the number of Monte Carlo sampling. f(x i ; W, z t ) is the prediction result of the model for input x i at the t-th sampling, z t is the dropout mask, and W is the weight parameter of the model. represents the final prediction variance, and τ is the precision parameter.
[0227] Then deep ensemble learning is performed, multiple models with different initializations and data samplings are trained to form a model ensemble, denoted as follows:
[0228]
[0229] where f m (x i ) is the prediction result of the mth model. M is the number of models in the ensemble.
[0230] Further, risk score calculation is performed, considering both failure probability and prediction uncertainty, to calculate the risk score Risk(v i ) of a node, denoted as follows:
[0231]
[0232] where β is the risk aversion coefficient, controlling the weight of uncertainty in risk assessment.
[0233] Further, cascading path identification is performed, based on node risk scores and causal graph structure, to identify potential cascading failure paths, denoted as follows:
[0234]
[0235] where P is a path, (v i ,v j ) is an edge on the path.
[0236] Optionally, an interpretable prediction result generation mechanism is designed to improve the credibility and operability of the prediction results. First, feature importance analysis is performed, using the integrated Shapley additive explanation method to quantify the contribution of different features to the prediction results, denoted as follows:
[0237]
[0238] where φ i is the Shapley additive explanation value of feature i, N is the set of all features, x S represents an instance containing only the feature subset S, N\{i} represents the subset of the set N of all features after removing feature i, and f(x S ∪{i}) represents the prediction output of the model for input x under the condition of containing feature subset S and feature i.
[0239] Further, critical path visualization is performed, visualizing the predicted cascading failure paths and labeling the causal strength S i→j and uncertainty
[0240] Further, a counterfactual explanation is generated to illustrate how the intervention on node v i affects the failure risk of node v j , which is expressed as follows:
[0241] ΔRisk(v j |do(v i ))=Risk(v j )-Risk cf (v j |do(v i ))
[0242] wherein Risk cf (v j |do(v i )) is the counterfactual risk score of node v i after the intervention on node v j .
[0243] Further, structured warning information (i.e., the final prediction result) is generated, for example, containing the following contents:
[0244] Warning ID: timestamp-risk level;
[0245] Risk level: [high / medium / low];
[0246] Influence range: [node list];
[0247] Expected time: [failure time window];
[0248] Root cause analysis: [key nodes and their abnormal features];
[0249] Propagation path: [cascade failure path];
[0250] Suggested measures: [intervention suggestions based on counterfactual analysis];
[0251] Confidence: [uncertainty evaluation of prediction].
[0252] The cascade failure prediction and self-healing method of the edge computing system provided by the embodiments of the present application can significantly improve the prediction accuracy by fusing causal reasoning and graph neural networks, realize early warning of cascade failure, generate intervention strategies by combining dynamic risk prediction, realize active self-healing, enhance system robustness, and improve system reliability.
[0253] It should be noted that the steps shown in the flowchart of the accompanying drawings can be executed in a computer system such as a set of computer executable instructions, and although a logical order is shown in the flowchart, in some cases, the steps shown or described herein can be executed in an order different from that shown herein.
[0254] Embodiment 2
[0255] The embodiment of the present application also provides a cascade failure prediction and self-healing device of an edge computing system. It should be noted that the cascade failure prediction and self-healing device of the edge computing system in the embodiment of the present application can be used to execute the cascade failure prediction and self-healing method for the edge computing system provided by the embodiment of the present application. The cascade failure prediction and self-healing device of the edge computing system provided by the embodiment of the present application is introduced as follows.
[0256] According to the embodiment of the present application, a cascade failure prediction and self-healing device of an edge computing system for implementing the cascade failure prediction and self-healing method of the edge computing system is also provided. As shown in the device, the device comprises a first determination unit 401 and a first processing unit 402. Figure 4
[0257] The first determination unit 401 is configured to, in a case where state change prediction data of a target edge computing node of the edge computing system is detected, determine a prediction result corresponding to the target edge computing node by using a pre-trained causal graph neural network model according to the state change prediction data and a preset causal graph, wherein the state change prediction data is used to represent a future state change of the target edge computing node, the preset causal graph is used to represent a causal relationship between edge computing nodes in the edge computing system, and the prediction result at least includes a cascade failure path associated with the target edge computing node and a confidence degree of the cascade failure path.
[0258] The first processing unit 402 is configured to determine a target processing strategy according to the prediction result, and execute the target processing strategy to realize the cascade failure self-healing of the edge computing system.
[0259] The cascade failure prediction and self-healing device of the edge computing system provided by the embodiment of the present application is configured to, in a case where state change prediction data of a target edge computing node of the edge computing system is detected, determine a prediction result corresponding to the target edge computing node by using a pre-trained causal graph neural network model according to the state change prediction data and a preset causal graph, wherein the state change prediction data is used to represent a future state change of the target edge computing node, the preset causal graph is used to represent a causal relationship between edge computing nodes in the edge computing system, and the prediction result at least includes a cascade failure path associated with the target edge computing node and a confidence degree of the cascade failure path. The first processing unit 402 is configured to determine a target processing strategy according to the prediction result, and execute the target processing strategy to realize the cascade failure self-healing of the edge computing system.
[0260] Optionally, in the cascade failure prediction and self-healing device of the edge computing system provided in the embodiments of the present application, the first determining unit 401 comprises: a first processing subunit, configured to perform encoding processing on the state change prediction data by using the causal graph neural network model to obtain encoded data; a first determining subunit, configured to determine the influence degree of the target edge computing node on the neighboring nodes of the target edge computing node according to the encoded data and the preset causal graph, and determine the cascade failure path according to the influence degree and the preset causal graph; and a second determining subunit, configured to determine the confidence of the cascade failure path based on a preset algorithm, and determine the prediction result according to the cascade failure path and the confidence of the cascade failure path.
[0261] Optionally, in the cascade failure prediction and self-healing device of the edge computing system provided in the embodiments of the present application, the first processing unit 402 comprises: a third determining subunit, configured to determine a plurality of intervention nodes from the edge computing nodes contained in the cascade failure path according to the cascade failure path and the confidence of the cascade failure path; and a fourth determining subunit, configured to determine an intervention strategy corresponding to each intervention node and a strategy execution order, and compose a target processing strategy according to the intervention strategy corresponding to each intervention node and the strategy execution order.
[0262] Optionally, in the cascade failure prediction and self-healing device of the edge computing system provided in the embodiments of the present application, the device further comprises: a first obtaining unit, configured to obtain multi-source heterogeneous state data of a target edge computing node by using the target edge computing node before detecting state change prediction data of the target edge computing node of the edge computing system, and construct an initial state tensor according to the multi-source heterogeneous state data; a second processing unit, configured to perform compression processing on the initial state tensor to obtain a compressed state tensor, and construct a digital twin model of the target edge computing node according to the compressed state tensor; and a third processing unit, configured to predict state changes of the target edge computing node by using the digital twin model to obtain the state change prediction data.
[0263] Optionally, in the cascade failure prediction and self-healing device of the edge computing system provided in the embodiments of the present application, the device further comprises: a fourth processing unit, configured to evaluate the state change prediction data by using the target edge computing node after obtaining the state change prediction data to obtain an evaluation result, wherein the evaluation result is used to represent the importance of the state change prediction data; and a fifth processing unit, configured to compare the evaluation result with a preset threshold value, and if the evaluation result is greater than the preset threshold value, forward the state change prediction data to the neighboring nodes of the target edge computing node by using the target edge computing node.
[0264] Optionally, in the cascaded failure prediction and self-healing device for the edge computing system provided in this application embodiment, the device further includes the following unit, which is used to obtain a causal graph neural network model through the following steps: a second acquisition unit, used to acquire a training sample set, wherein the training sample set includes historical state data of multiple edge computing nodes; and a sixth processing unit, used to construct an initial causal graph neural network model based on a preset causal graph, and train the initial causal graph neural network model based on the training sample set until a predetermined training target is reached, thereby obtaining a causal graph neural network model.
[0265] Optionally, in the cascaded failure prediction and self-healing device for the edge computing system provided in this application embodiment, the device further includes the following unit, used to obtain a preset causal graph through the following steps: a seventh processing unit, used to determine constraints based on the target domain knowledge information of the edge computing system, construct a target optimization function based on the constraints, solve the target optimization function using a preset solution algorithm, and obtain an initial causal adjacency matrix, wherein the target optimization function is used to determine the causal relationship between edge computing nodes in the edge computing system; an eighth processing unit, used to perform time-series expansion on the initial causal adjacency matrix to obtain a time-varying causal adjacency matrix, and determine the preset causal graph based on the time-varying causal adjacency matrix.
[0266] It should be noted that the first determining unit 401 and the first processing unit 402 mentioned above correspond to steps S201 to S202 in Embodiment 1. The two units and the corresponding steps implement the same instances and application scenarios, but are not limited to the content disclosed in Embodiment 1. It should be noted that the above modules or units can be hardware or software components stored in memory (e.g., memory 104) and processed by one or more processors (e.g., processors 102a, 102b, ..., 102n). The above units can also be part of a device and run in the computer terminal 10 provided in Embodiment 1.
[0267] Example 3
[0268] Embodiments of this application may provide an electronic device. Figure 5 This is a structural block diagram of an electronic device according to an embodiment of this application. Figure 5 As shown, the electronic device may include: one or more ( Figure 5 Only one of the components is shown: processor 502, memory 504, memory controller, and peripheral interface, wherein the peripheral interface is connected to the radio frequency module, audio module, and display.
[0269] The memory can be used to store software programs and modules, such as the program instructions / modules corresponding to the methods and apparatus in the embodiments of this application. The processor executes various functional applications and data processing by running the software programs and modules stored in the memory, thereby implementing the above-described methods. The memory may include high-speed random access memory, and may also include non-volatile memory, such as one or more magnetic storage devices, flash memory, or other non-volatile solid-state memory. In some instances, the memory may further include memory remotely located relative to the processor, and these remote memories can be connected to the terminal via a network. Examples of such networks include, but are not limited to, the Internet, corporate intranets, local area networks, mobile communication networks, and combinations thereof.
[0270] Those skilled in the art will understand that Figure 5 The structure shown is for illustrative purposes only. Electronic devices can also be smartphones, tablets, handheld computers, mobile internet devices (MIDs), PADs, and other terminal devices. Figure 5 This does not limit the structure of the aforementioned electronic device. For example, electronic devices may also include components that are more... Figure 5 The more or fewer components shown (such as network interfaces, display devices, etc.), or having the same Figure 5 The different configurations shown.
[0271] Those skilled in the art will understand that all or part of the steps in the various methods of the above embodiments can be implemented by a program instructing the hardware related to the terminal device. The program can be stored in a computer-readable storage medium, which may include: flash drive, read-only memory (ROM), random access memory (RAM), disk or optical disk, etc.
[0272] Example 4
[0273] Embodiments of this application also provide a computer-readable storage medium. Optionally, in this embodiment, the storage medium can be used to store the program code executed by the cascading failure prediction and self-healing method of the edge computing system provided in Embodiment 1.
[0274] Optionally, in this embodiment, the storage medium may be located in any computer terminal in a group of computer terminals in a computer network, or in any mobile terminal in a group of mobile terminals.
[0275] This application also provides a computer program product that, when executed on a data processing device, is suitable for performing steps of a cascading failure prediction and self-healing method for an edge computing system.
[0276] The above embodiment numbers of the present application are only for description, and do not represent the advantages or disadvantages of the embodiments.
[0277] In the above embodiments of the present application, the description of each embodiment has its own focus, and the parts not described in detail in a certain embodiment can be referred to the relevant description of other embodiments.
[0278] In the several embodiments provided by the present application, it should be understood that the disclosed technology can be implemented in other ways. Of course, the embodiment described above is only a schematic, for example, the division of units is only a logical function division, and there can be another division manner in actual implementation, for example, a plurality of units or components can be combined or integrated into another system, or some features can be ignored or not executed. In addition, the coupling or direct coupling or communication connection between the units shown or discussed can be indirect coupling or communication connection through some interface, unit or module, and can be electrical or other forms.
[0279] The units described as separate components can or can not be physically separate, and the components shown as units can or can not be physical units, that is, they can be located in one place, or distributed on a plurality of network units. Part or all of the units can be selected according to actual needs to achieve the purpose of the embodiment scheme.
[0280] In addition, each functional unit in each embodiment of the present application can be integrated in one processing unit, or each unit can exist physically, or two or more units can be integrated in one unit. The above integrated unit can be realized in the form of hardware or in the form of software functional unit.
[0281] When the integrated unit is realized in the form of software functional unit and sold or used as an independent product, it can be stored in a computer readable storage medium. Based on this understanding, the technical solutions of the present application essentially or the part that contributes to the prior art or the whole or part of the technical solutions can be embodied in the form of a software product. The computer software product is stored in a storage medium, and includes a number of instructions for causing a computer device (which can be a personal computer, a server or a network device, etc.) to execute all or part of the steps of the methods described in each embodiment of the present application. The foregoing storage medium includes: a U disk, a read-only memory (ROM, Read-Only Memory), a random access memory (RAM, Random Access Memory), a mobile hard disk, a magnetic disk or an optical disk, and various media that can store program codes.
[0282] The above merely describes the preferred embodiments of the present application, and it should be pointed out that, for those skilled in the art, some improvements and refinements can be made without departing from the principles of the present application, and these improvements and refinements should also be considered as the protection scope of the present application.
Claims
1. A cascading failure prediction and self-healing method of an edge computing system, characterized in that, The method comprises the following steps: In the case of detecting state change prediction data of a target edge computing node of an edge computing system, determining a prediction result corresponding to the target edge computing node by a pre-trained causal graph neural network model according to the state change prediction data and a preset causal graph, wherein the state change prediction data is used to represent the future state change of the target edge computing node, and the preset causal graph is used to represent the causal relationship between edge computing nodes in the edge computing system, and the prediction result at least includes a cascading failure path associated with the target edge computing node and a confidence degree of the cascading failure path; According to the prediction result, a target processing strategy is determined, and the target processing strategy is executed to realize the cascading failure self-healing of the edge computing system.
2. The method of claim 1, wherein, Determining the prediction result corresponding to the target edge computing node by the pre-trained causal graph neural network model according to the state change prediction data and the preset causal graph comprises: Encoding the state change prediction data by the causal graph neural network model to obtain encoded data; According to the encoded data and the preset causal graph, the influence degree of the target edge computing node on the adjacent nodes of the target edge computing node is determined, and according to the influence degree and the preset causal graph, the cascading failure path is determined; The confidence degree of the cascading failure path is determined based on a preset algorithm, and the prediction result is determined according to the cascading failure path and the confidence degree of the cascading failure path.
3. The method of claim 1, wherein, According to the prediction result, a target processing strategy is determined, and the target processing strategy is executed to realize the cascading failure self-healing of the edge computing system. According to the prediction result, a target processing strategy is determined, and the target processing strategy is executed to realize the cascading failure self-healing of the edge computing system. Before detecting the state change prediction data of the target edge computing node of the edge computing system, the method further comprises:
4. The method of claim 1, wherein, Obtaining multi-source heterogeneous state data of the target edge computing node by the target edge computing node, and constructing an initial state tensor according to the multi-source heterogeneous state data; Compressing the initial state tensor to obtain a compressed state tensor, and constructing a digital twin model of the target edge computing node according to the compressed state tensor; Predicting the state change of the target edge computing node by the digital twin model to obtain the state change prediction data. After obtaining the state change prediction data, the method further comprises:
5. The method of claim 4, wherein, Evaluating the state change prediction data by the target edge computing node to obtain an evaluation result, wherein the evaluation result is used to represent the importance of the state change prediction data; Comparing the evaluation result with a preset threshold value, if the evaluation result is greater than the preset threshold value, forwarding the state change prediction data to the adjacent nodes of the target edge computing node by the target edge computing node. The causal graph neural network model is obtained by the following steps:
6. The method of claim 1, wherein, obtaining a training sample set, wherein the training sample set comprises historical state data of a plurality of edge computing nodes; constructing an initial causal graph neural network model according to the preset causal graph, and training the initial causal graph neural network model according to the training sample set until a predetermined training target is reached to obtain the causal graph neural network model.
7. The method of claim 1, wherein, The preset causal graph is obtained by the following steps: determining a constraint condition according to target domain knowledge information of the edge computing system, constructing a target optimization function according to the constraint condition, and solving the target optimization function by using a preset solving algorithm to obtain an initial causal adjacency matrix, wherein the target optimization function is used to determine the causal relationship between the edge computing nodes in the edge computing system; performing time series expansion on the initial causal adjacency matrix to obtain a time-varying causal adjacency matrix, and determining the preset causal graph according to the time-varying causal adjacency matrix. 8.A cascading failure prediction and self-healing apparatus of an edge computing system, characterized in that, comprising: a first determination unit configured to, when state change prediction data of a target edge computing node of an edge computing system is detected, determine a prediction result corresponding to the target edge computing node by a pre-trained causal graph neural network model according to the state change prediction data and a preset causal graph, wherein the state change prediction data is used to represent a future state change of the target edge computing node, the preset causal graph is used to represent a causal relationship between edge computing nodes in the edge computing system, and the prediction result at least includes a cascading failure path associated with the target edge computing node and a confidence of the cascading failure path; a first processing unit configured to determine a target processing strategy according to the prediction result, and execute the target processing strategy to realize cascading failure self-healing of the edge computing system.
9. A computer-readable storage medium, characterized in that, The computer readable storage medium comprises a stored executable program, wherein when the executable program is running, the computer readable storage medium controls the device where the computer readable storage medium is located to execute the cascading failure prediction and self-healing method of the edge computing system in any one of claims 1 to 7.
10. An electronic device, comprising: comprising: a memory storing an executable program; a processor configured to run the program, wherein the program is executed when the program is running to execute the cascading failure prediction and self-healing method of the edge computing system in any one of claims 1 to 7.
