A Control Plane Strategy Validation Method Based on GNN Fault Model Learning

Abstract

This invention develops a control plane policy verification method based on GNN fault model learning: It acquires network topology information, uses K-Means clustering to divide equivalence classes, and generates corresponding fault models; designs a GNN fault learning model based on a message-passing mechanism; trains a message-passing-based GNN fault learning model for each equivalence class; constructs a network policy graph conforming to network topology characteristics; preprocesses the directed policy graph, extracts feature data, and inputs it into the trained GNN model to generate an accurate network environment; and verifies network policies according to their categories. This invention considers the existence of faults in real-world networks, using GNN-assisted fault models to infer the actual network environment corresponding to the network policy to be verified. It uses K-Means clustering to divide equivalence classes, reducing network size and improving verification speed. The addition of a data augmentation module gives the trained GNN a certain generalization ability, enabling accurate and rapid verification of multiple network policy types.

Description

Technical Field

[0001] This invention relates to the field of network policy verification technology, and in particular to a control plane policy verification method based on GNN fault model learning. Background Technology

[0002] Increased network complexity makes networks more susceptible to various failures, such as misconfigurations, software vulnerabilities, and malicious attacks. These failures can cause networks to deviate from their policy objectives, thus affecting their availability. However, traditional manual troubleshooting methods, such as using Ping to detect latency and packet loss rates, or using Traceroute to detect latency, reachability, and packet loss rates, are not only inefficient but also often result in network downtime of several hours, causing significant losses. Therefore, preventing network failures and ensuring proper network operation has become a fundamental problem for network operators and researchers.

[0003] Network policy verification technology is used to address this problem. Compared to traditional manual troubleshooting methods, network policy verification technology not only enables rapid, real-time, and automated detection, improving the efficiency and accuracy of network policy verification, but also enhances the reliability and accuracy of verification results by combining formal verification methods and utilizing mathematical models and algorithms. Currently, network policy verification technology mainly falls into two categories: data plane analysis and control plane verification. Data plane analysis is primarily used to infer policies applicable to a specific data plane; it can infer all expected policies under that data plane within seconds or minutes. Control plane verification, on the other hand, verifies a single policy under a specific network configuration. For network policy verification technology to be applied to real-world networks, fault models are needed to model potential faults in the network. However, deploying existing data plane analysis and control plane verification tools in networks that consider fault models requires traversing all possible fault environments to determine the accurate environment that conforms to the network policy. Therefore, as network size increases exponentially, finding the accurate network environment that conforms to the network policy becomes difficult. Directly using data plane analysis or control plane verification tools leads to high computational complexity, slow verification speed, and a decrease in the accuracy of verification results.

[0004] The paper "Config2Spec: Mining Network Specifications from Network Configurations," published in NSDI (pp. 969-984) by Birkner, R., Drachsler-Cohen, D., Vanbever, L., and Vechev, MT (2020, February), discusses Config2Spec as a typical network policy verification tool that considers fault models. It combines the advantages of data plane and control plane verification methods. By analyzing historical iteration information and fault models, it uses a stage predictor to switch between data plane analysis and control plane verification to obtain the optimal verification method, enabling the generation of network specifications with high accuracy and recall in large networks. However, this tool is still limited by the verification capabilities of existing data plane analysis and control plane verification methods, making it difficult to meet the need for rapid verification in large-scale network topologies with poor network conditions. Furthermore, Config2Spec may generate spurious specifications because network configuration files may contain inconsistent or erroneous information, which can affect the accuracy of the specifications generated by Config2Spec. Summary of the Invention

[0005] In view of this, the purpose of this invention is to provide a control plane policy verification method based on GNN fault model learning, to solve the technical problems mentioned in the background art. For large-scale complex dynamic networks, neglecting the existence of faults in the network will obviously reduce the reliability of network policy verification results. Therefore, this invention fully utilizes the graph representation learning capability of GNN neural networks, combined with fault models, to fully learn the network structure under fault conditions, thereby accurately locating the fault environment for network policy and performing relatively accurate network policy verification. Furthermore, since GNN is an efficient neural network model capable of processing large-scale network data, this greatly improves the speed of network policy verification, facilitating rapid detection of network faults.

