Privacy protection method, device and electronic device for discrete-time dynamic graphs

Abstract

The present application relates to a privacy protection method, apparatus, and electronic device for discrete-time dynamic graphs, including node sampling of the original discrete-time dynamic graph, calculating the attention weights of the neighboring nodes of the collected nodes and concatenating them, inputting the obtained noisy discrete-time dynamic subgraph structural representation into an LSTM neural network to obtain a time and structure fusion representation of the noisy discrete-time dynamic subgraph, and inputting the representation into the generator multi-layer perceptron to obtain a synthetic discrete-time dynamic graph at the next moment. This method can effectively alleviate the problem of the difficulty in maintaining a sustainable balance between privacy and availability of discrete-time dynamic graphs caused by the uneven distribution of private and non-private information. At the same time, through dynamic noise adjustment, the problem of privacy leakage caused by a sudden change in the dynamic graph structure at a certain moment is solved, further improving the privacy protection strength of the published discrete-time dynamic graph data and effectively ensuring the availability of dynamic graph data at other moments.

Description

Technical Field

[0001] The present application relates to the field of computer science and technology, and in particular to a privacy protection method, device, and electronic device for discrete-time dynamic graphs. Background Art

[0002] In the real world, publishing and sharing graph data (such as social network graphs and trajectory network graphs) often carries the risk of privacy leakage. Privacy-Preserving Graph Publishing (PPGP) offers some privacy-preserving solutions, but it primarily targets static graphs. However, most real-world graph data is dynamically updated, posing a higher risk of privacy leakage than static graphs.

[0003] Some researchers have begun studying privacy publication in dynamic graphs, but these techniques still have two flaws. First, they ignore the uneven distribution of private and non-private edges. We have noticed that in some real-world networks, such as social networks, the same user often has a large amount of non-private information and a small amount of private information. Directly applying differential privacy methods may lead to insufficient protection of private information while also introducing excessive noise to non-private information, which may disrupt the ongoing balance between privacy and data availability during the evolution of dynamic graphs. Second, they ignore the structural mutations that occur during the continuous evolution of dynamic graphs. Over time, the structure of dynamic graphs may suddenly undergo significant changes, such as a sudden increase in node size or a sudden decrease in the number of edges between nodes. Accordingly, these structural mutations reflect the semantic behavior of users in the real world and reveal the privacy characteristics of user behavior trends, which may lead to privacy leaks. Summary of the Invention

[0004] In view of this, the present application proposes a privacy protection method for discrete-time dynamic graphs to solve the problems reflected in the above background technology.

[0005] According to one aspect of the present application, a privacy protection method for discrete-time dynamic graphs is provided, comprising:

[0006] Obtaining input data, where the input data includes an original discrete-time dynamic graph, a preset batch size, a discrete-time dynamic graph at a next moment, a preset gradient clipping constraint value, and a preset privacy budget;

[0007] Node sampling is performed on the original discrete-time dynamic graph, attention weights of neighboring nodes of the collected nodes are calculated, the attention weights are concatenated, and the concatenated structural representation of the noisy discrete-time dynamic subgraph is input into an LSTM neural network to obtain a time and structure fusion representation of the noisy discrete-time dynamic subgraph;

[0008] splicing the time and structure fusion representations of the noisy discrete-time dynamic subgraphs at two different moments, and inputting the spliced ​​result into the generator multi-layer perceptron to calculate the mutual information result;

[0009] Inputting the time and structure fusion representation of the noisy discrete-time dynamic subgraph into the generator multi-layer perceptron to obtain a synthetic discrete-time dynamic graph at the next moment;

[0010] performing gradient discrimination on the synthetic discrete-time dynamic graph at the next moment according to the discrete-time dynamic graph at the next moment to obtain gradient information;

[0011] Clipping the gradient information according to the preset gradient clipping constraint value to obtain a first gradient clipping result and a second gradient clipping result;

[0012] Inputting Gaussian noise, and adjusting the variance of the Gaussian noise according to a preset noise adjustment formula based on the first gradient clipping result and the mutual information result;

[0013] Calculating the privacy consumption according to the adjusted variance of the Gaussian noise, the preset order of the Ruili differential privacy, the second gradient clipping result, and the preset batch size, and determining the consumption of the preset privacy budget according to the privacy consumption;

[0014] When the preset privacy budget is consumed, the synthetic discrete-time dynamic graph at the next moment is output.

[0015] As an optional implementation scheme of the present application, the input data further includes: a preset node subset size and noise that obeys a standard normal distribution; the node sampling of the original discrete-time dynamic graph, the calculation of the attention weights of the neighboring nodes of the collected nodes, the splicing of the attention weights, and the input of the spliced ​​noisy discrete-time dynamic subgraph structural representation into the LSTM neural network to obtain the time and structure fusion representation of the noisy discrete-time dynamic subgraph, including:

[0016] Selecting a node from the original discrete-time dynamic graph and using it as an element of the initialization subgraph node set;

[0017] Generate a BFS tree with the element as the root according to the preset node subset size;

[0018] Selecting nodes from the BFS tree, sampling the nodes according to a preset transition probability, expanding the number of elements in the initialized subgraph node set to a preset node subset size, and obtaining a discrete-time dynamic subgraph;

[0019] According to the noise that obeys the standard normal distribution, the attention weights of the neighboring nodes of the nodes in the discrete-time dynamic subgraph are calculated, the attention weights are spliced, and the spliced ​​noisy discrete-time dynamic subgraph structural representation is input into the LSTM neural network to obtain the time and structure fusion representation of the noisy discrete-time dynamic subgraph.

