Multi-target network disintegration method, system, equipment and medium

Abstract

The invention relates to a multi-target network disintegration method, system and device and a medium, and the method comprises the steps: decomposing a multi-target network disintegration problem into a plurality of standard sub-problems, and defining a corresponding weight vector for each sub-problem; for each standard quantum problem, a corresponding neural network model is constructed based on the weight vector of the standard quantum problem, and the neural network model comprises an encoder and a decoder; performing feature extraction on nodes of a target network by using the encoder to generate corresponding node embedding vectors; calculating the selection probability of each node based on the node embedding vector through the decoder in combination with an attention mechanism; according to the selection probability, nodes are selected and removed step by step through a greedy strategy, and a solution of the standard quantum problem is generated; and traversing the solutions of all the standard quantum problems, and screening out a solution set meeting the Pareto optimal condition as a final disintegration strategy. According to the method, a more accurate model is obtained by weakening the network functionality to the maximum degree and minimizing the collapse cost at the same time.

Description

Technical Field

[0001] The present invention relates to the field of network science and technology, and in particular to a multi-target network disintegration method, system, equipment and medium. Background Art

[0002] With the rapid development of network science, complex networks are widely used to describe interactive systems in social, biological, and technological fields. However, some networks (such as terrorist networks, rumor-mongering networks, and financial risk networks) pose serious threats to society, and effective network dismantling strategies are urgently needed to weaken their functionality. The core of network dismantling is to minimize network connectivity and functionality by removing key nodes or edges. This task is essentially a combinatorial optimization problem.

[0003] Traditional network disruption research focuses on a single optimization objective, such as using disruption effectiveness (such as the extent of the decrease in network connectivity) as the only optimization indicator, while converting other factors (such as cost) into constraints. Although such methods simplify the problem model, they are difficult to meet the needs of multi-objective trade-offs in actual scenarios. For example, in real-world applications, decision makers need to consider both disruption effects and resource costs: efficient disruption strategies may come with high costs, while low-cost strategies may have limited effects. In addition, traditional methods usually use heuristic algorithms (such as genetic algorithms, simulated annealing) or multi-objective evolutionary algorithms to approximate Pareto optimal solutions through iterative searches. However, such methods have significant drawbacks:

[0004] Low computational efficiency: High-dimensional problems require a large number of iterations, resulting in computational time that grows exponentially with network size, making it difficult to meet the real-time requirements of large-scale networks.

[0005] Poor dynamic adaptability: When the network structure changes dynamically (such as the addition or removal of nodes), traditional methods need to re-search the solution space, which lacks robustness;

[0006] Insufficient handling of goal conflicts: The dimensional differences and nonlinear relationships among multiple objectives make it difficult for the simple weighted combination of objective functions to reflect the true trade-off relationship.

[0007] In recent years, deep reinforcement learning (DRL) has demonstrated promising potential in combinatorial optimization. Combining the feature extraction capabilities of deep learning with the sequential decision-making advantages of reinforcement learning, it can efficiently explore high-dimensional solution spaces. However, existing DRL methods are still limited to single-objective optimization in network collapse tasks and fail to fully exploit the potential of multi-objective collaborative optimization. Furthermore, existing algorithms typically rely on pre-trained models with fixed network structures, making them difficult to adapt to dynamic network environments, limiting their scalability in practical application scenarios. Summary of the Invention

[0008] The present invention provides a multi-objective network disintegration method, system, device and medium, which aims to solve the problems of low computational efficiency, poor dynamic adaptability and insufficient multi-objective conflict handling in traditional network disintegration methods when optimizing disintegration effect and cost simultaneously.

[0009] To achieve the above object, the present invention provides a multi-target network collapse method in a first aspect, comprising the following steps:

[0010] Decompose the multi-objective network collapse problem into multiple scalar subproblems and define the corresponding weight vector for each subproblem;

[0011] For each scalar subproblem, a corresponding neural network model is constructed based on its weight vector, wherein the neural network model includes an encoder and a decoder;

[0012] Using the encoder to extract features from nodes of the target network and generate corresponding node embedding vectors;

[0013] Calculating the selection probability of each node based on the node embedding vector by combining the decoder with an attention mechanism;

[0014] According to the selection probability, nodes are gradually selected and removed using a greedy strategy to generate a solution to the scalar subproblem;

[0015] Traverse the solutions of all scalar subproblems and select the solution set that meets the Pareto optimality condition as the final collapse strategy.

[0016] Furthermore, the multi-objective network collapse problem is decomposed into multiple scalar subproblems, and the method of defining the corresponding weight vector for each subproblem includes:

[0017] Generate a set of uniformly distributed weight vectors Each weight vector satisfy

[0018] For each weight vector λ j , the weighted sum method is applied to transform the multi-objective optimization problem into a scalar optimization sub-problem, and its objective function is defined as:

[0019]

[0020] Among them, X represents the network collapse strategy, that is, the set of nodes that need to be removed, g ws (X|λ j ) is the objective function, which means that given the weight parameter λ j The optimization target value under this condition is, C(X) is the collapse cost, that is, the cost required to remove the node, Γ(X) is the collapse effect, It means that the goal is to minimize the loss function after trade-off and find the optimal collapse strategy. and Respectively represent the weight coefficients of disintegration cost and disintegration effect;

[0021] A corresponding scalar subproblem is defined by each weight parameter in the weight vector set, so that a solution of each scalar subproblem corresponds to a candidate solution on the Pareto front of the multi-objective problem.

[0022] Furthermore, the method for generating the node embedding vector includes:

[0023] Obtaining the adjacency matrix of the target network and attribute information of each node, wherein the attribute information includes the node's degree, cost-sensitive parameters, and connection relationship with other nodes;

[0024] Inputting the adjacency matrix and node attribute information into a fully connected neural network layer of an encoder to generate an initial node feature vector;

[0025] Serializing the initial node feature vectors through multi-layer gated recurrent units to capture the topological dependencies between nodes and generate intermediate node embedding vectors;

[0026] A multi-head attention mechanism is introduced to perform context-aware weighting on the intermediate node embedding vectors, fuse the global network structure information, and output the final node embedding vectors.

[0027] Furthermore, the calculation method of the selection probability includes:

[0028] Step S31: Initialize the hidden state of the decoder and take the embedding vector of the current candidate node pool as input;

[0029] Step S32: In each decoding step, the attention scores of all candidate nodes are calculated through the attention mechanism based on the current hidden state of the decoder and the node embedding vector;

[0030] Step S33: Apply a masking operation to the removed nodes and set their attention scores to negative infinity to exclude duplicate selections;

[0031] Step S34: normalize the masked attention scores using the softmax function to generate the selection probability distribution of each node;

[0032] Step S35: Select the optimal node of the current step according to the probability distribution to remove, update the hidden state of the decoder, and iterate until the preset node removal quantity constraint is reached.

[0033] Furthermore, the calculation formula of the attention score is:

[0034] ut =Attention(h t-1 ,e i )

