Differential privacy-based range subgraph quantity publishing method

Abstract

The invention relates to the technical field of privacy protection, and discloses a differential privacy-based range sub-graph quantity publishing method, which comprises the following steps of: inputting a point attribute graph and a privacy parameter; sorting the nodes in an ascending order according to the values of the attributes; initializing an intermediate vector; enumerating copies of all mode graphs in the point attribute graph; constructing a differential privacy range tree by taking all Euclidean space points as input; obtaining a new discretization boundary value according to the discretization range of each query; and recursively traversing the differential privacy range tree generated in the step 4 according to the attribute range, and obtaining the number of mode graph copies in the point attribute graph in the attribute range. According to the method, the efficient epsilon-DP method with the same additive error can be realized for the range subgraph counting problem of the band edge attribute through simple deformation. The method is simple and easy to deploy, and the time complexity is consistent with that of a non-privacy range sub-graph counting method.

Description

Technical Field

[0001] The present invention relates to the field of privacy protection technology, and in particular to a method for publishing the number of range subgraphs based on differential privacy. Background Art

[0002] A graph is a data structure that represents objects and their relationships through a set of nodes and edges, where nodes represent entities and edges represent relationships between entities. The data structure of a graph can be an adjacency list or an adjacency matrix, and edges can be undirected or directed, and can be weighted. The properties of a graph include connectivity, directionality, cycles, density and sparsity, etc. These properties determine the structure and analysis methods of the graph. Graphs are widely used, including social network analysis, network science, recommendation systems, path search, computer vision, bioinformatics, and network security. Graphs analyze user relationships in social networks, study network structure characteristics in network science, make personalized recommendations in recommendation systems, find the shortest path in map services, process image data in computer vision, analyze the interaction of biomolecules in bioinformatics, and detect abnormal patterns in network security. With the development of technology, the scope of application of graphs is still expanding, becoming an indispensable part of data science.

[0003] Subgraph counting, which is to count the number of times a certain pattern graph H (triangle, star, etc.) appears in a graph G, is an important problem in social network mining. For example, network pattern analysis has studied the repetitive and key functional patterns that appear in many real biological networks (such as gene regulation and metabolic networks), such as feedforward loops. Subgraph counting can provide important reference value for downstream community discovery and property analysis.

[0004] Range subgraph counting was proposed by Tao et al. to expand the concept of subgraph counting, give subgraph counting a new direction from a more practical application perspective, and provide range subgraph counting and enumeration methods for common subgraphs, balancing space and time. Range subgraph counting considers attribute graphs, that is, each node has an attribute value. Each query q will give a numerical range, and the query content is the induced graph g composed of points with attribute values ​​in this range. q The number of subgraphs in it. This meets practical needs. Usually, users query the properties of subgraphs composed of points within a certain range, such as interpersonal relationships in a specific age range. However, this type of method does not have privacy protection properties and is prone to leaking individual privacy information, which is not in line with the current trend of data protection.

[0005] A widely accepted and strong standard for ensuring data privacy is differential privacy, developed by Dwork et al. Two adjacent graphs are considered adjacent if they differ in exactly one edge. A method is considered differentially private if it ensures that the output generated for two adjacent databases is statistically indistinguishable. The concept of differential privacy sets the standard for providing strong privacy guarantees. In the field of privacy protection, diverse goals can lead to a variety of applications of differential privacy.

[0006] Therefore, how to design a range subgraph counting method with differential privacy properties is a problem that needs to be studied. Summary of the invention

[0007] In order to solve the above technical problems, the present invention provides a method for publishing the number of range subgraphs based on differential privacy, which solves the privacy protection problem in the range subgraph counting problem. Specifically, the present invention designs a range subgraph counting method with differential privacy properties. First, the method achieves a good balance between privacy and practical errors. Compared with other methods for solving this problem, it has a smaller actual error under the premise of achieving the same privacy guarantee. Secondly, the method is concise and efficient, and easy to develop and deploy.

[0008] In order to solve the above technical problems, the present invention adopts the following technical solutions:

[0009] A range subgraph quantity publishing method based on differential privacy. The point attribute graph G = (V, E, A) is an undirected graph. Each node v∈V in G has a real-valued attribute vector A(v). For a given interval Define query point set And let G q Indicated by V q The induced subgraph of G, i.e., subgraph G q =G[V q ];set up The query set includes the following steps:

[0010] Step 1: Input the point attribute graph G = (V, E, A) and the privacy parameter ε, where V represents the node set, E represents the edge set, and A represents the attribute set of the node; V and A have a one-to-one mapping relationship.

[0011] Step 2: Sort the nodes in ascending order according to the attribute values; for nodes with the same attribute values, sort them according to the initial labels of the nodes; let s:V→[n] represent the new order, where [n] represents the set {1,…,n}; n represents the number of nodes in the vertex attribute graph G;

[0012] Step 3: Initialize the intermediate vector w u,v= 0, u, v∈V; enumerate all copies of the pattern graph H in the point attribute graph, let w s(u),s(v) =w s(u),s(v) +1, where u is the node with the smallest ranking value in the copy of the current pattern graph H, and v is the node with the largest ranking value in the copy of the current pattern graph H; s(u) and s(v) represent the sequence numbers of the sorted node u and node v respectively;

[0013] Step 4: Build a differential privacy range tree using all Euclidean space points as input The root node of the differential privacy range tree is The Euclidean space points are all pairs (i, j), i, j∈V;

[0014] Step 5: Discretize the range of each query q∈Q Get new discretization boundary values r′ q , l q is the left boundary value of query q, r q is the right boundary value of query q;

[0015] Step 6: According to the attribute range Recursively traverse the differential privacy range tree generated in step 4 The number of copies of the pattern graph H in the point attribute graph within the attribute range is obtained.

[0016] Furthermore, in step 4, the differential privacy range tree is constructed using all Euclidean space points as input, specifically including the following steps:

[0017] S41, use total n 2 tuples (s(u),s(v),w (s(u),s(v)) ) is constructed with The root node of the range tree T x , where u,v∈V; for each tuple (s(u),s(v),w (s(u),s(v)) ) is called the one with weight w (s(u),s(v)) The Euclidean space points (s(u), s(v)), the first dimension is called the x-coordinate, and the second dimension is called the y-coordinate; the Euclidean space points are grouped according to the x-coordinate, and the Euclidean space points with the same x-coordinate belong to the same group;

[0018] S42, sort the Euclidean space points of each group by x coordinate, denoted as p 1 ,...,p n ;

[0019] S43, use p 1 ,...,p n Construct range tree T x, considering only the x coordinate, partition the first dimension by building a one-dimensional range tree; T x Each node of contains a one-dimensional range tree T associated with the second dimension y and boundary information;

[0020] S44, according to the y coordinate of T x The Euclidean space points covered by each node in are grouped and sorted, and a list of nodes contained in the node T is constructed. x The corresponding range tree T in y ;

[0021] S45, traverse the range tree T x All T y weights, add independent Laplace noise Y; x The root node is the root node, which contains boundary information and T y , and T y The range tree with Laplace noise added to the weights is called a differentially private range tree Where Y~Lap(t); Lap(t) represents the Laplace distribution with a scale factor of t and a mean of 0;

[0022] Furthermore, in step S43, the method for constructing a one-dimensional range tree specifically includes the following steps:

[0023] S431, given a set of points P = {(x i ,w i )}, where each point has an x-coordinate and a weight; the points are sorted by x-coordinate, denoted by x 1 ,...,x n ;

[0024] S432, recursively build a tree starting from the root node, setting the interval to x 1 to x n ;

[0025] S433, the interval corresponding to the tree node p is x l ,...,x r , let mid = l + r;

[0026] S434, use point x l ,...,x mid Recursively construct the left child node, using point x mid +1,...,x r Recursively construct the right child node; if the interval contains only one point, terminate the recursion;

[0027] S435, during backtracking, calculate the weight of the current tree node as the sum of its intervals:

[0028] node.weight=left.weight+right.weight;

[0029] node represents a tree node, node.weight represents the weight of the tree node, left.weight represents the weight of the left child of the current tree node, and right.weight represents the weight of the right child of the current tree node.

[0030] Further, in step 5, the discretization range of each query q∈Q Get new discretization boundary values The specific steps include:

[0031] S51, for left border Find the first attribute value under the current s mapping that is not less than The node number of ; s represents the sorted mapping in step 2;