[0020] As an optional implementation scheme of the present application, the time and structure fusion representations of the noisy discrete-time dynamic subgraphs at two different moments are spliced, and the spliced ​​result is input into the generator multi-layer perceptron to calculate the mutual information result, including:

[0021] Traversing historical moments, and concatenating the time and structure fusion representations of the noisy discrete-time dynamic subgraphs at two different moments according to the historical moments to obtain a time and structure fusion long representation of the noisy discrete-time dynamic subgraphs;

[0022] The time and structure fusion long representation of the noisy discrete-time dynamic subgraph is input into the generator multi-layer perceptron, and the mutual information results between different moments in the time series are generated according to the preset mutual information result inequality.

[0023] As an optional implementation scheme of the present application, Gaussian noise is input, and the variance of the Gaussian noise is adjusted according to a preset noise adjustment formula based on the first gradient clipping result and the mutual information result, including:

[0024] Preset noise attenuation rate;

[0025] When the mutual information result is greater than a preset threshold, adjusting the variance of the Gaussian noise according to the noise attenuation rate;

[0026] When the mutual information result is less than or equal to a preset threshold, the variance of the Gaussian noise is maintained.

[0027] As an optional implementation scheme of the present application, when the mutual information result exceeds a preset threshold, after adjusting the variance of the Gaussian noise according to the noise attenuation rate, the method further includes:

[0028] A generator noisy gradient is formed according to the adjusted variance of the Gaussian noise.

[0029] As an optional implementation scheme of the present application, the privacy consumption is calculated based on the adjusted variance of the Gaussian noise, the preset order of the Ruili differential privacy, the second gradient clipping result, and the preset batch size, and the consumption of the preset privacy budget is determined based on the privacy consumption, including:

[0030] When the order of the preset Ruili differential privacy is greater than a preset order threshold, calculating the privacy consumption by using a first privacy consumption formula according to the variance of the Gaussian noise, the second gradient clipping result, and the preset batch size;

[0031] When the order of the preset Ruili differential privacy is less than or equal to a preset order threshold, calculating the privacy consumption by a second privacy consumption formula according to the variance of the Gaussian noise, the second gradient clipping result, and the preset batch size;

[0032] The remaining privacy budget after the privacy consumption in the current round is calculated according to the preset privacy budget.

[0033] As an optional implementation scheme of the present application, after calculating the remaining privacy budget after the privacy consumption in the current round according to the preset privacy budget, the method further includes:

[0034] When the privacy budget is not exhausted or the current round is less than a preset training number threshold, the generator noisy gradient is input into the LSTM neural network.

[0035] As an optional implementation scheme of the present application, outputting the synthetic discrete-time dynamic graph at the next moment further includes:

[0036] When the current round is equal to the training number threshold, the synthetic discrete-time dynamic graph of the next moment is output.

[0037] This application also provides a privacy protection device for discrete-time dynamic graphs, including:

[0038] An input data acquisition module is configured to acquire input data, wherein the input data includes an original discrete-time dynamic graph, a preset batch size, a discrete-time dynamic graph at the next moment, a preset gradient clipping constraint value, and a preset privacy budget;

[0039] A node sampling module, configured to perform node sampling on the original discrete-time dynamic graph;

[0040] A fusion representation module is used to calculate the attention weights of the neighboring nodes of the collected nodes and concatenate the attention weights; the concatenated noisy discrete-time dynamic subgraph structural representation is input into the LSTM neural network to obtain a time and structure fusion representation of the noisy discrete-time dynamic subgraph;

[0041] A splicing and fusion representation module is used to splice the time and structure fusion representations of the noisy discrete-time dynamic subgraphs at two different moments, and input the splicing result into the generator multi-layer perceptron to calculate the mutual information result;

[0042] A discrete dynamic graph generation module is used to input the time and structure fusion representation of the noisy discrete-time dynamic subgraph into the generator multi-layer perceptron to obtain a synthetic discrete-time dynamic graph at the next moment;

[0043] a gradient discrimination module, configured to perform gradient discrimination on the synthetic discrete-time dynamic graph at the next moment according to the discrete-time dynamic graph at the next moment to obtain gradient information;

[0044] a gradient clipping module, configured to clip the gradient information according to the preset gradient clipping constraint value to obtain a first gradient clipping result and a second gradient clipping result;

[0045] a variance adjustment module, configured to input Gaussian noise and adjust the variance of the Gaussian noise according to a preset noise adjustment formula based on the first gradient clipping result and the mutual information result;

[0046] a privacy consumption calculation module, configured to calculate the privacy consumption based on the adjusted variance of the Gaussian noise, the preset order of the Ruili differential privacy, the second gradient clipping result, and the preset batch size, and determine the consumption of the preset privacy budget based on the privacy consumption;

[0047] The judgment module is configured to output the synthetic discrete-time dynamic graph at the next moment when the preset privacy budget is consumed.

[0048] The present application also provides an electronic device, comprising:

[0049] processor;

[0050] a memory for storing processor-executable instructions;

[0051] The processor is configured to implement the above-mentioned privacy protection method for discrete-time dynamic graphs when executing the executable instructions.

[0052] Beneficial effects of this application:

[0053] This application effectively alleviates the problem of maintaining a consistent privacy-availability balance in discrete-time dynamic graphs, caused by the uneven distribution of private and non-private information. Furthermore, through dynamic noise regulation, it addresses the potential privacy leaks caused by sudden changes in the dynamic graph structure at a given moment. This further enhances the privacy protection strength of discrete-time dynamic graph data releases while effectively ensuring the availability of dynamic graph data at other times.