[0035] Among them, u t represents the unnormalized attention score of the candidate node in the t-th decoding step, Attention(·) represents the attention function, and h t-1 Denote the hidden state vector of the decoder at step t-1, e i is the embedding vector of the i-th node;

[0036] The normalized selection probability distribution is generated by the following formula:

[0037] p(v t |v1,v2,…,v t-1 )=softmax(u t +mask t )

[0038] Among them, p(·) represents the probability distribution of selecting a node in step t, v t Indicates the set of nodes removed from step 1 to step t-1 during the decoding process, softmax(·) represents the normalization function, and mask t is a mask vector that is set to negative infinity at the positions of removed nodes and to 0 at all other positions to prevent duplicate selection.

[0039] Furthermore, methods for gradually selecting and removing nodes using a greedy strategy to generate solutions to scalar subproblems include:

[0040] Step S51: Initialize the candidate node pool to be the set of all nodes in the network that have not been removed, and set the number of currently removed nodes to 0;

[0041] Step S52: According to the generated selection probability distribution, select the node with the highest current probability value as the node to be removed;

[0042] Step S53: permanently remove the node to be removed from the candidate node pool, and update the number of removed nodes;

[0043] Step S54: Input the information of the removed node into the decoder, and update its hidden state to reflect the new state after the network topology changes;

[0044] Step S55: Repeat steps S32 to S54 until the number of removed nodes reaches a preset maximum constraint value, and output the solution to the current scalar subproblem.

[0045] Furthermore, the method further includes training the neural network model, and the training method includes:

[0046] Step S21: decompose the multi-objective network collapse problem into multiple scalar subproblems, each scalar subproblem corresponds to a weight vector;

[0047] Step S22: Initialize the neural network model parameters of the first scalar subproblem, including the weight matrices of the encoder, decoder, and attention mechanism;

[0048] Step S23: Using the Actor-Critic algorithm to train the first scalar subproblem, and optimizing the neural network model parameters through back propagation until convergence conditions are reached;

[0049] Step S24: Based on the neighborhood parameter transfer strategy, the neural network model parameters after training the i-1 scalar subproblem are used as the initial parameters of the i th subproblem, and step S63 is repeated for iterative training;

[0050] Step S25: traverse all scalar subproblems until the neural network model parameters of all scalar subproblems are trained to obtain a trained neural network model.

[0051] To achieve the above objectives, the second aspect of the present invention provides a multi-target network disruption system, comprising the following modules:

[0052] Decomposition module, used to decompose the multi-objective network collapse problem into multiple scalar subproblems and define the corresponding weight vector for each subproblem;

[0053] A model building module is used to build a corresponding neural network model for each scalar subproblem based on its weight vector, wherein the neural network model includes an encoder and a decoder;

[0054] An encoding module, integrated into the encoder, configured to extract features from nodes of the target network using the encoder and generate corresponding node embedding vectors;

[0055] A decoding and attention calculation module, integrated into the decoder, for calculating the selection probability of each node based on the node embedding vector by combining the decoder with an attention mechanism;

[0056] A node selection module, configured to gradually select and remove nodes using a greedy strategy according to the selection probability, to generate a solution to the scalar subproblem;

[0057] The Pareto solution set screening module is used to traverse the solutions of all scalar subproblems and select the solution set that meets the Pareto optimality condition as the final collapse strategy;

[0058] The training module is used to perform end-to-end training of neural network models using the Actor-Critic algorithm and accelerate the optimization of neural network model parameters for multi-scale quantum problems based on the neighborhood parameter transfer strategy;

[0059] The storage module is used to store the trained neural network model parameters, network topology data and the generated Pareto optimal solution set.

[0060] To achieve the above objectives, the third aspect of the present invention provides an electronic device, including a memory and a processor, wherein the memory is used to store a program that supports the processor to execute the multi-target network disintegration method, and the processor is configured to execute the program stored in the memory.

[0061] To achieve the above-mentioned object, the third aspect of the present invention provides a computer-readable storage medium, on which a computer program is stored. When the computer program is executed by a processor, the steps of the multi-target network disintegration method are executed.

[0062] Beneficial effects of the present invention:

[0063] Compared with the prior art, the present invention provides a multi-objective network collapse method, system, device and medium. First, by adopting a decomposition strategy, the multi-objective network collapse problem is converted into multiple scalar subproblems. Each subproblem clearly weighs the conflicting goals of collapse effect and cost through a weight vector, avoiding the limitation of the traditional method of simply merging goals. Secondly, an independent neural network model (encoder-decoder structure) is designed for each subproblem. The encoder is used to extract network topology features and generate node embedding vectors. The decoder combined with the attention mechanism dynamically calculates the node selection probability and efficiently generates candidate solutions through a greedy strategy, significantly reducing the search complexity of the high-dimensional solution space and improving computational efficiency. In addition, through the end-to-end deep reinforcement learning framework and parameter transfer strategy, the model can quickly adapt to the dynamic changes of the network structure (such as node addition and subtraction) and generate robust solutions without retraining, solving the problem of poor dynamic adaptability of traditional methods. Finally, by integrating the Pareto optimal solution set of all subproblems, the present invention achieves efficient and real-time collapse strategy generation for large-scale complex networks while ensuring multi-objective collaborative optimization. BRIEF DESCRIPTION OF THE DRAWINGS

[0064] In order to more clearly illustrate the technical solutions in the embodiments of the present invention, the following briefly introduces the drawings required for describing the embodiments.

[0065] Figure 1 The present invention discloses a flowchart of a multi-target network collapse method.

[0066] Figure 2This is a diagram of two different multi-target network collapse strategies disclosed in an embodiment of the present invention.

[0067] Figure 3 This is a framework diagram of a DRL-MND solution to the multi-objective network collapse problem disclosed in an embodiment of the present invention.

[0068] Figure 4 It is a neural network structure diagram for solving the multi-objective network collapse problem disclosed in an embodiment of the present invention.

[0069] Figure 5 This is a schematic diagram of a neighborhood-based sub-problem model parameter transfer strategy disclosed in an embodiment of the present invention.

[0070] Figure 6 It is a Pareto front (p=1) diagram of an algorithm disclosed in an embodiment of the present invention when solving the SF network collapse problem of different scales.

[0071] Figure 7 It is a Pareto front (p=1) diagram of an algorithm disclosed in an embodiment of the present invention when solving the BA network collapse problem of different scales.

[0072] Figure 8 It is a Pareto front (p=2) diagram of an algorithm disclosed in an embodiment of the present invention when solving the SF network collapse problem of different scales.

[0073] Figure 9 This is a diagram of the HV value and speed of an algorithm disclosed in an embodiment of the present invention. DETAILED DESCRIPTION

[0074] In order to enable those skilled in the art to better understand the solutions of the present invention, the technical solutions in the embodiments of the present invention will be clearly and completely described below in conjunction with the drawings in the embodiments of the present invention. Obviously, the embodiments described are only part of the embodiments of the present invention, not all of the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by ordinary technicians in this field without making creative efforts should fall within the scope of protection of the present invention.