[0032] S52, for the right boundary r, find the node number of the first attribute value not less than r under the current s mapping; s represents the sorted mapping in step 2.

[0033] Furthermore, step six specifically includes:

[0034] S61, will Decompose into ranges Will n,1,r q′ They are respectively recorded as low 1 ,high 1 ,low 2 ,high 2 ; Given range [low 1 ,high 1 ]×[low 2 ,high 2 ] and differentially private range trees from The root node starts the recursive query; low 1 ,high 1 ,low 2 ,high 2 Indicates the query range boundary; for the current node, if the node is in the range [low 1 ,high 1 ], use [low 2 ,high 2 ] for a one-dimensional range tree T y Execute the query; if low1 Located in the left child of the node, recursively query the left subtree; if high 1 If it is in the right child, recursively query the right subtree;

[0035] S62, returning the sum of the results of the left subtree and the right subtree of the root node, which is the number of ternary communities in the social network under the current attribute range.

[0036] Furthermore, in step S61, the process of executing a query on the one-dimensional range tree specifically includes the following steps:

[0037] S611, given a query range [low, high], starting from the root node of the one-dimensional range tree T; recursively querying from the root node of T;

[0038] S612, for the current node, if the node is in the range [low, high], return p.weight; if low is in the left subtree of p, recursively query the left subtree; if high is in the right subtree of p, recursively query the right subtree;

[0039] S613, backtrack, add the results of the left subtree and the right subtree and return them.

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

[0041] The present invention proposes the first efficient range subgraph counting method that satisfies the differential privacy property and has almost optimal additive error, wherein the running time of the method is polynomial time, which has practical significance. The present invention can realize an efficient ε-DP method with the same additive error for the range subgraph counting problem with edge attributes through simple transformation.

[0042] The method of the present invention can be extended to multi-dimensional attribute situations, which is common in practical applications. This property mainly comes from the scalability of differential privacy range trees. In addition, in multi-dimensional situations, the privacy and practicality of the present invention are still well balanced.

[0043] The method of the present invention is concise and easy to deploy, and its time complexity is consistent with the non-privacy range subgraph counting method. In addition, a simple estimation method for the sensitivity of subgraph counting in practice is provided, further enhancing its engineering application value. BRIEF DESCRIPTION OF THE DRAWINGS

[0044] Figure 1 It is a schematic diagram of the overall framework of the present invention;

[0045] Figure 2 Schematic diagram of a two-dimensional range tree construction process in an embodiment of the present invention. DETAILED DESCRIPTION

[0046] A preferred embodiment of the present invention is described in detail below with reference to the accompanying drawings.

[0047] Definition of terms:

[0048] Tree: A tree is an abstract data type or a data structure that implements this abstract data type, used to simulate a data set with tree-like structure properties.

[0049] Euclidean space: Euclidean space is a geometric space used to describe the position, distance and angular relationship of points. The dimensions range from one-dimensional straight lines, two-dimensional planes to three-dimensional physical spaces and even higher-dimensional mathematical abstractions. Points are represented by coordinates, and the distance between two points is calculated using Euclidean formulas. Its basic properties include that a straight line is the shortest path, angles are defined by the angle between vectors, and that translation and rotation preserve geometric properties.

[0050] The present invention proposes a method for publishing the number of range subgraphs based on differential privacy, which can help detect the number of communities in social network graph data. Specifically, the number of ternary community relationships can be detected for a local social network composed of individuals with different attributes in a large social network, while protecting individual privacy. The number of ternary community relationships can help detect the closeness between communities.

[0051] In this embodiment, the point attribute graph is a social network.

[0052] In this embodiment, the social network is first converted into an adjacency matrix representation. Figure 1 As shown, a subgraph is projected on a given social network, and then the intermediate vector is output to construct a differential privacy range tree. When querying, discretization is first performed, and then the differential privacy range tree is traversed and calculated. Specifically, this embodiment is performed in the following steps:

[0053] Step 1: Input a social network G = (V, E, A) with individual attributes, and a privacy parameter ε. V represents a set of individuals, E represents a set of relationships between individuals (such as friendships), and A represents a set of individual attributes (such as an individual's age, height, weight, etc.). The privacy parameter ε is a constant value used to balance privacy and practicality. Convert the social network into an adjacency matrix representation and store individual attributes in an array structure.

[0054] The adjacency matrix A is an n×n matrix, where n is the number of nodes in the social network G. The elements in the adjacency matrix A are defined as follows:

[0055] If there is an edge between node i and node j (edges in an undirected graph are bidirectional), then A[i][j]=A[j][i]=1.

[0056] If there is no edge between node i and node j, then A[i][j]=A[j][i]=0.

[0057] Step 2: Sort the nodes corresponding to all individuals in ascending order of attribute values. For nodes corresponding to individuals with the same attribute values, sort them by their initial labels. Let s:V→[n] represent the new order. Where [n] represents the set {1,…,n}, and store the mapping relationship in an array.

[0058] Step 3: Initialize the intermediate vector w u,v = 0, u, v∈V, that is, initialize a two-dimensional array; enumerate all ternary relationships in the entire social network, that is, the triangles of the social network graph, and calculate w s(u),s(v) =w s(u),s(v) +1, where u is the smallest sort value in the current ternary relationship copy (also called triangle copy), v is the largest sort value in the current ternary relationship copy, and s(u) and s(v) represent the sort values ​​of node u and node v, respectively, that is, the sequence numbers of node u and node v after sorting.

[0059] Step 4: The Euclidean space point w corresponding to the binary pair (i, j) (i,j) As input, construct a differentially private range tree Differentially Private Range Trees The root node is T x , i,j∈V.

[0060] like Figure 2 As shown, step 4 specifically includes the following steps:

[0061] Step 4-1: Use total n 2 tuples (s(u),s(v),w (s(u),s(v)) ) is constructed with The root node of the range tree T x , where u,v∈V; for each tuple (s(u),s(v),w (s(u),s(v)) ) is called the one with weight w (s(u),s(v)) The first dimension is called the x-coordinate and the second dimension is called the y-coordinate. The Euclidean space points are grouped according to the x-coordinate, and the Euclidean space points with the same x-coordinate belong to the same group.

[0062] Step 4-2: Sort each set of Euclidean space points by x, denoted as p 1 ,...,p n .

[0063] Step 4-3: Use p 1 ,...,p n Construct range tree T x, considering only the x coordinate, partition the first dimension by building a one-dimensional range tree. x Each node of contains a one-dimensional range tree T associated with the second dimension y and boundary information.

[0064] Step 4-4: For T x For each node in T, get the points covered by the node, group and sort them by y coordinate, and build a x A one-dimensional range tree T in y .

[0065] Step 4-4: Traverse the two-dimensional range tree T x All T y The weights of the , add independent Laplace noise Y. x The root node is the root node, which contains boundary information and T y , and T y The tree with Laplace noise added to the weights is called a differentially private range tree Where Y~Lap(t). Lap(t) represents the Laplace distribution with a scale factor of t and a mean of 0. Here is the setting Where n is the number of individuals in the social network, that is, the size of the node set.

[0066] Figure 2 In the example, the total number of nodes n=4.

[0067] Step 5: Based on the given individual attribute value range Get new discretization boundary values r q ′ ; l q is the left boundary value of query q, r q is the right boundary value of query q.

[0068] Step 5 specifically includes the following steps:

[0069] S51, for left border Find the first attribute value under the current s mapping that is not less than The node number of ; s represents the sorted mapping in step 2;

[0070] S52, for the right boundary \, find the node number of the first attribute value not less than \ under the current s mapping; s represents the sorted mapping in step 2.

[0071] Step 6: Based on individual attribute range Recursively traverse the differential privacy range tree generated in step 4 The number of ternary relationships in the social network within the attribute range is published, so as to obtain the number of ternary community relationship structures in the social network under different attribute ranges.

[0072] Step 6 specifically includes the following steps:

[0073] Step 6-1: Decompose into ranges Will n,1,\ q′ They are respectively recorded as low 1 ,high 1 ,low 2 ,high 2 , given [low 1 ,high 1 ]×[low 2 ,high 2 ] and differentially private range trees from The root node of the recursive query starts. For the current node, if the node is in the range [low 1 ,high 1 ], use [low 2 ,high 2 ] for a one-dimensional range tree T y Execute the query (calling the one-dimensional tree query). If low 1 Located in the left child of the node, recursively query the left subtree; if high 1 If it is in the right child, recursively query the right subtree.

[0074] Preferably, in step 6-1, the process of executing a query on the one-dimensional range tree is specifically as follows:

[0075] Step 6-1-1: Given a query range [low, high], start from the root node of the one-dimensional range tree T. Start recursive query from the root node of T.

[0076] Step 6-1-2: For the current node, if the node is in the range [low, high], return p.weight. If low is in the left subtree of p, recursively query the left subtree; if high is 1 If it is in the right subtree, recursively query the right subtree.

[0077] Step 6-1-3: Backtrack, add the results of the left subtree and the right subtree and return them.

[0078] Step 6-2: Return the sum of the results of the left subtree and the right subtree of the root node, which is the number of ternary communities in the social network under the current attribute range.

[0079] Taking the ego-facebook and fbgov graph datasets as examples, we set different privacy parameter values ​​and compare the relative error sizes under different pattern graphs.

[0080] Pattern graph: The subgraph with the query quantity is called pattern graph. Generally, pattern graph is a graph with a constant number of edges, such as triangle, star, complete graph, etc.

[0081] Maximum relative error:

[0082] All methods are implemented in Python. The experiments were run on a system with a 128-core Intel(R) Xeon(R) Platinum 8358 CPU @ 2.60 GHz and 504 GB RAM.

[0083]

[0084] It is obvious to those skilled in the art that the present invention is not limited to the details of the exemplary embodiments described above, and that the present invention can be implemented in other specific forms without departing from the spirit or essential features of the present invention. Therefore, from any point of view, the embodiments should be regarded as exemplary and non-limiting, and the scope of the present invention is defined by the appended claims rather than the above description, and it is intended that all changes falling within the meaning and scope of the equivalent elements of the claims are included in the present invention, and any reference numerals in the claims should not be regarded as limiting the claims involved.

[0085] In addition, it should be understood that although this specification is described in terms of implementation methods, not every implementation method contains only one independent technical solution. This narrative method of the specification is only for the sake of clarity. Those skilled in the art should regard the specification as a whole. The technical solutions in each embodiment may also be appropriately combined to form other implementation methods that can be understood by those skilled in the art.

Claims

1. A method for publishing the number of range subgraphs based on differential privacy, characterized in that: The point attribute graph G = (V, E, A) is an undirected graph. Each node v∈V in G has a real-valued attribute vector A(v). For a given interval q = [l, r], define the query point set V q ={v∈V|l≤A(v)≤r}, and let G q Indicated by V q The induced subgraph of G, i.e., subgraph G q =G[V q ]; Let Q = {q = [l q ,r q ]|l q ,r q ∈R,l q ≤r q } is a query set; specifically includes the following steps: Step 1: Input the point attribute graph G = (V, E, A) and the privacy parameter ε, where V represents the node set, E represents the edge set, and A represents the attribute set of the node; V and A have a one-to-one mapping relationship. Step 2: Sort the nodes in ascending order according to the attribute values; for nodes with the same attribute values, sort them according to the initial labels of the nodes; let s:V→[n] represent the new order, where [n] represents the set {1,…,n}; n represents the number of nodes in the vertex attribute graph G; Step 3: Initialize the intermediate vector w u,v = 0, u, v∈V; enumerate all copies of the pattern graph H in the point attribute graph, let w s(u),s(v) =w s(u),s(v) +1, where u is the node with the smallest ranking value in the copy of the current pattern graph H, and v is the node with the largest ranking value in the copy of the current pattern graph H; s(u) and s(v) represent the sequence numbers of the sorted node u and node v respectively; Step 4: Build a differential privacy range tree using all Euclidean space points as input The root node of the differential privacy range tree is The Euclidean space points are all pairs (i, j), i, j∈V; Step 5: According to the discretization range [l q ,r q ], and obtain the new discretization boundary value l′ q ,r′ q , l q is the left boundary value of query q, r q is the right boundary value of query q; Step 6: According to the attribute range [l q′ ,r q′ ] Recursively traverse the differential privacy range tree generated in step 4 The number of copies of the pattern graph H in the point attribute graph within the attribute range is obtained.

2. According to the method for publishing the number of range subgraphs based on differential privacy according to claim 1, it is characterized in that: In step 4, the differential privacy range tree is constructed using all Euclidean space points as input, which specifically includes the following steps: S41, use total n 2 tuples (s(u),s(v),w (s(u),s(v)) ) is constructed with The root node of the range tree T x , where u,v∈V; for each tuple (s(u),s(v),w (s(u),s(v)) ) is called the one with weight w (s(u),s(v)) The Euclidean space points (s(u), s(v)), the first dimension is called the x-coordinate, and the second dimension is called the y-coordinate; the Euclidean space points are grouped according to the x-coordinate, and the Euclidean space points with the same x-coordinate belong to the same group; S42, sort the Euclidean space points of each group by x coordinate, denoted as p1,...,p n ; S43, using p1,...,p n Build range tree T x , considering only the x coordinate, partition the first dimension by building a one-dimensional range tree; T x Each node of contains a one-dimensional range tree T associated with the second dimension y and boundary information; S44, according to the y coordinate of T x The Euclidean space points covered by each node in are grouped and sorted, and a list of nodes contained in the node T is constructed. x The corresponding range tree T in y ; S45, traverse the range tree T x All T y weights, add independent Laplace noise Y; x The root node is the root node, which contains boundary information and T y , and T y The range tree with Laplace noise added to the weights is called a differentially private range tree Where Y~Lap(t); Lap(t) represents the Laplace distribution with a scale factor of t and a mean of 0; 3. According to the method for publishing the number of range subgraphs based on differential privacy according to claim 2, it is characterized in that: In step S43, the method for constructing a one-dimensional range tree specifically includes the following steps: S431, given a set of points P = {(x i ,w i )}, where each point has an x-coordinate and a weight; the points are sorted by x-coordinate, denoted x1,...,x n ; S432, recursively build a tree starting from the root node, setting the interval from x1 to x n ; S433, the interval corresponding to the tree node p is x l ,...,x r , let mid = l + r; S434, use point x l ,...,x mid Recursively construct the left child node, using point x mid +1,...,x r Recursively construct the right child node; if the interval contains only one point, terminate the recursion; S435, during backtracking, calculate the weight of the current tree node as the sum of its intervals: node.weight=left.weight+right.weight; node represents a tree node, node.weight represents the weight of the tree node; left.weight represents the weight of the left child of the current tree node, and right.weight represents the weight of the right child of the current tree node.

4. According to a method for publishing the number of range subgraphs based on differential privacy according to claim 1, it is characterized in that: In step 5, the discretization range [l q ,r q ], and obtain the new discretization boundary value l′ q ,r′ q , specifically including the following steps: S51, for the left boundary l, find the node number of the first attribute value not less than l under the current s mapping; s represents the sorted mapping in step 2; S52, for the right boundary r, find the node number of the first attribute value not less than r under the current s mapping; s represents the sorted mapping in step 2.

5. According to a method for publishing the number of range subgraphs based on differential privacy according to claim 2, it is characterized in that: Step 6 specifically includes: S61, will [l q′ ,r q′ ] is decomposed into range [l q′ ,n]×[1,r q′ ]; q′ ,n,1,r q′ They are denoted as low1, high1, low2, high2 respectively; given the range [low1, high1] × [low2, high2] and the differential privacy range tree from The recursive query starts from the root node of ; low1, high1, low2, high2 represent the query range boundaries; for the current node, if the node is in the range [low1, gigh1], then use [low2, high2] to query the one-dimensional range tree T y Execute the query; if low1 is in the left child of the node, recursively query the left subtree; if high1 is in the right child, recursively query the right subtree; S62, returning the sum of the results of the left subtree and the right subtree of the root node, which is the number of ternary communities in the social network under the current attribute range.

6. According to the method for publishing the number of range subgraphs based on differential privacy according to claim 5, it is characterized in that: In step S61, the process of executing a query on the one-dimensional range tree specifically includes the following steps: S611, given a query range [low, high], starting from the root node of the one-dimensional range tree T; recursively querying from the root node of T; S612, for the current node, if the node is in the range [low, high], return p.weight; if low is in the left subtree of p, recursively query the left subtree; if high is in the right subtree of p, recursively query the right subtree; S613, backtrack, add the results of the left subtree and the right subtree and return them.

Images