[0054] Other features and aspects of the present application will become apparent from the following detailed description of exemplary embodiments with reference to the attached drawings. BRIEF DESCRIPTION OF THE DRAWINGS

[0055] The accompanying drawings, which are incorporated in and constitute a part of the specification, illustrate exemplary embodiments, features, and aspects of the application and, together with the description, serve to explain the principles of the application.

[0056] Figure 1 A flowchart illustrating a privacy protection method for discrete-time dynamic graphs according to an embodiment of the present application is shown;

[0057] Figure 2 A block diagram of a privacy protection device for discrete-time dynamic graphs according to an embodiment of the present application is shown. DETAILED DESCRIPTION

[0058] Various exemplary embodiments, features, and aspects of the present application will be described in detail below with reference to the accompanying drawings. The same reference numerals in the accompanying drawings represent elements with the same or similar functions. Although various aspects of the embodiments are shown in the accompanying drawings, the drawings are not necessarily drawn to scale unless otherwise indicated.

[0059] It should be understood that the terms "center", "longitudinal", "lateral", "length", "width", "up", "down", "front", "back", "left", "right", "vertical", "horizontal", "top", "bottom", "inside", "outside", "clockwise", "counterclockwise", "axial", "radial", "circumferential" and the like indicate orientations or positional relationships based on the orientations or positional relationships shown in the accompanying drawings, and are only for the convenience of describing the present application or simplifying the description, and do not indicate or imply that the device or element referred to must have a specific orientation, be constructed and operated in a specific orientation, and therefore should not be understood as a limitation on the present application.

[0060] Furthermore, the terms "first" and "second" are used for descriptive purposes only and should not be construed as indicating or implying relative importance or implicitly specifying the number of the technical features being referred to. Thus, a feature defined as "first" or "second" may explicitly or implicitly include one or more of the features. Throughout the description of this application, "plurality" means two or more, unless otherwise specifically defined.

[0061] The word “exemplary” is used exclusively herein to mean “serving as an example, example, or illustration.” Any embodiment described herein as “exemplary” is not necessarily to be construed as preferred or advantageous over other embodiments.

[0062] In addition, numerous specific details are provided in the detailed description below to better illustrate the present application. Those skilled in the art will appreciate that the present application can be practiced without certain specific details. In some instances, methods, means, components, and circuits well known to those skilled in the art are not described in detail in order to highlight the main purpose of the present application.

[0063] Dynamic graphs can be divided into discrete-time dynamic graphs and continuous-time dynamic graphs based on their temporal evolution. Continuous-time dynamic graphs require recording every change in the graph (such as the addition and deletion of edges or nodes), which is computationally complex and difficult to implement. Discrete-time dynamic graphs sample and record graph changes at regular time intervals (also known as graph snapshots), which have lower computational complexity and are more common in practical applications. Therefore, this application mainly addresses the privacy issue of discrete-time dynamic graphs.

[0064] Many researchers have used graph neural network (GNN) models to learn the features of discrete-time dynamic graphs. These methods are mainly divided into: matrix decomposition-based, random walk-based, and deep learning-based. Matrix decomposition-based methods usually assume that all relationships are linear, which may not be able to capture more complex nonlinear patterns. Random walk-based methods have low computational efficiency for large graphs, and the walk process has a certain degree of randomness, which may lead to poor feature learning effects. Deep learning-based methods can capture complex nonlinear relationships in the latent space, and have stronger scalability and parallelization capabilities for large graphs, and have achieved excellent results in practical applications. Therefore, this application mainly solves the privacy release problem of discrete-time dynamic graphs based on deep learning architecture.

[0065] In order to protect the privacy of graph data, many researchers have conducted related research, which mainly includes three types of methods: anonymization methods, differential privacy (DP) methods, and privacy computing methods (such as homomorphic encryption or multi-party computing). Anonymization methods usually lack strict privacy guarantees and are vulnerable to attacks by attackers with extensive knowledge. Differential privacy (DP) methods can provide mathematical privacy guarantees, which means that even if the attacker has background knowledge, he cannot obtain more information about the user. Privacy computing methods can provide stronger privacy protection, but at the cost of a significant reduction in data availability, which makes them unsuitable for scenarios where graph data is published and shared. Therefore, this application mainly combines deep learning architecture and differential privacy (DP) methods to solve the privacy publishing problem of discrete-time dynamic graphs.

[0066] Common differential privacy schemes include (ε,δ)-DP and Ruili Differential Privacy ((α,ε)-RDP). (ε,δ)-DP is the most common differential privacy scheme, but it requires a very precise privacy budget, which is cumulatively consumed across multiple queries, potentially affecting data availability. Ruili Differential Privacy ((α,ε)-RDP) allows for more granular control over the allocation of privacy budgets across queries, thereby improving data availability and preventing the introduction of more noise. Therefore, this application primarily combines deep learning architectures with Ruili Differential Privacy ((α,ε)-RDP) to address the privacy publication problem for discrete-time dynamic graphs.

[0067] Example 1

[0068] Figure 1 FIG2 shows a flowchart of a privacy protection method for discrete-time dynamic graphs according to an embodiment of the present application. Figure 1 As shown, the flow chart includes:

[0069] S100, obtaining input data, where the input data includes an original discrete-time dynamic graph, a preset batch size, a discrete-time dynamic graph at the next moment, a preset gradient clipping constraint value, and a preset privacy budget;