[0075] According to an embodiment of the present invention, 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 following production method, in some cases, the steps shown or described can be executed in an order different from that shown here.

[0076] like Figure 1As shown, the present invention provides a multi-objective network collapse method. Through a deep reinforcement learning framework, the multi-objective network collapse problem is decomposed into multiple scalar subproblems, and a neural network and attention mechanism are used to dynamically generate Pareto optimal solutions, thereby ensuring the collapse effect while minimizing the cost. The specific implementation process includes the following steps:

[0077] Step S1: Decompose the multi-objective network collapse problem into multiple scalar subproblems, and define a corresponding weight vector for each subproblem;

[0078] Multi-objective network collapse problems typically involve multiple optimization objectives, such as collapse effectiveness and collapse cost. Because these objectives may conflict—improving collapse effectiveness may require higher costs, while reducing costs may reduce effectiveness—directly solving multi-objective problems can be complex. Therefore, a decomposition method is first used to transform the original problem into a series of scalar subproblems, each representing a specific combination of objectives. Specifically, this decomposition step employs a weighted sum approach, defining a corresponding weight vector for each subproblem. These weight vectors are used to transform the multi-objective problem into multiple scalar optimization problems. For example, if the weight vector of a scalar subproblem is (0.8, 0.2), this indicates that optimizing the collapse effectiveness accounts for 80% of the weight in this scalar subproblem, while optimizing the collapse cost accounts for 20%. By adjusting these weights, multiple different scalar subproblems can be generated, each focusing on a different objective trade-off.

[0079] First, generate a set of uniformly distributed weight vectors Each weight vector corresponds to a scalar subproblem, where each objective (such as disruption cost and disruption effect) has a corresponding weight. Assuming there are multiple scalar subproblems in the method, the weight vector λ j is a two-dimensional vector in, and Represent the weight coefficients of the disruption cost and disruption effect respectively, and meet the following conditions:

[0080]

[0081] In this way, all weight vectors weight the two objectives differently, ensuring a different optimization combination for each objective. The distribution of these weight vectors can be uniform or adjusted according to the needs of the problem. In this way, it is guaranteed that the solution to each scalar subproblem corresponds to a different solution to the original multi-objective problem, thus obtaining a diverse set of solutions that contain optimization trade-offs for multiple objectives.

[0082] For each weight vector λ j, the weighted sum method is used to transform the multi-objective optimization problem into a scalar optimization sub-problem, and its objective function is defined as:

[0083]

[0084] Among them, X represents the network collapse strategy, that is, the set of nodes that need to be removed, g ws (X|λ j ) is the objective function, which means that given the weight parameter λ j The optimization target value under this condition is, C(X) is the collapse cost, that is, the cost required to remove the node, Γ(X) is the collapse effect, It means that the goal is to minimize the loss function after trade-off and find the optimal collapse strategy. and Represent the weight coefficients of disintegration cost and disintegration effect respectively.

[0085] The weighted sum method combines the two objectives (cost and effectiveness) into a single objective, allowing each sub-problem to optimize its collapse strategy according to its corresponding weight. This approach ensures multi-objective optimization while making each sub-problem simpler and easier to solve.

[0086] Through the weighted sum method mentioned above, the original multi-objective optimization problem is transformed into multiple scalar optimization sub-problems. Each sub-problem corresponds to a weight vector, and the objective function of each sub-problem will weigh the cost and effect of collapse. In other words, the goal of the scalar sub-problem is to minimize g by choosing an appropriate collapse strategy. ws (X|λ j ), where g ws (X|λ j ) includes the disruption cost C and the disruption effect Γ.

[0087] The optimal solution sets of these scalar subproblems can provide multiple solutions, which can help decision makers find the optimal disruption strategy under different trade-offs. By traversing the solutions of these scalar subproblems, we can ultimately select the solution set that meets the Pareto optimality condition and use it as the final network disruption strategy.

[0088] For example, in Figure 2 Among the strategies shown, strategy 1 removes the node set {v4, v6}, with a cost of C(X1) = 0.36 and a disruption effect of Γ(X1) = 0.37; strategy 2 removes the node set {v5, v9}, with a cost of C(X2) = 0.14 and a disruption effect of Γ(X2) = 0.91.

[0089] It's understandable that Strategy 1 (λ = (0.8, 0.2)) achieves a good disruption effect (Γ = 0.37) at a higher cost (C = 0.6), while Strategy 2 (λ = (0.2, 0.8)) sacrifices effectiveness (Γ = 0.19) at a lower cost (C = 0.14). The decomposed subproblems clarify the trade-offs between objectives through weight vectors, avoiding the limitations of traditional methods that simply merge objectives. It can be seen that different disruption strategies require different disruption costs and produce different results.

[0090] It is worth noting that the cost of disrupting strategy X is calculated as follows:

[0091]

[0092] Among them, c i is the unit collapse cost of the i-th node, r i represents the degree of node i, which indicates the number of connections of the node, N is the total number of nodes in the network, and p is a cost-sensitive parameter. When p = 1, the cost is uniform. As p increases, the cost of disintegrating nodes with larger degrees is higher. C(X) is the total disintegration cost corresponding to the disintegration strategy X, x i Indicates whether the node is removed. If x i =1, then remove the node, if x i =0, then keep the node.

[0093] The disruption effect of disruption strategy X is calculated as follows:

[0094]

[0095] Among them, Γ(X) is the collapse effect of the collapse strategy X, is the network after executing strategy X, G is the original network. Obviously, the smaller the value of Γ(X), the better the collapse effect.

[0096] The constraints are:

[0097]

[0098] Among them, Q is the total number of nodes removed, that is, the number of nodes included in the collapse strategy; X i It is a binary variable that determines whether to remove the i-th node, 1 represents removal and 0 represents retention.

[0099] Step S2: for each scalar subproblem, construct a corresponding neural network model based on its weight vector, wherein the neural network model includes an encoder and a decoder;

[0100] Based on the weight vectors for each scalar subproblem generated in step S1, a neural network model corresponding to each subproblem is further constructed. Specifically, for each scalar subproblem, the neural network model consists of two parts: an encoder and a decoder. The goal is to solve each subproblem through a neural network and ultimately generate the optimal collapse strategy.