[0006] To achieve the above objectives, the present invention adopts the following technical solution:

[0007] A control plane policy verification method based on GNN fault model learning includes the following steps:

[0008] Step S1: Obtain network topology information, use K-Means clustering to divide equivalence classes, reduce the network size, and set the maximum number of faults in the network according to requirements to generate the corresponding fault model;

[0009] Step S2: Design a GNN fault learning model based on message passing mechanism. The model includes a linear transformation layer, a graph convolutional layer and a fully connected layer. The input is the adjacency matrix of the network topology and the corresponding fault model. The output is the probability distribution of fault probabilities between feature nodes.

[0010] Step S3: Train a GNN fault learning model based on message passing mechanism for each equivalence class, and use the trained model to verify the network policy.

[0011] Step S4: Collect network policy information that the administrator needs to verify, generate a network policy set according to the requirements, and construct a network policy diagram that conforms to the network topology characteristics.

[0012] Step S5: Preprocess the policy directed graph, extract feature data, input it into the trained GNN model, obtain the probability distribution of fault probabilities between feature nodes, and generate an accurate network environment.

[0013] Step S6: In an accurate network environment, verify the network policies according to the network policy categories to obtain the final verification results.

[0014] Preferably, step S1 includes the following steps:

[0015] Step S1.1: Obtain network topology information, calculate node degree and degree centrality, train K-Means clustering model to divide equivalence classes using node degree and degree centrality, select the optimal number of clusters as the optimal number of categories for equivalence classes using the elbow rule, and generate a unique label and corresponding topology graph for each equivalence class.

[0016] Step S1.2: Set the maximum number of faults k in the network topology according to requirements. max Generate a failure model based on Monte Carlo simulation: Failure_model = {env1,...env q}, where env q This represents each possible failure environment, and the failure probability P is calculated using Monte Carlo simulation in each possible failure environment. fail ;

[0017] Assuming the probability of a fault occurring on an edge (u,v) of the topological graph in step S1.1 is p, then in k max Within one step, the failure probability P fail Represented by a binomial distribution:

[0018]

[0019] in Indicates that in k maxWithin a step, q (0≤q≤k) occurs. max The number of combinations of failures; the failure probability P. fail Indicates the maximum number of failures k max The probability of an edge (u,v) failing.

[0020] Preferably, in step S2:

[0021] Construct a graph neural network (GNN) fault learning model, which includes a linear transformation layer, a graph convolutional layer, and a fully connected layer:

[0022] The linear transformation layer:

[0023] h i (1) =σ(W (1) x i +b (1) (2)

[0024] Where: h i (1) σ is the feature vector of the hidden layer, σ is the ReLU activation function, and W is the feature vector of the hidden layer. (1) ∈R din×dout It is the weight matrix of the input layer, x i ∈R din b is the input feature vector of node i. (1) It is the bias vector of the linear transformation layer;

[0025] The graph convolutional layer:

[0026]

[0027] in: Let be the set of neighboring nodes of node i, and AGGREGATE represent the aggregation function. It is the weight matrix of the k-th graph convolutional layer. This represents the feature vector of node j in the (k-1)th graph convolutional layer. This represents the feature vector of node i in the k-th graph convolutional layer;

[0028] The fully connected layer:

[0029]

[0030] Among them: W (L) ∈R dout×dout and These are the weights and bias matrices of the fully connected layer. This represents the feature vector output by node i in the fully connected layer;

[0031] Then the feature vector The final probability distribution of the failure probability is obtained by using a softmax activation function:

[0032]

[0033] Where: h ij (L) h represents the characteristic value representing the failure probability between node i and node j in the fully connected layer. im (L) p represents the m-th feature of the i-th node in the fully connected layer output. ij This represents the probability distribution of the failure probability between node i and node j.

[0034] Preferably, in step S3:

[0035] The graph neural network (GNN) fault learning model uses the mean squared error (MSE) loss function during training.

[0036]

[0037] Where output is the output of the graph neural network (GNN) fault learning model, and adj is the adjacency matrix of the actual network topology.

[0038] Preferably, step S4 includes the following steps:

[0039] Step S4.1: Generate a network policy set according to requirements. The network policy set includes: policy number, policy type, source device, destination device, and latency limit. The policy type includes: policy reachability, policy isolation, and policy load balancing, represented by Reachiability(src,dst,delay), Isolation(src,dst), and Loadbalancing(src,dst), respectively. Here, src represents the source device, dst represents the destination device, and delay represents the latency limit. Reachiability(src,dst,delay) indicates that network traffic reaches dst from src under the latency limit delay. Isolation(src,dst) indicates that network traffic does not reach dst from src. Loadbalancing(src,dst) indicates that network traffic from src to dst is load balanced on at least two paths.

[0040] Step S4.2: Construct a policy-directed graph G based on the network policy set, and G = (V, E); where V = {d | d = 1, ..., n} is the set of all physical devices in the network, and d ∈ V is the physical device with index d in the policy-directed graph; E = {e(a, b) | a, b ∈ V} is the set of policy state transitions between physical devices, where a represents the source device index, b represents the destination device index, and e(a, b) ∈ E indicates that there is a link between the device with index a and the device with index b, which allows network traffic to be transmitted from device a to device b.

[0041] Preferably, step S5 includes the following steps:

[0042] Step S5.1: Preprocess the policy-directed graph G using a combination of pruning and padding: If the number of nodes or edges in the policy-directed graph G is greater than the number of nodes or edges in the original network topology, perform a pruning operation to delete nodes or edges in the policy-directed graph G that do not exist in the original network topology, until the size of the policy-directed graph G is the same as the original network topology; if the number of nodes or edges in the policy-directed graph G is less than the number of nodes or edges in the original network topology, perform a padding operation to add virtual nodes or edges, until the size of the policy-directed graph G is the same as the original network topology.

[0043] Step S5.2: Input the preprocessed policy directed graph G into the trained K-Means model, divide the policy directed graph G into policy subgraphs, each policy subgraph corresponds to a network topology subgraph under a label, and extract the features of each policy subgraph.

[0044] Step S5.3: Input the features of the extracted policy subgraph into the pre-trained Graph Neural Network (GNN) fault learning model under the corresponding label, and process the output results. The transformation is then performed, followed by binary classification; a threshold θ is introduced, with probabilities greater than the threshold classified as 1 and probabilities less than or equal to the threshold classified as 0, i.e.:

[0045]

[0046] Here, Edge represents the state of each edge, i and j represent the source and destination devices of the edge, respectively, and the values ​​0 and 1 indicate that the edge has failed and has not failed, respectively. This represents the probability distribution of the connection probability between node i and node j learned through the graph neural network (GNN) fault learning model; based on the link state between nodes in the accurate fault environment obtained, the fault environment corresponding to the policy subgraph is derived.

[0047] Preferably, step S6 includes the following steps:

[0048] Step S6.1: Classify network policies according to requirements and obtain network policy sets under different policy types;

[0049] Step S6.2: If it is necessary to verify the reachability of the network policy, use the depth-first search algorithm to determine whether there is a reachable path from the source node to the target node in the given policy subgraph, and limit the maximum search distance;

[0050] Step S6.3: If it is necessary to verify the isolation of the network policy, use the depth-first search algorithm to determine whether there is a reachable path from the source node to the target node in the given policy subgraph, and limit the maximum search distance, and invert the result;

[0051] Step S6.4: If it is necessary to verify the load balancing of the network strategy, then check whether there is a node whose reach distance does not exceed a certain multiple of the average shortest path length to ensure load balancing; where the average shortest path length is calculated by averaging the shortest path lengths from the source node to all other nodes.

[0052] Compared with the prior art, the beneficial effects of the present invention are:

[0053] 1. The network policy verification method based on GNN fault model learning utilizes GNN to learn the network environment. Compared with general verification methods, it can better learn the network performance and characteristics, thereby determining the accurate fault environment for the policy to be verified and achieving accurate network policy verification.

[0054] 2. The network policy verification method based on GNN fault model learning introduces a fault model during GNN learning and combines it with reinforcement learning, thereby reducing the impact of noise and erroneous data on the network policy verification results, thus improving the robustness of decision-making and making the network policy verification results more accurate.

[0055] 3. The network policy verification method based on GNN fault model learning uses K-Means clustering to assist GNN in network policy verification, which reduces the network size, makes the verification process faster, and effectively alleviates the state explosion problem of benchmark tools. Attached Figure Description

[0056] Figure 1 This is a schematic diagram of the process of the present invention;

[0057] Figure 2 This is a schematic diagram of the message passing mechanism used in this invention;

[0058] Figure 3 This is a computational diagram of the model structure based on GNN fault model learning used in this invention;

[0059] Figure 4This is a schematic diagram illustrating the network strategy expression form defined in this invention;

[0060] Figure 5 This is a comparison of the verification time of the present invention and the benchmark method when considering different maximum number of failures. Detailed Implementation

[0061] To make the objectives, technical solutions, and advantages of the embodiments of the present invention clearer, 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, 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.

[0062] like Figure 1 As shown, this invention provides a control plane policy verification method based on GNN fault model learning, which includes the following steps:

[0063] Step S1: Generate the corresponding fault model based on the network topology information and the maximum number of faults in the network as required.

[0064] Specifically, in this embodiment, step S1 includes:

[0065] First, network topology information is obtained from the publicly available configuration dataset of the Internet2 network in May 2015. This network topology includes 33 nodes and 96 edges. The degree of the nodes in this network topology is calculated as D∈R. n Sum-degree centrality of nodes C∈R n , where n represents the number of devices in the network topology (33). Using these two features as criteria, a K-Means clustering model is trained on the network topology to divide it into equivalence classes. The elbow rule is used to select the optimal number of equivalence classes as 8, and then a unique label and the corresponding topology graph are generated for each equivalence class.

[0066] Next, set the maximum number of faults k in the network topology according to requirements. max In this embodiment, we assume k max =1, at the maximum number of failures k max Under the constraints, all possible failure environments are enumerated. To avoid an explosion of numbers due to enumeration, the number of Monte Carlo simulations is set to num_simulations = 100, and the number of failure combinations to be simulated is set to num_combinations = 10. For each edge, the failure probability is calculated using Monte Carlo simulation and added to the corresponding failure environment feature vector.

[0067] Step S2: Design a GNN fault learning model based on a message-passing mechanism, employing a three-layer network structure, including: a linear transformation layer, a graph convolutional layer, and a fully connected layer. The model takes as input the original network topology adjacency matrix A∈R. n×n Fault model F∈R l×m (l represents the number of fault environments in the fault model, m represents the number of edges in the network), node centrality C∈R n And node degree D∈R n The common node features are used to output the probability distribution p of the failure probability among the nodes. ij .

[0068] Specifically, such as Figure 2 As shown, in this embodiment, the input dimension is N. in =96, the hidden layer dimension is N hid =16, the output dimension is N out =96, and the activation function used is the non-linear activation function ReLU. First, the input features undergo a linear transformation and the ReLU activation function to obtain the hidden layer features.

[0069] h i (1) =ReLU(W (1) x i +b (1) (1)

[0070] Among them W (1) It is the weight matrix of the input layer, with dimension [N] in N hid ], x i It is a dimension of [N] in N in The input features of b (1) It is the bias vector of the linear transformation layer, and its output is the feature vector h of the hidden layer. i (1) .

[0071] Next, the features from the first hidden layer are used as input and passed through a graph convolutional layer to obtain new hidden layer features:

[0072]

[0073] in Let c be the set of neighboring nodes of node i. ij W is the normalized coefficient between node i and node j. The aggregation function uses addition. (k) It is the weight matrix of the k-th graph convolutional layer. This represents the feature vector of node j in the (k-1)th graph convolutional layer. This represents the feature vector of node i in the k-th graph convolutional layer. For example... Figure 2 As shown, the neighboring nodes of the destination node sum up the features element by element according to certain rules and then transfer the information to the destination node. In order to take into account the amount of information of the source node itself, self-connection is used to connect the nodes themselves.

[0074] The third layer is a multilayer perceptron (MLP) layer consisting of three linear layers and two ReLU activation functions. It transforms the output of the graph convolutional layer into the final output, and then passes it through a softmax activation function to obtain the probability distribution of fault probabilities between nodes.

[0075] p ij =Softmax(W (L) h i (L-1) +b (L) (3)

[0076] in, and These are the weights and bias matrices of the fully connected layer, respectively, and the output p ij This represents the probability distribution of the failure probability between node i and node j.

[0077] Step S3: After designing the GNN model, train it. The overall computational graph is as follows: Figure 3 As shown, the training data comes from the original network topology. The mean squared error (MSE) loss function is used to measure the difference between the GNN model output and the adjacency matrix adj of the actual network topology. The Adam optimizer is used to update the model parameters.

[0078] Step S4: Generate a network policy diagram based on the network policy information that the administrator needs to verify.

[0079] Specifically, such as Figure 3 As shown, each network policy is represented by a 5-tuple, including: policy number, policy type, source device, destination device, and latency limit. The policy type includes: Reachiability (src, dst, delay): indicating that network traffic can reach dst from src, provided the latency limit is delayed; Isolation (src, dst): indicating that network traffic cannot reach dst from src; Loadbalancing (src, dst): indicating that network traffic from src to dst is load-balanced across at least two paths. Here, src represents the source device, dst represents the destination device, and delay represents the latency limit.

[0080] Next, a policy-directed graph G is constructed based on the network policy set, and G = (V, E); where V = {d | d = 1, ..., n} is the set of all physical devices in the network, where d ∈ V is the physical device with index d in the policy-directed graph; E = {e(a, b) | a, b ∈ V} is the set of policy state transitions between physical devices, where a represents the source device index, b represents the destination device index, and e(a, b) ∈ E indicates that there is a link between the device with index a and the device with index b, enabling network traffic to be transmitted from device a to device b.

[0081] Step S5: Preprocess the policy directed graph, extract feature data, input it into the trained GNN model, obtain the probability distribution of fault probabilities between feature nodes, and generate an accurate network environment.

[0082] Specifically, if the number of nodes or edges in the strategy graph is greater than the number of nodes or edges in the network topology, a pruning operation is performed, deleting nodes or edges in the strategy graph that do not exist in the original topology; if the number of nodes or edges in the strategy graph is less than the number of nodes or edges in the original topology, a filling operation is performed, adding virtual nodes or edges.

[0083] Next, the preprocessed policy graph is input into the trained K-Means model to partition the policy subgraph. Each policy subgraph corresponds to a network topology subgraph under a label, and the features of each policy subgraph are extracted.

[0084] Finally, the features of the extracted policy subgraph are input into the pre-trained GNN model under the corresponding label, and the output is processed. The transformation yields the connection probability between nodes. Next, binary classification is performed, introducing a threshold θ. Probabilities greater than this threshold are classified as 1, and probabilities less than or equal to this threshold are classified as 0.

[0085]

[0086] Here, Edge represents the state of each edge, i and j represent the source and destination devices of the edge, respectively, and the values ​​0 and 1 indicate whether the edge has a fault, with 0 indicating a fault and 1 indicating no fault. This represents the probability distribution of the connection probability between node i and node j obtained through GNN learning. Based on the obtained link states between nodes in the accurate fault environment, the fault environment corresponding to the policy subgraph can be derived.

[0087] Step S6: In an accurate fault environment, verify the network policies for different types of network policies respectively;

[0088] Specifically, network policies are categorized according to requirements to obtain policy sets for different policy types.

[0089] If it is necessary to verify the reachability of the strategy considering latency, a depth-first search algorithm is used to determine whether there is a reachable path from the source node to the target node in the given strategy subgraph, and the maximum search distance is limited.

[0090] If you need to verify the isolation of the strategy, the method is the same as for reachability; simply invert the final result.

[0091] If it is necessary to verify the load balancing of the strategy, it is done by checking whether there exists a node whose reach is no more than a certain multiple of the average shortest path length to ensure load balancing. The average shortest path length is obtained by calculating the shortest path lengths from the source node to all other nodes and then averaging them.

[0092] In summary, this invention proposes a control plane strategy verification method based on GNN fault model learning, such as... Figure 4 As shown, with the increase of the maximum number of faults, the present invention, compared with the benchmark method, can quickly locate the accurate environment in which the policy to be verified exists under complex fault models, achieving accurate and rapid network policy verification. Furthermore, this method has a certain generalization ability and is applicable to the verification of different network policies under various network topologies.

[0093] Any aspects of this invention not described in detail are well-known to those skilled in the art.

[0094] The preferred embodiments of the present invention have been described in detail above. It should be understood that those skilled in the art can make numerous modifications and variations based on the concept of the present invention without creative effort. Therefore, all technical solutions that can be obtained by those skilled in the art based on the concept of the present invention through logical analysis, reasoning, or limited experimentation on the basis of existing technology should be within the scope of protection defined by the claims.

Claims

1. A control plane strategy verification method based on GNN fault model learning, characterized in that, Includes the following steps: Step S1: Obtain network topology information, use K-Means clustering to divide equivalence classes, reduce the network size, and set the maximum number of faults in the network according to requirements to generate the corresponding fault model; Step S2: Design a GNN fault learning model based on message passing mechanism. The model includes a linear transformation layer, a graph convolutional layer and a fully connected layer. The input is the adjacency matrix of the network topology and the corresponding fault model. The output is the probability distribution of fault probabilities between feature nodes. Step S3: Train a GNN fault learning model based on message passing mechanism for each equivalence class, and use the trained graph neural network (GNN) fault learning model for network policy verification. Step S4: Collect network policy information that the administrator needs to verify, generate a network policy set according to the requirements, and construct a network policy diagram that conforms to the network topology characteristics. Step S5: Preprocess the policy directed graph, extract feature data, and input it into the trained graph neural network (GNN) fault learning model to obtain the probability distribution of fault probabilities between feature nodes and generate an accurate network environment. Step S6: In an accurate network environment, verify the network policies according to the network policy categories to obtain the final verification results.

2. The control plane strategy verification method based on GNN fault model learning according to claim 1, characterized in that, Step S1 includes the following steps: Step S1.1: Obtain network topology information, calculate node degree and degree centrality, train K-Means clustering model to divide equivalence classes using node degree and degree centrality, select the optimal number of clusters as the optimal number of categories for equivalence classes using the elbow rule, and generate a unique label and corresponding topology graph for each equivalence class. Step S1.2: Set the maximum number of faults k in the network topology according to requirements. max Generate a failure model based on Monte Carlo simulation: Failure_model = {env1,...env q }, where env q This represents each possible failure environment, and the failure probability P is calculated using Monte Carlo simulation in each possible failure environment. fail ; Assuming the probability of a fault occurring on an edge (u,v) of the topological graph in step S1.1 is p, then in k max Within one step, the failure probability P fail Represented by a binomial distribution: in Indicates that in k max Within a step, q (0≤q≤k) occurs. max The number of combinations of failures; the failure probability P. fail Indicates the maximum number of failures k max The probability of an edge (u,v) failing.

3. The control plane strategy verification method based on GNN fault model learning according to claim 2, characterized in that, In step S2: Construct a graph neural network (GNN) fault learning model, which includes a linear transformation layer, a graph convolutional layer, and a fully connected layer: The linear transformation layer: h i (1) =σ(W (1) x i +b (1) ) (2) Where: h i (1) W is the feature vector of the hidden layer, σ is the ReLU activation function, and W is the feature vector of the hidden layer. (1) ∈R din×dout It is the weight matrix of the input layer, x i ∈R din b is the input feature vector of node i. (1) It is the bias vector of the linear transformation layer; The graph convolutional layer: h i (k) =AGGREGATE j∈N(i) (W (k) h j (k-1) )(3) in: Let be the set of neighboring nodes of node i, and AGGREGATE represent the aggregation function. It is the weight matrix of the k-th graph convolutional layer. This represents the feature vector of node j in the (k-1)th graph convolutional layer. This represents the feature vector of node i in the k-th graph convolutional layer; The fully connected layer: h i (L) =W (L) h i (L-1) +b (L) (4) Among them: W (L) ∈R dout×dout and These are the weights and bias matrices of the fully connected layer. This represents the feature vector output by node i in the fully connected layer; Then the feature vector The final probability distribution of the failure probability is obtained by using a softmax activation function: Where: h ij (L) h represents the characteristic value representing the failure probability between node i and node j in the fully connected layer. im (L) p represents the m-th feature of the i-th node in the fully connected layer output. ij This represents the probability distribution of the failure probability between node i and node j.

4. The control plane strategy verification method based on GNN fault model learning according to claim 3, characterized in that, In step S3: The graph neural network (GNN) fault learning model uses the mean squared error (MSE) loss function during training. Where output is the output of the graph neural network (GNN) fault learning model, and adj is the adjacency matrix of the actual network topology.

5. The control plane strategy verification method based on GNN fault model learning according to claim 4, characterized in that, Step S4 includes the following steps: Step S4.1: Generate a network policy set according to requirements. The network policy set includes: policy number, policy type, source device, destination device, and latency limit. The policy type includes: policy reachability, policy isolation, and policy load balancing, represented by Reachiability(src,dst,delay), Isolation(src,dst), and Loadbalancing(src,dst), respectively. Here, src represents the source device, dst represents the destination device, and delay represents the latency limit. Reachiability(src,dst,delay) indicates that network traffic reaches dst from src under the latency limit delay. Isolation(src,dst) indicates that network traffic does not reach dst from src. Loadbalancing(src,dst) indicates that network traffic from src to dst is load balanced on at least two paths. Step S4.2: Construct a policy-directed graph G based on the network policy set, and G = (V, E); where V = {d | d = 1, ..., n} is the set of all physical devices in the network, and d ∈ V is the physical device with index d in the policy-directed graph; E = {e(a, b) | a, b ∈ V} is the set of policy state transitions between physical devices, where a represents the source device index, b represents the destination device index, and e(a, b) ∈ E indicates that there is a link between the device with index a and the device with index b, which allows network traffic to be transmitted from device a to device b.

6. The control plane strategy verification method based on GNN fault model learning according to claim 5, characterized in that, Step S5 includes the following steps: Step S5.1: Preprocess the policy-directed graph G using a combination of pruning and padding: If the number of nodes or edges in the policy-directed graph G is greater than the number of nodes or edges in the original network topology, perform a pruning operation to delete nodes or edges in the policy-directed graph G that do not exist in the original network topology, until the size of the policy-directed graph G is the same as the original network topology; if the number of nodes or edges in the policy-directed graph G is less than the number of nodes or edges in the original network topology, perform a padding operation to add virtual nodes or edges, until the size of the policy-directed graph G is the same as the original network topology. Step S5.2: Input the preprocessed policy directed graph G into the trained K-Means clustering model, divide the policy directed graph G into policy subgraphs, each policy subgraph corresponds to a network topology subgraph under a label, and extract the features of each policy subgraph. Step S5.3: Input the features of the extracted policy subgraph into the pre-trained Graph Neural Network (GNN) fault learning model under the corresponding label, and process the output results. The transformation is then performed, followed by binary classification; a threshold θ is introduced, with probabilities greater than the threshold classified as 1 and probabilities less than or equal to the threshold classified as 0, i.e.: Here, Edge represents the state of each edge, i and j represent the source and destination devices of the edge, respectively, and the values ​​0 and 1 indicate that the edge has failed and has not failed, respectively. This represents the probability distribution of the connection probability between node i and node j learned through the graph neural network (GNN) fault learning model; based on the link state between nodes in the accurate fault environment obtained, the fault environment corresponding to the policy subgraph is derived.

7. The control plane strategy verification method based on GNN fault model learning according to claim 6, characterized in that, Step S6 includes the following steps: Step S6.1: Classify network policies according to requirements and obtain network policy sets under different policy types; Step S6.2: If it is necessary to verify the reachability of the network policy, use the depth-first search algorithm to determine whether there is a reachable path from the source node to the target node in the given policy subgraph, and limit the maximum search distance; Step S6.3: If it is necessary to verify the isolation of the network policy, use the depth-first search algorithm to determine whether there is a reachable path from the source node to the target node in the given policy subgraph, and limit the maximum search distance, and invert the result; Step S6.4: If it is necessary to verify the load balancing of the network strategy, then check whether there is a node whose reach distance does not exceed a certain multiple of the average shortest path length to ensure load balancing; where the average shortest path length is calculated by averaging the shortest path lengths from the source node to all other nodes.

Images