[0070] In this embodiment, the original discrete-time dynamic graph is trained to output the synthetic discrete-time dynamic graph at the next moment. The input data for training includes the original discrete-time dynamic graph that needs to be privacy-protected, the specified batch size B, and the real discrete-time dynamic graph at the next moment. Specify the gradient clipping constraint value T and the privacy budget ε.

[0071] S200: sampling nodes of the original discrete-time dynamic graph, calculating attention weights of neighboring nodes of the sampled nodes, concatenating the attention weights, and inputting the concatenated structural representation of the noisy discrete-time dynamic subgraph into an LSTM neural network to obtain a time and structure fusion representation of the noisy discrete-time dynamic subgraph;

[0072] Given a discrete-time dynamic graph G T ={G1,…,G t}, for the original discrete-time dynamic graph G T ={G1,…,G t} Perform node sampling and grow nodes based on the sampled nodes to form a discrete time dynamic subgraph For any given node in the discrete-time dynamic subgraph, the generator self-attention mechanism is used. Based on the structural self-attention layer, the embedding of the neighboring nodes of the given node is calculated to calculate the attention weight, and then the representation of the given node is formed. The representations of all given nodes are spliced ​​to form the structural representation of the noisy discrete-time dynamic subgraph.

[0073] The noisy discrete-time dynamic subgraph structural representation is input into the LSTM layer to capture the pattern of the dynamic graph evolving over time, forming a time-structure fusion representation of the noisy discrete-time dynamic subgraph.

[0074] S300, splicing the time and structure fusion representations of the noisy discrete-time dynamic subgraphs at two different moments, and inputting the spliced ​​result into a generator multi-layer perceptron to calculate the mutual information result;

[0075] Traverse all historical moments and represent the time-structure fusion of the noisy discrete-time dynamic subgraphs at two different moments and Splicing is performed to obtain a time-structure fusion long representation of the noisy discrete-time dynamic subgraph

[0076] enter The mutual information results between graphs at different moments in the sequence are formed through the MLP layer

[0077] S400, inputting the time and structure fusion representation of the noisy discrete-time dynamic subgraph into the generator multi-layer perceptron to obtain a synthetic discrete-time dynamic graph at the next moment;

[0078] Time-structure fusion representation of noisy discrete-time dynamic subgraphs Input to the MLP layer to obtain the synthetic discrete-time dynamic graph of the next moment

[0079] S500, performing gradient discrimination on the synthetic discrete-time dynamic graph at the next moment according to the discrete-time dynamic graph at the next moment to obtain gradient information;

[0080] Input the next moment of synthetic discrete-time dynamic graph and the real discrete time dynamic graph of the next moment The MLP layer is used to discriminate and feedback the gradient information Θ G .

[0081] S600, clipping the gradient information according to the preset gradient clipping constraint value to obtain a first gradient clipping result and a second gradient clipping result;

[0082] Input gradient information Θ G And the gradient clipping constraint value T, forming a clipped gradient Θ' not greater than T G And the L2-sensitivity Δ2f of the clipped gradient. The first gradient clipping result is the clipped gradient Θ' not greater than T G , the second gradient clipping result is the L2-sensitivity Δ2f of the clipped gradient.

[0083] S700: Inputting Gaussian noise, and adjusting the variance of the Gaussian noise according to a preset noise adjustment formula based on the first gradient clipping result and the mutual information result;

[0084] Input clipped gradient Θ' G , and add a mean of 0 and a variance of σ e Gaussian noise According to the mutual information results Dynamically adjust the variance σ of Gaussian noisee .

[0085] S800: Calculate the privacy cost based on the adjusted variance of the Gaussian noise, the preset order of the Ruili differential privacy, the second gradient clipping result, and the preset batch size, and determine the consumption of the preset privacy budget based on the privacy cost;

[0086] Adjusted Gaussian noise variance σ' e The noise variance of the current training round is combined with the order of Ruili Differential Privacy (RDP), the gradient function L2-sensitivity Δ2f and the batch size B to calculate the privacy consumption, and finally the remaining privacy budget of the current round is calculated.

[0087] S900: When the preset privacy budget is consumed, output the synthetic discrete-time dynamic graph at the next moment.

[0088] When privacy budget If it is exhausted, the training ends and the synthetic discrete-time dynamic graph of the next moment is output.

[0089] As an optional implementation scheme of the present application, the input data also includes: a preset node subset size and noise that obeys a standard normal distribution; the node sampling of the original discrete-time dynamic graph, the calculation of the attention weights of the neighboring nodes of the collected nodes, the splicing of the attention weights, and the input of the spliced ​​noisy discrete-time dynamic subgraph structural representation into the LSTM neural network to obtain a noisy discrete-time dynamic subgraph time and structure fusion representation, including: selecting a node from the original discrete-time dynamic graph and using it as an element of the initialized subgraph node set; generating a BFS tree with the element as the root according to the preset node subset size; selecting a node from the BFS tree, sampling the node according to a preset transition probability, expanding the number of elements of the initialized subgraph node set to the preset node subset size to obtain a discrete-time dynamic subgraph; calculating the attention weights of the neighboring nodes of the nodes in the discrete-time dynamic subgraph according to the noise that obeys a standard normal distribution, splicing the attention weights, and inputting the spliced ​​noisy discrete-time dynamic subgraph structural representation into the LSTM neural network to obtain a noisy discrete-time dynamic subgraph time and structure fusion representation.