[0101] Encoder: Responsible for extracting network topology features and generating node embedding vectors. The encoder consists of a fully connected layer, a gated recurrent unit (GRU), and a multi-head attention mechanism (such as Figure 4 The input data includes the adjacency matrix A(G) of the target network, node attributes (such as degree k i , cost-sensitive parameters p, etc.) The original node attributes are mapped to the initial feature vector γ={γ i ,i=1,2,…,N}(represents node v i The initial features are serialized using multi-layer GRU to capture the dynamic dependencies between nodes. In the global fusion stage, a multi-head attention mechanism is introduced to context-weight the intermediate embedding vectors output by GRU to generate the final node embedding vector E = {e1, e2, ..., e N}.

[0102] Decoder: Dynamically generates node removal strategies based on the attention mechanism. The decoder uses a GRU structure and combines mask operations to avoid repeated node selection (such as Figure 4 As shown). The initial hidden state is obtained by aggregating the global embedding vector of the encoder, and the candidate node pool is initialized to all nodes that have not been removed. In the t-th decoding step, the candidate node v is calculated i The attention score u t ; Apply a mask (set to negative infinity) to the attention scores of the removed nodes and generate a selection probability distribution through softmax.

[0103] The weight vector for each subproblem Directly affects the definition of the objective function. During the model training phase, the weight parameters are passed through the Actor-Critic framework (such as Figure 3 ) is integrated into the reward function design to drive the neural network to learn the optimal strategy under specific trade-offs.

[0104] For example, when When it is large (biased towards cost minimization), the decoder tends to select nodes with low selectivity and low removal cost; otherwise, When it is large (maximum bias effect), the decoder preferentially removes high-degree nodes to destroy network connectivity (e.g. Figure 2 Comparison between Strategy 1 and Strategy 2).

[0105] Neural network model parameters of adjacent sub-problems are shared through neighborhood parameter transfer strategies (e.g. Figure 5 ). Assume that the model parameters of the j-1th sub-problem have been trained, and its parameters This strategy uses the continuity of the weight vector on the Pareto front (e.g., a gradual transition from (1,0) to (0,1)) to ensure smooth adjustment of model parameters and avoid the computational overhead of repeated training.

[0106] It is understandable that the encoder-decoder architecture directly maps the network topology to the collapse strategy, avoiding the iterative search process of the traditional heuristic algorithm, flexibly defining the sub-problem goals through the weight vector, and dynamically adjusting the node selection preference in combination with the attention mechanism to achieve an accurate balance between effect and cost; and the parameter transfer strategy significantly reduces The independent training time of each sub-problem is shortened, improving the practicality in large-scale network scenarios.

[0107] Step S3: Using the encoder to extract features from the nodes of the target network and generate corresponding node embedding vectors;

[0108] The encoder's task is to extract features from the target network's nodes and convert each node's features into a node embedding vector. During this process, the encoder first inputs the target network's adjacency matrix and each node's attribute information into the neural network. Node attributes include the node's degree (i.e., the number of other nodes connected to it), a cost-sensitive parameter (the cost of removing the node), and its connection relationships with other nodes. Using this information, the encoder can map each node's features into a high-dimensional space, generating the corresponding node embedding vector.

[0109] The target network can be described as an unweighted undirected graph G = (V, E), where V and E represent the set of nodes and edges respectively. Let N = |V| and W = |E| represent the number of nodes and edges in the network respectively, and express the adjacency matrix of G as A(G) = (a ij ) N×N Before extracting the features of the nodes of the target network, first obtain the adjacency matrix A(G)=(a ij ) N×N , where a ij =1 indicates node v i With v j There is a connection, otherwise a ij =0.

[0110] Extract each node v i Attribute information, including the node degree k i, cost-sensitive parameter p, and connection patterns with other nodes (such as the degree distribution of neighboring nodes).

[0111] The node attributes (such as k i and p) input the encoder’s fully connected neural network layer and map it to the initial feature vector; the original attributes are mapped to the initial node feature vector γ through nonlinear transformation i ; Input the initial feature vector sequence into the multi-layer gated recurrent unit (GRU), and capture the topological dependencies between nodes through its recurrent structure (such as Figure 4 As shown). The mathematical expression of GRU is:

[0112] z t =σ g (W z x t +U z h t-1 +b z )

[0113] r t =σ g (W r x t +U r h t-1 +b r )

[0114]

[0115] Among them, z t represents the update gate, which is used to control how many copies of the current state come from the hidden state of the previous moment and how many come from the current input; r t Represents the reset gate, which is used to control how many copies of the hidden state from the previous moment are used to generate the candidate hidden state at the current moment; h t is the current hidden state; represents the candidate hidden state (candidate output) at the current moment; X t is the input feature at the current moment; h t-1 Indicates the hidden state at the previous moment; W z 、U z 、W r 、U r 、W h 、U h is the weight matrix, respectively with the input feature x t and the hidden state h at the previous moment t-1 Multiplication, control the calculation of update gate, reset gate and candidate hidden state; b z 、b r and b h are bias terms, respectively related to the calculation of the update gate, reset gate and candidate hidden state; σg Represents the sigmoid activation function, which is used to generate an output between 0 and 1 to control the flow of information; φ h Denotes the tanh activation function, used to calculate candidate hidden states; ⊙ denotes element-wise multiplication. The GRU preserves long-term dependencies through a gating mechanism and generates intermediate node embedding vectors.

[0116] The multi-head attention mechanism is introduced to perform context-aware weighting on the intermediate node embedding vector. Specifically, the intermediate node embedding vector output by the GRU is divided into multiple heads (e.g., 8 heads), each head independently calculates the attention weight, and finally concatenates and linearly transforms it into a globally aware node embedding vector E = {e1, e2, ..., e N This process combines local node attributes with global topological information. For example, the embedding vector of a high-centrality node will contain more key features of the network structure.

[0117] Step S4: Calculate the selection probability of each node based on the node embedding vector by combining the decoder with the attention mechanism;

[0118] The task of the decoder is to calculate the selection probability of each node through the attention mechanism based on the node's embedding vector, that is, to decide which nodes should be removed.

[0119] This step dynamically evaluates the importance of candidate nodes through the synergy between the decoder and the attention mechanism, generates a normalized selection probability distribution, and thus guides the order of node removal. The specific implementation method is as follows:

[0120] The initial hidden state of the decoder is initialized by the global network features output by the encoder (such as the mean of all node embedding vectors), ensuring that the decoding process can perceive the overall network state (such as Figure 4 The decoder structure shown in Figure 2). The node embedding vector E of the candidate node pool is E={e1,e2,...,e N} as the input sequence of the decoder.

[0121] At each decoding step t, the current hidden state h of the decoder is t The unnormalized attention score is calculated by the attention function with the candidate node embedding vector:

[0122] u t =Attention(h t-1 ,e i )

[0123] Among them, u t represents the unnormalized attention score of the candidate node in the t-th decoding step, Attention(·) represents the attention function, and h t-1Denote the hidden state vector of the decoder at step t-1, e i is the embedding vector of the i-th candidate node; the attention function can be an inner product, additive model, etc., and a multi-head attention mechanism can be adopted.

[0124] Apply the mask vector to the removed nodes and set the attention scores corresponding to the removed nodes to negative infinity (i.e. ), thereby excluding repeated selections in the probability distribution (e.g. Figure 2 Once the middle node v4 is removed, its probability is forced to zero in subsequent steps).

[0125] The masked attention scores are normalized by the softmax function to generate the selection probability distribution of each candidate node:

[0126] p(v t |v1,v2,…,v t-1 )=softmax(u t +mask t )

[0127] Among them, p(·) represents the probability distribution of selecting a node in step t, v t Indicates the set of nodes removed from step 1 to step t-1 during the decoding process, softmax(·) represents the normalization function, and mask t is a mask vector that is set to negative infinity when acting on the position of the removed node and to 0 for the remaining positions to prevent repeated selection. This probability distribution reflects the contribution of each node to the optimization objective under the current network state.

[0128] The node with the highest current probability is selected for removal using a greedy strategy. For example, Figure 2 In the collapse strategy, if the probability of node v5 is the highest at step t=1 (assuming λ j Focus on low cost), then remove v5 first and update the decoder's hidden state h t+1 To reflect changes in network topology.

[0129] It is understandable that the decoder, through iterative updates of the hidden state, captures the impact of node removal on network functionality (such as decreased connectivity) in real time, avoiding the short-sightedness of traditional static heuristic strategies. The attention mechanism, combined with masking operations, ensures that the node selection process strictly adheres to the "no repeated removal" constraint, avoiding invalid operations. The probability distribution is directly linked to the objective function of the subproblem, ensuring that node selection always focuses on optimizing a specific weight vector.

[0130] Step S5: According to the selection probability, gradually select and remove nodes using a greedy strategy to generate a solution to the scalar subproblem;

[0131] It should be noted that the greedy strategy is a strategy that gradually selects the local optimal solution. In each step, the current best node is selected and removed until the predetermined goal is achieved. The specific operation of the greedy strategy is as follows:

[0132] Initialize to the set of all nodes in the network that have not been removed. Initialize to 0, that is, Q = 0, and set the maximum number of removed nodes constraint Q max (For example Figure 2 Strategy 1 removes 2 nodes).

[0133] In each step t, according to the selection probability distribution p(v t |v1,v2,…,v t-1 ), select the node with the highest current probability value. For example, Figure 2 In strategy 2, if λ j Focus on low cost Then the node v5 with lower degree but lower removal cost may be preferred.

[0134] The selected nodes are selected from the candidate node pool, so in each step, the candidate node pool will gradually shrink. When a node is removed, it is no longer a candidate node. Therefore, the node with the highest current probability value is permanently removed from the candidate pool, and the number of removed nodes Q = Q + 1 is updated to ensure that the same node will not be selected repeatedly.

[0135] After removing the node with the highest current probability value, the network's adjacency matrix is ​​updated, and all edges connected to the node with the highest current probability value are deleted to generate a new network state. The information about the removed node is input into the decoder, and the hidden state is updated through the GRU structure, allowing the model to perceive the state after the network topology changes. It can be understood that after removing the node, the network topology changes. Specifically, all connections of the removed node are deleted, which will affect the structure of the remaining network. The decoder needs to adjust the probability of node selection based on the new network state. The decoder update process is achieved by passing the information about the removed node to the decoder and updating its hidden state. The new hidden state will be used for the next round of node selection decisions.

[0136] Repeat the above selection, removal and update steps until the number of removed nodes Q reaches the preset maximum constraint value Q max The final output of the removed node set x j This is the solution to the current scalar quantum problem.

[0137] Through the gradual selection of the greedy strategy, the solution to the scalar subproblem is a set of node removals. The solution to the scalar subproblem will be used as the input of the optimization objective function, and eventually, through the influence of the selection probability, the optimal strategy for network collapse will be gradually formed. In this way, the decoder can gradually find the optimal solution that meets the multi-objective optimization conditions. This method of quickly generating candidate solutions through local optimal selection avoids the time-consuming problem of multiple iterations required by traditional heuristic algorithms (such as genetic algorithms). In large-scale network scenarios, the network state and the decoder hidden state are updated after each removal step, so that the model can respond to network topology changes in real time (such as decreased connectivity after node removal), improving the global rationality of the solution; the selection probability is directly related to the objective function of the scalar subproblem, ensuring that the removal strategy always revolves around a specific weight vector λ j For example, when When it is large, the model tends to remove high centrality nodes to maximize the collapse effect.

[0138] Step S6: traverse all solutions of the scalar subproblem and select the solution set that meets the Pareto optimality condition as the final collapse strategy.

[0139] Through the greedy selection process described above, we have generated multiple sets of solutions to the scalar subproblems. Each solution corresponds to a specific node removal strategy, reflecting the strategies for dismantling the network under different weight combinations. Next, we need to select the final dismantling strategy using Pareto optimality.

[0140] It should be noted that in multi-objective optimization, a solution is considered Pareto optimal if it is not inferior to other solutions in all objectives and is superior to other solutions in at least one objective. In other words, a Pareto optimal solution is one that cannot be improved by other solutions in terms of one objective while maintaining the same results in terms of the other objectives.

[0141] For the multi-objective network collapse problem, two optimization objectives need to be considered: collapse cost C(X) and collapse effect Γ(X). Given a solution set X1, X2, ..., X N , through Pareto optimality screening, a solution set X can be selected * , where each solution has an optimal balance between these two objectives.

[0142] In order to screen out the Pareto optimal solution set, it is necessary to check each solution X i Is it not inferior to other solutions in all objectives? The specific steps are as follows:

[0143] Traverse all solutions of the scalar subproblem (each solution corresponds to a weight vector λ j ), assuming that multiple solutions X1, X2, ..., X have been obtained from all scalar subproblemsN , each solution corresponds to a specific collapse strategy.

[0144] Compare the objective function values ​​of each solution and eliminate individuals dominated by other solutions. For example, for each pair of solutions X i and X j , compare their performance on the two objectives of disruption cost C(X) and disruption effect Γ(X). i The cost of disintegration is no greater than that of solution X j , and is better than solution X in terms of disintegration effect j , then solve X i Considered to be superior to solution X in terms of objective j , so solve X j It is not a Pareto optimal solution.

[0145] Finally, solutions that are not dominated by other solutions are selected, and these solutions constitute the Pareto front. The Pareto front represents the best trade-off between the cost and effect of disruption, and each solution is the optimal solution under this trade-off.

[0146] Through the above screening, the Pareto optimal solution set X * This is the final dismantling strategy. In multi-objective optimization problems, the Pareto optimal solution set provides decision makers with multiple options. Decision makers can choose the solution that best meets their specific needs, thereby obtaining the optimal network dismantling strategy.

[0147] In this embodiment, as described in step S2 above, the constructed neural network model needs to be trained, and the training steps are as follows:

[0148] Step S21: decompose the multi-objective network collapse problem into multiple scalar subproblems, each scalar subproblem corresponds to a weight vector;

[0149] Step S22: Initialize the neural network model parameters of the first scalar subproblem, including the weight matrices of the encoder, decoder, and attention mechanism;

[0150] Step S23: Using the Actor-Critic algorithm to train the first scalar subproblem, and optimizing the neural network model parameters through back propagation until convergence conditions are reached;

[0151] Step S24: Based on the neighborhood parameter transfer strategy, the neural network model parameters after training the i-1 scalar subproblem are used as the initial parameters of the i th subproblem, and step S63 is repeated for iterative training;

[0152] Step S25: traverse all scalar subproblems until the neural network model parameters of all scalar subproblems are trained to obtain a trained neural network model.

[0153] It is understandable that the multi-objective network collapse problem is decomposed into scalar optimization subproblems, each of which is modeled as a neural network. Therefore, solving each subproblem requires specific neural network model parameters. Specifically, the model parameter transfer strategy is used to output The neural network model parameters of each sub-problem are then obtained through the classic AC training algorithm. Considering that the weight vectors of two adjacent sub-problems are very close, they are likely to have very similar optimal solutions. Therefore, the model parameters of the adjacent sub-problems can be used to solve the model parameters of the sub-problem, thereby speeding up the training process. The training speed of each subproblem.

[0154] Furthermore, suppose that Represents the neural network model parameters of the (i-1)th subproblem. Define [θ * ,φ * ] are trained model parameters, and [θ,φ] are untrained parameters. Assuming that the model parameters of the (i-1)th sub-problem have been trained and have reached the optimal value, the optimized model parameters of the (i-1)th sub-problem will be used. As the starting point for optimizing the model parameters of the i-th sub-problem. In simple terms, the training process of the network model parameters is carried out from one sub-problem to the next one in sequence. By transferring the network weights, the model parameters of all sub-problems can be obtained in sequence. Figure 5 A schematic diagram of the neighborhood-based sub-problem model parameter transfer strategy is given.

[0155] In order to evaluate the performance of the DRL-MND model (i.e., the model of the above embodiment method), the classic multi-objective evolutionary algorithms NSGA-II and NSGA-III were selected as comparison algorithms, and all algorithms were implemented in the Python environment. All experiments were performed on a computer configured with a GPU RTX3090, an i9-12900K CPU, and 64G RAM.

[0156] Because the multi-objective network collapse problem defined by the model is a novel problem, no existing public datasets are available. Therefore, based on the characteristics of this problem, a specific data distribution rule is employed to independently generate the required training and testing datasets. Specifically, two network types with significantly different node degree distributions—Scale-Free (SF) networks and Barabási–Albert (BA) random networks—were selected to simulate the target network structure. Given that the DRL-MND model employs unsupervised reinforcement learning to train the parameters of deep neural networks, only network structure information and the target value calculation method are input during training, without requiring the optimal collapse solution as a label.

[0157] During the training phase, randomly generated SF network instances with 40 nodes were trained with a cost-sensitive parameter p = 1 for node removal. After training, when the model parameters reached a stable state, the model was able to solve the collapse problem for SF networks or BA networks with 40, 70, 100, 150, and 200 nodes.

[0158] In the DRL-MND model, the parameter settings for each sub-problem are shown in Table 1, where D input Represents the dimension of the input information. The Actor network's encoder uses a fully connected neural network with 128 hidden layer nodes, while the decoder uses a single-layer GRU recurrent neural network with 128 hidden layer nodes. The Critic network's hidden layer has 128 nodes, and the last layer has 1 node, which is used to evaluate the performance of the proposed solution. The model parameters of both the Actor and Critic networks are trained using the Adam optimizer with a learning rate of 0.0001. The weights of the first subproblem model are initialized using the Xavier method, and a neighborhood-based model parameter transfer strategy is then used to train the models for subsequent subproblems.

[0159] Table 1 Parameter settings of the DRL-MND neutron problem model

[0160]

[0161] To verify the effectiveness of DRL-MND, two classic multi-objective combinatorial optimization algorithms, NSGA-II and NSGA-III, were selected for comparison. The maximum number of genetic generations for both algorithms was set to 300, and the population size was 100. The number of subproblems in DRL-MND was also set to 100. When solving the multi-objective network collapse problem, the definition of non-dominated solutions was used to select the Pareto solution set that meets the requirements.

[0162] First, we trained the DRL-MND model on a 40-node dual-objective network collapse problem. Afterwards, we used the trained model to solve randomly generated SF network collapse test instances with 40, 70, 100, 150, and 200 nodes. In all these test instances, the node removal cost-sensitive parameter p = 1.

[0163] Figure 6 The Pareto fronts obtained by different algorithms for dealing with the collapse problem of SF networks of different scales are shown. For example, Figure 6 (a) shows the Pareto front obtained when the SF network with 40 nodes collapses. Figure 6 (b) shows the Pareto front obtained when the SF network with 100 nodes collapses. Figure 6 (c) shows the Pareto front obtained when the SF network with 150 nodes collapses. Figure 6 (d) shows the Pareto front obtained when the SF network with 200 nodes collapses.

[0164] Although the designed model is only trained on a network containing 40 nodes, it still shows remarkable effectiveness in dealing with multi-objective network collapse problems of different scales. In particular, DRL-MND shows excellent performance in the test cases of 70, 100, 150 and 200 nodes.

[0165] like Figure 6 As shown in , all the compared algorithms can solve the small-scale multi-objective network collapse problem well. However, as the number of network nodes increases, such as Figure 6 As shown in Figures (c) and (d), the solutions of NSGA-II and NSGA-III gradually converge in a certain area, while DRL-MND exhibits greater solution diversity. Of course, as can be seen from the Pareto front above, the designed DRL-MND does not completely dominate NSGA-II and NSGA-III, and vice versa. To further compare the algorithm performance, the HV performance index and solution time of each algorithm were also calculated.

[0166] To further compare the performance of the algorithms, the HV performance metric and solution time of each algorithm were calculated. As shown in Table 2, regardless of the problem size, the HV metric values ​​calculated by DRL-MND are consistently higher than those of NSGA-II and NSGA-III, further demonstrating the advantages of the proposed model in terms of convergence and diversity. Furthermore, as the problem size increases, traditional heuristic algorithms typically require more time to search for a solution. For example, for a 200-node problem, NSGA-II takes 135.4 seconds after 300 iterations, while NSGA-III takes 116.42 seconds. However, DRL-MND outputs a solution in only 15.18 seconds, significantly reducing the solution time.

[0167] Table 2 HV index and solution speed of the algorithm for SF network collapse problem of different scales (p=1)

[0168]

[0169] Furthermore, the trained model is used to solve randomly generated instances of the multi-objective BA network collapse test problem with 40, 70, 100, 150, and 200 nodes. Figure 7 The Pareto frontiers obtained by all algorithms for solving the collapse problem of BA networks of different scales are shown, for example, Figure 7 (a) shows the Pareto frontier obtained when the BA network with 40 nodes collapses. Figure 7 (b) shows the Pareto frontier obtained when the BA network collapses with 100 nodes. Figure 7 (c) shows the Pareto frontier obtained when the BA network with 150 nodes collapses. Figure 7 (d) shows the Pareto front obtained for the BA network collapse problem with 200 nodes. The results show that DRL-MND has similar convergence performance to the baseline algorithm in solving the multi-objective BA network collapse problem, but significantly outperforms NSGA-II and NSGA-III in terms of solution diversity.

[0170] Table 3 further compares the HV index and solution time of the algorithms for BA network collapse problems of different scales. It shows that DRL-MND not only achieves more ideal HV index values, but also outputs the Pareto solution set of the solved problem more quickly than NSGA-II and NSGA-III. As the problem size increases, the gap between DRL-MND's running time and the baseline algorithm becomes more obvious.

[0171] Table 3 HV index and solution speed of the algorithm for BA network collapse problem of different scales (p=1)

[0172]

[0173] Although problem instances with a fixed cost-sensitive parameter (p = 1) are used for training during the training phase, network disintegration tasks in real environments may be affected by factors such as enemy interference or terrain changes, causing the cost-sensitive parameter to change. Therefore, the DRL-MND model needs to have good generalization capabilities and be able to quickly generate high-quality Pareto solutions when facing different network structures and scales.

[0174] Experiments show that DRL-MND can quickly generate high-quality Pareto solutions regardless of network structure and scale, without the need for retraining. This demonstrates DRL-MND's excellent generalization capabilities across diverse network structures and scales.

[0175] Next, we evaluate the performance of DRL-MND with different cost-sensitive parameters. Specifically, we adjust the cost-sensitive parameter for node removal from p = 1 to p = 2, which means that the cost required to remove different nodes varies more. Figure 8 The Pareto fronts obtained by different algorithms for solving the SF network collapse problem of different scales are shown, for example, Figure 8 (a) shows the Pareto front obtained when the SF network with 40 nodes collapses. Figure 8 (b) shows the Pareto front obtained when the SF network with 100 nodes collapses. Figure 8 (c) shows the Pareto front obtained when the SF network with 150 nodes collapses. Figure 8 (d) shows the Pareto front obtained for the SF network collapse problem with a node number of 200. The results show that regardless of the problem size, the Pareto solutions obtained by the NSGA-II and NSGA-III algorithms cannot completely dominate the Pareto solution set found by DRL-MND.

[0176] Figure 9 The HV index and solution time for this problem scenario are shown. DRL-MND performs best on SF network collapse problems of all scales, and as the problem size increases, the gap between DRL-MND's solution speed and NSGA-II and NSGA-III becomes increasingly significant.

[0177] In summary, the DRL-MND model demonstrates significant advantages over traditional multi-objective optimization methods. First, through its "offline training, online solution" approach, DRL-MND can directly output the optimal Pareto front, eliminating the need for lengthy iterations and significantly improving solution speed. Second, the method exhibits excellent generalization capabilities, allowing the trained model to quickly adapt to diverse problem instances, significantly reducing solution time.

[0178] Based on the above experiments, we propose a deep reinforcement learning-based multi-objective network disintegration method, DRL-MND, which aims to simultaneously maximize the disintegration effect and minimize the disintegration cost. Experimental verification demonstrates that DRL-MND achieves higher solution efficiency and optimization performance when solving large-scale multi-objective network disintegration problems, and offers significant advantages over traditional heuristic algorithms in terms of convergence and diversity.

[0179] According to one aspect of an embodiment of the present application, a multi-target network disintegration system is provided, including the following modules:

[0180] Decomposition module, used to decompose the multi-objective network collapse problem into multiple scalar subproblems and define the corresponding weight vector for each subproblem;

[0181] A model building module is used to build a corresponding neural network model for each scalar subproblem based on its weight vector, wherein the neural network model includes an encoder and a decoder;

[0182] An encoding module, integrated into the encoder, configured to extract features from nodes of the target network using the encoder and generate corresponding node embedding vectors;

[0183] A decoding and attention calculation module, integrated into the decoder, for calculating the selection probability of each node based on the node embedding vector by combining the decoder with an attention mechanism;

[0184] A node selection module, configured to gradually select and remove nodes using a greedy strategy according to the selection probability, to generate a solution to the scalar subproblem;

[0185] The Pareto solution set screening module is used to traverse the solutions of all scalar subproblems and select the solution set that meets the Pareto optimality condition as the final collapse strategy;

[0186] The training module is used to perform end-to-end training of neural network models using the Actor-Critic algorithm and accelerate the optimization of neural network model parameters for multi-scale quantum problems based on the neighborhood parameter transfer strategy;

[0187] The storage module is used to store the trained neural network model parameters, network topology data and the generated Pareto optimal solution set.

[0188] Specifically, MND is modeled as a nonlinear optimization problem and proven to be NP-hard. Then, an end-to-end framework, DRL-MND, is proposed that uses deep reinforcement learning to solve the multi-objective network collapse problem. Leveraging the concept of decomposition, MND is decomposed into a set of scalar quantum problems, with the optimal solution to each subproblem obtained using a deep neural network and an actor-critic algorithm. Evaluation results demonstrate that DRL-MND uses an end-to-end approach to directly generate Pareto optimal solutions without requiring a complex iterative search process. This allows for rapid acquisition of the optimal collapse strategy for the multi-objective network collapse problem, demonstrating significant advantages in optimization capabilities and scalability.

[0189] According to another aspect of an embodiment of the present application, an electronic device is provided, including a processor and a memory, wherein the processor is configured to implement the steps of the method when executing a computer program stored in the memory.

[0190] In the above embodiments of the present invention, the description of each embodiment has its own focus. For parts that are not described in detail in a certain embodiment, reference can be made to the relevant descriptions of other embodiments.

[0191] In the several embodiments provided in this application, it should be understood that the disclosed technical content can be implemented in other ways. Among them, the device embodiments described above are only exemplary. For example, the division of the units can be a logical function division. In actual implementation, there may be other division methods, such as multiple units or components can be combined or integrated into another system, or some features can be ignored or not executed. Another point is that the mutual coupling or direct coupling or communication connection shown or discussed can be through some interfaces, indirect coupling or communication connection of units or modules, which can be electrical or other forms.

[0192] In addition, the functional units in the various embodiments of the present invention may be integrated into a single processing unit, each unit may exist physically separately, or two or more units may be integrated into a single unit. The aforementioned integrated units may be implemented in the form of hardware or software functional units.

[0193] If the integrated unit is implemented in the form of a 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 solution of the present invention, or the part that contributes to the prior art, or all or part of the technical solution can be embodied in the form of a software product. The computer software product is stored in a storage medium and includes several instructions for enabling a computer device (which can be a personal computer, server or network device, etc.) to perform all or part of the steps of the method described in each embodiment of the present invention. The aforementioned storage medium includes: U disk, read-only memory (ROM, Read-Only Memory), random access memory (RAM, Random Access Memory), mobile hard disk, magnetic disk or optical disk, etc. Various media that can store program codes.

[0194] The above is only a preferred embodiment of the present invention. It should be pointed out that for ordinary technicians in this technical field, several improvements and modifications can be made without departing from the principles of the present invention. These improvements and modifications should also be regarded as within the scope of protection of the present invention.

Claims

1. A multi-target network collapse method, characterized in that: The steps include: Decompose the multi-objective network collapse problem into multiple scalar subproblems and define the corresponding weight vector for each subproblem; For each scalar subproblem, a corresponding neural network model is constructed based on its weight vector, wherein the neural network model includes an encoder and a decoder; Using the encoder to extract features from nodes of the target network and generate corresponding node embedding vectors; Calculating the selection probability of each node based on the node embedding vector by combining the decoder with an attention mechanism; According to the selection probability, nodes are gradually selected and removed using a greedy strategy to generate a solution to the scalar subproblem; Traverse the solutions of all scalar subproblems and select the solution set that meets the Pareto optimality condition as the final collapse strategy.

2. The multi-target network disintegration method according to claim 1, wherein: The method of decomposing the multi-objective network collapse problem into multiple scalar subproblems and defining the corresponding weight vector for each subproblem includes: Generate a set of uniformly distributed weight vectors Each weight vector satisfy For each weight vector λ j , the weighted sum method is applied to transform the multi-objective optimization problem into a scalar optimization sub-problem, and its objective function is defined as: Among them, X represents the network collapse strategy, that is, the set of nodes that need to be removed, g ws (X|λ j ) is the objective function, which means that given the weight parameter λ j The optimization target value under this condition is, C(X) is the collapse cost, that is, the cost required to remove the node, Γ(X) is the collapse effect, It means that the goal is to minimize the loss function after trade-off and find the optimal collapse strategy. and Respectively represent the weight coefficients of disintegration cost and disintegration effect; A corresponding scalar subproblem is defined by each weight parameter in the weight vector set, so that a solution of each scalar subproblem corresponds to a candidate solution on the Pareto front of the multi-objective problem.

3. The multi-target network disintegration method according to claim 1, wherein: Methods for generating node embedding vectors include: Obtaining the adjacency matrix of the target network and attribute information of each node, wherein the attribute information includes the node's degree, cost-sensitive parameters, and connection relationship with other nodes; Inputting the adjacency matrix and node attribute information into a fully connected neural network layer of an encoder to generate an initial node feature vector; Serializing the initial node feature vectors through multi-layer gated recurrent units to capture the topological dependencies between nodes and generate intermediate node embedding vectors; A multi-head attention mechanism is introduced to perform context-aware weighting on the intermediate node embedding vectors, fuse the global network structure information, and output the final node embedding vectors.

4. The multi-target network disintegration method according to claim 1, wherein: Methods for calculating selection probability include: Step S31: Initialize the hidden state of the decoder and take the embedding vector of the current candidate node pool as input; Step S32: In each decoding step, the attention scores of all candidate nodes are calculated through the attention mechanism based on the current hidden state of the decoder and the node embedding vector; Step S33: Apply a masking operation to the removed nodes and set their attention scores to negative infinity to exclude duplicate selections; Step S34: normalize the masked attention scores using the softmax function to generate the selection probability distribution of each node; Step S35: Select the optimal node of the current step according to the probability distribution to remove, update the hidden state of the decoder, and iterate until the preset node removal quantity constraint is reached.

5. The multi-target network disintegration method according to claim 4, wherein: The calculation formula of the attention score is: u t =Attention(h t-1 ,e i ) Among them, u t represents the unnormalized attention score of the candidate node in the t-th decoding step, Attention(·) represents the attention function, and h t-1 Denote the hidden state vector of the decoder at step t-1, e i is the embedding vector of the i-th node; The normalized selection probability distribution is generated by the following formula: p(v t |v1,v2,…,v t-1 )=softmax(u t +mask t ) Among them, p(·) represents the probability distribution of selecting a node in step t, v t Indicates the set of nodes removed from step 1 to step t-1 during the decoding process, softmax(·) represents the normalization function, and mask t is a mask vector that is set to negative infinity at the positions of removed nodes and to 0 at all other positions to prevent duplicate selection.

6. The multi-target network disintegration method according to claim 4, wherein: Methods for generating solutions to scalar subproblems by gradually selecting and removing nodes using a greedy strategy include: Step S51: Initialize the candidate node pool to be the set of all nodes in the network that have not been removed, and set the number of currently removed nodes to 0; Step S52: According to the generated selection probability distribution, select the node with the highest current probability value as the node to be removed; Step S53: permanently remove the node to be removed from the candidate node pool, and update the number of removed nodes; Step S54: Input the information of the removed node into the decoder, and update its hidden state to reflect the new state after the network topology changes; Step S55: Repeat steps S32 to S54 until the number of removed nodes reaches a preset maximum constraint value, and output the solution to the current scalar subproblem.

7. The multi-target network disintegration method according to claim 1, wherein: The method further includes training the neural network model, wherein the training method includes: Step S21: decompose the multi-objective network collapse problem into multiple scalar subproblems, each scalar subproblem corresponds to a weight vector; Step S22: Initialize the neural network model parameters of the first scalar subproblem, including the weight matrices of the encoder, decoder, and attention mechanism; Step S23: Using the Actor-Critic algorithm to train the first scalar subproblem, and optimizing the neural network model parameters through back propagation until convergence conditions are reached; Step S24: Based on the neighborhood parameter transfer strategy, the neural network model parameters after training the i-1 scalar subproblem are used as the initial parameters of the i th subproblem, and step S63 is repeated for iterative training; Step S25: traverse all scalar subproblems until the neural network model parameters of all scalar subproblems are trained to obtain a trained neural network model.

8. A multi-target network disruption system, characterized in that: Includes the following modules: Decomposition module, used to decompose the multi-objective network collapse problem into multiple scalar subproblems and define the corresponding weight vector for each subproblem; A model building module is used to build a corresponding neural network model for each scalar subproblem based on its weight vector, wherein the neural network model includes an encoder and a decoder; An encoding module, integrated into the encoder, configured to extract features from nodes of the target network using the encoder and generate corresponding node embedding vectors; A decoding and attention calculation module, integrated into the decoder, for calculating the selection probability of each node based on the node embedding vector by combining the decoder with an attention mechanism; A node selection module, configured to gradually select and remove nodes using a greedy strategy according to the selection probability, to generate a solution to the scalar subproblem; The Pareto solution set screening module is used to traverse the solutions of all scalar subproblems and select the solution set that meets the Pareto optimality condition as the final collapse strategy; The training module is used to perform end-to-end training of neural network models using the Actor-Critic algorithm and accelerate the optimization of neural network model parameters for multi-scale quantum problems based on the neighborhood parameter transfer strategy; The storage module is used to store the trained neural network model parameters, network topology data and the generated Pareto optimal solution set.

9. An electronic device comprising a memory and a processor, characterized in that: The memory is used to store a program that supports the processor to execute the multi-target network disintegration method according to any one of claims 1 to 7, and the processor is configured to execute the program stored in the memory.

10. A computer-readable storage medium having a computer program stored thereon, characterized in that: When the computer program is executed by a processor, the steps of the multi-target network disintegration method according to any one of claims 1 to 7 are executed.

Images