[0090] Given an original discrete-time dynamic graph G T ={G1,…,G t}, randomly select a node v from the original discrete-time dynamic graph, initialize the subgraph node set V' = {v}, and calculate the node subset size according to the specified Generate a BFS tree with v as the root for Randomly select a node v i , according to the transition probability p(v j |v i ) performs node sampling to expand the subgraph. Among them, the transition probability: p(v j |v i ) is calculated as:

[0091]

[0092] where w j,i ∈{0.5w,w,2w} is the edge (v j ,v i ) weight. When v j and v i When it is a privacy node, w j,i =0.5w. If v j or v i is a privacy node, then w j,i =w, otherwise, if these two are non-private nodes, w j,i =2w; the temperature parameter τ<1 is used to increase the probability of private nodes being sampled. Repeat the growth of nodes in the subgraph node set until the number of nodes in V' is equal to Forming discrete-time dynamic subgraphs

[0093] Input discrete-time dynamic subgraph And a set of noises Γ={γ1,…,γ t For any given node v, based on the structured self-attention layer, the attention weight is calculated according to the embedding of its neighboring nodes in, f act represents the nonlinear activation function, is the edge weight between nodes u and v, W s represents the shared weight, a represents the weight vector of the attention function, and || represents the connection operation. This forms the representation of node v: in Represents the set of neighbors of node v. Then, by calculating and concatenating multiple attention heads in each self-attention layer, an output representation that can capture the structural properties of the subgraph is constructed. Where hd represents the number of attention heads.

[0094] Representing the noisy discrete-time dynamic subgraph structure Input into the LSTM layer to capture the pattern of the dynamic graph evolving over time and form a time-structure fusion representation of the noisy discrete-time dynamic subgraph

[0095] For example, given a real social network discrete-time dynamic graph with 1899 nodes and 59835 edges, containing 10 snapshots of the dynamic graph at different moments; the sliding window size w = 5; the batch size B = 64; the real dynamic graph at the 6th moment (i.e., the next moment) The number of nodes required for each subgraph is 80; the gradient clipping constraint value T = 1; a set of noises Γ = {γ1,…,γ t}, with a mean of 0 and a variance of 1; the initial epoch of model training is 200; the order of Ruili differential privacy (RDP) is α=2, and the specified privacy budget ε=1.

[0096] According to the number of nodes required to be included in each subgraph = 80 and the number of sampled subgraphs = 20, sampling is performed to obtain a discrete-time dynamic subgraph.

[0097] Use a sliding window size of 5 and input the discrete time dynamic subgraph of 5 historical moments And a set of noises Γ={γ1,…,γ5} that obey the standard normal distribution, select the number of attention heads hd=8, and construct an output representation that can capture the structural properties of the subgraph Finally, the noisy discrete-time dynamic subgraph structure representation of these five moments is formed

[0098] The noisy discrete-time dynamic subgraph structural representations at 5 moments are input to form the time-structure fusion representations of the noisy discrete-time dynamic subgraph at 5 historical moments and the sixth moment.

[0099] As an optional implementation scheme of the present application, the time and structure fusion representations of the noisy discrete-time dynamic subgraph at two different moments are spliced, and the spliced ​​results are input into the generator multi-layer perceptron to calculate the mutual information result, including: traversing historical moments, and according to the historical moments, splicing the time and structure fusion representations of the noisy discrete-time dynamic subgraph at two different moments to obtain a long representation of the time and structure fusion of the noisy discrete-time dynamic subgraph; inputting the long representation of the time and structure fusion of the noisy discrete-time dynamic subgraph into the generator multi-layer perceptron, and generating the mutual information results between different moments in the time series according to the preset mutual information result inequality.

[0100] Traverse all historical moments and represent the time-structure fusion of the noisy discrete-time dynamic subgraphs at two different moments and Splicing is performed to obtain a time-structure fusion long representation of the noisy discrete-time dynamic subgraph

[0101] enter The mutual information calculation results between graphs at different moments in the time series are formed through the MLP layer The calculation method is as follows: Among them, f ξ represents the MLP layer, N is the number of subgraph nodes, that is, Adjust the parameters of MLP to maximize the right-hand side equation to obtain the mutual information result.

[0102] For example, we traverse five historical moments and concatenate the noisy discrete-time dynamic subgraphs of two different moments, such as time 1, time 2; time 1, time 3; time 2, time 5, etc., to obtain the noisy discrete-time dynamic subgraph time-structure fusion long representation. enter The mutual information results between graphs at different moments in the time series are formed through the MLP layer

[0103] As an optional implementation scheme of the present application, Gaussian noise is input, and the variance of the Gaussian noise is adjusted according to a preset noise adjustment formula based on the first gradient clipping result and the mutual information result, including: when the mutual information result is greater than a preset threshold, the variance of the Gaussian noise is adjusted according to a preset noise attenuation rate; when the mutual information result is less than or equal to the preset threshold, the variance of the Gaussian noise is maintained.

[0104] Input clipped gradient Θ' G , and add a mean of 0 and a variance of σ e Gaussian noise Noi e , according to the mutual information results Dynamically adjust the variance σ of Gaussian noise e , where the noise adjustment formula is: If the value of the mutual information result exceeds the threshold τ, the noise scale will be reduced to σ' e =kσ e ; otherwise keep σ e Where k is the noise attenuation rate preset in advance, 0 <k<1。

[0105] Specific example: Input the clipped gradient Θ' G , and add a mean of 0 and an initial variance of σ e =100 Gaussian noise Noi e Let the noise attenuation rate k = 0.45, the mutual information threshold τ = 0.5, and according to the mutual information results Dynamically adjust the variance σ of Gaussian noise e .

[0106] As an optional implementation scheme of the present application, when the mutual information result exceeds a preset threshold, after adjusting the variance of the Gaussian noise according to the noise attenuation rate, the method further includes:

[0107] A generator noisy gradient is formed according to the adjusted variance of the Gaussian noise.

[0108] According to the adjusted noise variance σ' e , and finally form the noisy gradient of the generator after perturbation

[0109] As an optional implementation scheme of the present application, the privacy consumption is calculated according to the adjusted variance of the Gaussian noise, the preset order of Ruili differential privacy, the second gradient clipping result and the preset batch size, and the consumption of the preset privacy budget is determined according to the privacy consumption, including: when the order of the preset Ruili differential privacy is greater than the preset order threshold, the privacy consumption is calculated according to the variance of the Gaussian noise, the second gradient clipping result and the preset batch size through the first privacy consumption formula; when the order of the preset Ruili differential privacy is less than or equal to the preset order threshold, the privacy consumption is calculated according to the variance of the Gaussian noise, the second gradient clipping result and the preset batch size through the second privacy consumption formula; and the remaining privacy budget after the privacy consumption in the current round is calculated according to the preset privacy budget.

[0110] According to the current round noise variance σ' e , the order of Ruili Differential Privacy (RDP), the gradient function L2-sensitivity Δ2f and the batch size B to calculate the privacy consumption. The calculation formula is as follows: If the specified Ruili Differential Privacy (RDP) order α>2, then ε≤Bα(Δ2f) 2 / 2σ 2 ; If α≤2 and the current round noise variance σ'e is large, then ε≤16B / σ 2 ; If α≤2 and the current round noise variance σ'e is small, then The final calculation forms the remaining privacy budget of the current round

[0111] For example, the privacy cost is calculated based on the current round noise variance σ'e, the order of Ruili Differential Privacy (RDP), the gradient function L2-sensitivity Δ2f=2, and the batch size B=64. At this time, the current round noise variance σ'e is large, and the privacy budget consumed by the current round ε=1024 / (σ'e) 2 , calculate the remaining privacy budget of the current round

[0112] As an optional implementation scheme of the present application, after calculating the remaining privacy budget after the privacy consumption in the current round according to the preset privacy budget, it also includes: when the privacy budget has not been consumed or the current round is less than a preset training number threshold, the generator noisy gradient is input into the LSTM neural network.

[0113] Determine whether the model training epoch or privacy budget has been reached exhausted, if not, the generator is noisy with gradients Feedback is given to the generator LSTM for optimization training again; if yes, the training is terminated. For example, it is determined whether 200 training times or the privacy budget has been reached. Exhausted.

[0114] As an optional implementation scheme of the present application, outputting the synthetic discrete-time dynamic graph of the next moment also includes: when the current round is equal to a preset training number threshold, outputting the synthetic discrete-time dynamic graph of the next moment.

[0115] When the number of training times reaches the specified model training Epoch, the training is stopped and the next moment synthetic discrete-time dynamic graph is output, such as the synthetic discrete-time dynamic graph of the sixth moment mentioned above.

[0116] The above approach effectively alleviates the difficulty in maintaining a consistent privacy-availability balance in discrete-time dynamic graphs, caused by the uneven distribution of private and non-private information. Furthermore, through dynamic noise adjustment, it addresses the potential privacy leaks caused by sudden changes in the dynamic graph structure at a given moment. This further enhances the privacy protection strength of discrete-time dynamic graph data releases while effectively ensuring the availability of dynamic graph data at other times.

[0117] Example 2

[0118] Based on the same principle as the above method, a privacy protection device for discrete-time dynamic graphs is proposed. Figure 2 A privacy protection device 100 for discrete-time dynamic graphs according to an embodiment of the present disclosure includes:

[0119] An input data acquisition module 110 is configured to acquire input data, wherein the input data includes an original discrete-time dynamic graph, a preset batch size, a discrete-time dynamic graph at a next moment, a preset gradient clipping constraint value, and a preset privacy budget;

[0120] A node sampling module 120 is configured to perform node sampling on the original discrete-time dynamic graph;

[0121] The fusion representation module 130 is used to calculate the attention weights of the neighboring nodes of the collected nodes and concatenate the attention weights; input the concatenated noisy discrete-time dynamic subgraph structural representation into the LSTM neural network to obtain a time and structure fusion representation of the noisy discrete-time dynamic subgraph;

[0122] A splicing and fusion representation module 140 is used to splice the time and structure fusion representations of the noisy discrete-time dynamic subgraphs at two different moments, and input the splicing result into the generator multi-layer perceptron to calculate the mutual information result;

[0123] A discrete dynamic graph generation module 150 is configured to input the time and structure fusion representation of the noisy discrete-time dynamic subgraph into the generator multi-layer perceptron to obtain a synthetic discrete-time dynamic graph at the next moment;

[0124] A gradient discrimination module 160 is configured to perform gradient discrimination on the synthetic discrete-time dynamic graph at the next moment according to the discrete-time dynamic graph at the next moment to obtain gradient information;

[0125] a gradient clipping module 170, configured to clip the gradient information according to the preset gradient clipping constraint value to obtain a first gradient clipping result and a second gradient clipping result;

[0126] a variance adjustment module 180 configured to input Gaussian noise and adjust the variance of the Gaussian noise according to a preset noise adjustment formula based on the first gradient clipping result and the mutual information result;

[0127] a privacy consumption calculation module 190, configured to calculate the privacy consumption based on the adjusted variance of the Gaussian noise, the preset order of the Ruili differential privacy, the second gradient clipping result, and the preset batch size, and determine the consumption of the preset privacy budget based on the privacy consumption;

[0128] The judgment module 200 is configured to output the synthetic discrete-time dynamic graph at the next moment when the preset privacy budget is consumed.

[0129] Obviously, those skilled in the art should understand that all or part of the processes in the above-mentioned embodiment methods can be implemented by instructing the relevant hardware through a computer program. The program can be stored in a computer-readable storage medium. When the program is executed, it can include the processes of the embodiments of the above-mentioned control methods. The modules or steps of the present invention can be implemented by a general-purpose computing device. They can be concentrated on a single computing device or distributed on a network composed of multiple computing devices. Alternatively, they can be implemented by program codes executable by the computing device, so that they can be stored in a storage device and executed by the computing device, or they can be made into individual integrated circuit modules, or multiple modules or steps therein can be made into a single integrated circuit module for implementation. In this way, the present invention is not limited to any specific combination of hardware and software.

[0130] Those skilled in the art will appreciate that all or part of the processes in the above-mentioned embodiments can be implemented by instructing the relevant hardware through a computer program. The program can be stored in a computer-readable storage medium. When the program is executed, it can include the processes of the above-mentioned control method embodiments. The storage medium can be a magnetic disk, an optical disk, a read-only memory (ROM), a random access memory (RAM), a flash memory, a hard disk drive (HDD), or a solid-state drive (SSD). The storage medium can also include a combination of the above-mentioned types of memory.

[0131] Example 3

[0132] Furthermore, an electronic device is proposed, comprising:

[0133] processor;

[0134] a memory for storing processor-executable instructions;

[0135] The processor is configured to implement the privacy protection method for discrete-time dynamic graphs described in Example 1 when executing the executable instructions.

[0136] The electronic device of the embodiment of the present disclosure includes a processor and a memory for storing processor-executable instructions, wherein the processor is configured to implement any of the aforementioned privacy protection methods for discrete-time dynamic graphs when executing the executable instructions.

[0137] It should be noted that the number of processors can be one or more. Furthermore, the electronic device in the embodiments of the present disclosure may also include an input device and an output device. The processor, memory, input device, and output device may be connected via a bus or other means, which are not specifically limited herein.

[0138] The memory, as a computer-readable storage medium for the privacy protection method for discrete-time dynamic graphs, can be used to store software programs, computer executable programs, and various modules, such as the programs or modules corresponding to the privacy protection method for discrete-time dynamic graphs according to the embodiments of the present disclosure. The processor executes the software programs or modules stored in the memory to perform various functional applications and data processing in the electronic device.

[0139] The input device can be used to receive input numbers or signals. The signals can be key signals related to user settings and function control of the device / terminal / server. The output device can include a display device such as a display screen.

[0140] The embodiments of the present application have been described above. The above description is illustrative and not exhaustive, and is not limited to the disclosed embodiments. Many modifications and variations will be apparent to those skilled in the art without departing from the scope and spirit of the described embodiments. The terminology used herein is selected to best explain the principles of the embodiments, their practical applications, or improvements to the technology in the market, or to enable other persons skilled in the art to understand the embodiments disclosed herein.

Claims

1. A privacy protection method for discrete-time dynamic graphs, characterized in that: include: Obtaining input data, where the input data includes an original discrete-time dynamic graph, a preset batch size, a discrete-time dynamic graph at a next moment, a preset gradient clipping constraint value, and a preset privacy budget; Node sampling is performed on the original discrete-time dynamic graph, attention weights of neighboring nodes of the collected nodes are calculated, the attention weights are concatenated, and the concatenated structural representation of the noisy discrete-time dynamic subgraph is input into an LSTM neural network to obtain a time and structure fusion representation of the noisy discrete-time dynamic subgraph; splicing the time and structure fusion representations of the noisy discrete-time dynamic subgraphs at two different moments, and inputting the spliced ​​result into the generator multi-layer perceptron to calculate the mutual information result; Inputting the time and structure fusion representation of the noisy discrete-time dynamic subgraph into the generator multi-layer perceptron to obtain a synthetic discrete-time dynamic graph at the next moment; performing gradient discrimination on the synthetic discrete-time dynamic graph at the next moment according to the discrete-time dynamic graph at the next moment to obtain gradient information; Clipping the gradient information according to the preset gradient clipping constraint value to obtain a first gradient clipping result and a second gradient clipping result; Inputting Gaussian noise, and adjusting the variance of the Gaussian noise according to a preset noise adjustment formula based on the first gradient clipping result and the mutual information result; Calculating the privacy consumption according to the adjusted variance of the Gaussian noise, the preset order of the Ruili differential privacy, the second gradient clipping result, and the preset batch size, and determining the consumption of the preset privacy budget according to the privacy consumption; When the preset privacy budget is consumed, the synthetic discrete-time dynamic graph at the next moment is output.

2. The privacy protection method for discrete-time dynamic graphs according to claim 1, characterized in that: The input data further includes: a preset node subset size and noise that obeys a standard normal distribution; performing node sampling on the original discrete-time dynamic graph, calculating the attention weights of neighboring nodes of the collected nodes, splicing the attention weights, and inputting the spliced ​​noisy discrete-time dynamic subgraph structural representation into an LSTM neural network to obtain a time and structure fusion representation of the noisy discrete-time dynamic subgraph, including: Selecting a node from the original discrete-time dynamic graph and using it as an element of the initialization subgraph node set; Generate a BFS tree with the element as the root according to the preset node subset size; Selecting nodes from the BFS tree, sampling the nodes according to a preset transition probability, expanding the number of elements in the initialized subgraph node set to a preset node subset size, and obtaining a discrete-time dynamic subgraph; According to the noise that obeys the standard normal distribution, the attention weights of the neighboring nodes of the nodes in the discrete-time dynamic subgraph are calculated, the attention weights are spliced, and the spliced ​​noisy discrete-time dynamic subgraph structural representation is input into the LSTM neural network to obtain the time and structure fusion representation of the noisy discrete-time dynamic subgraph.

3. The privacy protection method for discrete-time dynamic graphs according to claim 2, characterized in that: The time and structure fusion representations of the noisy discrete-time dynamic subgraphs at two different moments are spliced, and the spliced ​​result is input into the generator multi-layer perceptron to calculate the mutual information result, including: Traversing historical moments, and concatenating the time and structure fusion representations of the noisy discrete-time dynamic subgraphs at two different moments according to the historical moments to obtain a time and structure fusion long representation of the noisy discrete-time dynamic subgraphs; The time and structure fusion long representation of the noisy discrete-time dynamic subgraph is input into the generator multi-layer perceptron, and the mutual information results between different moments in the time series are generated according to the preset mutual information result inequality.

4. The privacy protection method for discrete-time dynamic graphs according to claim 1, characterized in that: Inputting Gaussian noise, and adjusting the variance of the Gaussian noise according to a preset noise adjustment formula based on the first gradient clipping result and the mutual information result, including: When the mutual information result is greater than a preset threshold, adjusting the variance of the Gaussian noise according to a preset noise attenuation rate; When the mutual information result is less than or equal to a preset threshold, the variance of the Gaussian noise is maintained.

5. The privacy protection method for discrete-time dynamic graphs according to claim 4, characterized in that: When the mutual information result exceeds a preset threshold, after adjusting the variance of the Gaussian noise according to the noise attenuation rate, the method further includes: A generator noisy gradient is formed according to the adjusted variance of the Gaussian noise.

6. The privacy protection method for discrete-time dynamic graphs according to claim 5, characterized in that: Calculating the privacy consumption according to the adjusted variance of the Gaussian noise, the preset order of the Ruili differential privacy, the second gradient clipping result, and the preset batch size, and determining the consumption of the preset privacy budget according to the privacy consumption, including: When the order of the preset Ruili differential privacy is greater than a preset order threshold, calculating the privacy consumption by using a first privacy consumption formula according to the variance of the Gaussian noise, the second gradient clipping result, and the preset batch size; When the order of the preset Ruili differential privacy is less than or equal to a preset order threshold, calculating the privacy consumption by a second privacy consumption formula according to the variance of the Gaussian noise, the second gradient clipping result, and the preset batch size; The remaining privacy budget after the privacy consumption in the current round is calculated according to the preset privacy budget.

7. The privacy protection method for discrete-time dynamic graphs according to claim 6, characterized in that: After calculating the remaining privacy budget after the privacy consumption in the current round according to the preset privacy budget, the method further includes: When the privacy budget is not exhausted or the current round is less than a preset training number threshold, the generator noisy gradient is input into the LSTM neural network.

8. The privacy protection method for discrete-time dynamic graphs according to claim 7, characterized in that: Outputting the synthetic discrete-time dynamic graph at the next moment also includes: When the current round is equal to the preset training times threshold, the synthetic discrete-time dynamic graph of the next moment is output.

9. A privacy protection device for discrete-time dynamic graphs, characterized in that: include: An input data acquisition module is configured to acquire input data, wherein the input data includes an original discrete-time dynamic graph, a preset batch size, a discrete-time dynamic graph at the next moment, a preset gradient clipping constraint value, and a preset privacy budget; A node sampling module, configured to perform node sampling on the original discrete-time dynamic graph; A fusion representation module is used to calculate the attention weights of the neighboring nodes of the collected nodes and concatenate the attention weights; The concatenated noisy discrete-time dynamic subgraph structural representation is input into the LSTM neural network to obtain the time and structure fusion representation of the noisy discrete-time dynamic subgraph; A splicing and fusion representation module is used to splice the time and structure fusion representations of the noisy discrete-time dynamic subgraphs at two different moments, and input the splicing result into the generator multi-layer perceptron to calculate the mutual information result; A discrete dynamic graph generation module is used to input the time and structure fusion representation of the noisy discrete-time dynamic subgraph into the generator multi-layer perceptron to obtain a synthetic discrete-time dynamic graph at the next moment; a gradient discrimination module, configured to perform gradient discrimination on the synthetic discrete-time dynamic graph at the next moment according to the discrete-time dynamic graph at the next moment to obtain gradient information; a gradient clipping module, configured to clip the gradient information according to the preset gradient clipping constraint value to obtain a first gradient clipping result and a second gradient clipping result; a variance adjustment module, configured to input Gaussian noise and adjust the variance of the Gaussian noise according to a preset noise adjustment formula based on the first gradient clipping result and the mutual information result; a privacy consumption calculation module, configured to calculate the privacy consumption based on the adjusted variance of the Gaussian noise, the preset order of the Ruili differential privacy, the second gradient clipping result, and the preset batch size, and determine the consumption of the preset privacy budget based on the privacy consumption; The judgment module is configured to output the synthetic discrete-time dynamic graph at the next moment when the preset privacy budget is consumed.

10. An electronic device, characterized in that: include: processor; a memory for storing processor-executable instructions; Wherein, the processor is configured to implement the privacy protection method for discrete-time dynamic graphs as described in any one of claims 1 to 8 when executing the executable instructions.

Images