Weighted graph generation method based on localized differential privacy and server

Abstract

The invention provides a weighted graph generation method based on localized differential privacy, which comprises the following steps of: constructing a sub-graph by using a non-privacy edge of each node in a network structure, and performing community division on the sub-graph; according to a community division result, uploading a node noise degree vector to calculate an optimal partition; according to a result of the optimal partition, clustering is carried out by using a clustering algorithm; generating a weighted graph by using an improved CL algorithm according to a clustering result; and protecting the weight of the generated weighted graph, and assigning the weight to the edge of each node. The weighted graph generation method and system based on localized differential privacy provided by the invention do not depend on global graph information, are suitable for a distributed environment and a peer-to-peer network, and can protect the privacy of a user; by introducing a community division and clustering technology, the accuracy and effectiveness of graph generation are improved; a proposed weight protection method can keep the effectiveness of graph data while protecting privacy; the method has good adaptability and flexibility, and can be adjusted and optimized according to different requirements.

Description

Technical Field

[0001] The present invention relates to the field of graph data generation and privacy protection, and in particular to a weighted graph generation method based on localized differential privacy and a system thereof. Background Art

[0002] With the rapid development of information technology, graph data has become an important tool for describing and analyzing complex relationships in the real world. In many fields such as social networks, communication networks, and transportation networks, graph data is widely used to represent the relationships between entities. Traditional graph data generation methods usually rely on global graph information, that is, when generating graph data, it is necessary to access and process the data structure and content of the entire graph. However, this method faces storage and computing challenges when processing large-scale graph data, and there is also the risk of privacy leakage. In many application scenarios, such as social network analysis and financial transaction records, the data involved often contains sensitive information, which requires data processing and analysis under the premise of protecting personal privacy.

[0003] For example, Chinese patent CN109711197B describes a user privacy protection method for road networks, which relies on global graph information to achieve privacy protection; however, the patent needs to rely on global graph information and cannot be applied to distributed environments and peer-to-peer networks. In the absence of global graph information, it cannot effectively protect user privacy. Chinese patent CN114168805B also involves the generation of graph data, but it requires access to and processing of the data structure and content of the entire graph. Therefore, the patent cannot generate weighted graphs when nodes only have local information and cannot adapt to the needs of distributed systems. Chinese patent CN116778307B proposes an image tampering detection method, which generates images rather than graph data, so the patent cannot generate graph data, especially weighted graph data while protecting user privacy. Chinese patent CN116894263A targets the problem of privacy leakage in machine learning and adopts differential privacy technology, but does not focus on collecting and generating graph data without leaking user privacy. Chinese patent CN116543868A provides a weighted graph clustering method that relies on global graph information; however, the patent requires global graph information.

[0004] In order to solve the privacy protection problem, researchers have proposed a variety of privacy protection technologies, among which differential privacy is a widely recognized method. Differential privacy introduces randomness in the data publishing process to ensure that the impact of a single data item on the output result is controlled within a certain range, thereby protecting the privacy of individuals. However, most of the existing differential privacy technologies are applied to the privacy protection of numerical data, and there is relatively little research on the privacy protection of graph data, especially weighted graph data.

[0005] A weighted graph is a type of graph data in which the edges of the graph have weights, which can represent the strength, distance, cost and other properties of the relationship between entities. In practical applications, weighted graphs can more accurately reflect the relationship between entities. However, the addition of weight information also increases the difficulty of privacy protection, because weights may be associated with certain sensitive attributes, and directly exposing weight information may lead to privacy leakage.

[0006] Among the existing weighted graph generation methods, some studies focus on the privacy protection of unweighted graphs by introducing randomness or perturbations to protect user privacy. However, these methods often ignore the particularity of weight information when dealing with weighted graphs and fail to effectively protect the privacy information implied by the weights. In addition, while protecting privacy, existing methods may sacrifice the utility of graph data, resulting in a significant reduction in the application value of the generated graph data. Summary of the invention

[0007] In response to the above problems, technicians in this field have been exploring more effective weighted graph generation methods to achieve the goal of generating graphs with certain data utility while protecting privacy. This demand is particularly prominent in an environment without a trusted center. For example, in a distributed system or peer-to-peer network, each node may only know its own adjacency information but not the global graph information. In this case, how to generate a global or local weighted graph without leaking the private information of the nodes is a technical problem that needs to be solved urgently.

[0008] The motivation of this invention is to provide a novel weighted graph generation method that can effectively protect user privacy and generate weighted graphs with certain data utility without global graph information. To achieve this goal, this invention adopts localized differential privacy technology, combines advanced theories of graph theory and machine learning, and proposes an innovative graph generation framework.

[0009] The present invention provides a weighted graph generation method based on localized differential privacy, comprising the following steps: constructing a subgraph using the non-privacy edges of each node in a network structure, and performing community division on the subgraph; uploading a node noise degree vector to calculate an optimal partition according to the result of the community division; clustering the nodes according to the result of the optimal partition using a clustering algorithm; generating a weighted graph according to the result of the clustering using an improved CL algorithm; protecting the weights of the generated weighted graph, and assigning weights to the edges of each node.

[0010] As an implementation method, in the step of constructing a subgraph, the user selectively uploads non-private edge data according to his or her privacy preference. Furthermore, before the user uploads the non-private edge data, the system provides a user interface for the user to set privacy preferences, including but not limited to the selective disclosure and anonymization options of the edges. Still further, the privacy preferences set by the user are used to guide a privacy preference algorithm, which automatically screens and identifies the non-private edge data that the user is willing to disclose. Still further, after the non-private edge data uploaded by the user is verified, the system uses encryption technology to ensure the security of the data during transmission. Still further, a data verification mechanism is also provided to ensure the authenticity and validity of the uploaded non-private edge data and prevent forgery or tampering.

[0011] As an implementation method, in the community division step, a community detection algorithm is used to perform preliminary community division on the subgraph. Further, in the optimal partition calculation step, the generation of the node noise degree vector is determined by analyzing the connection mode and communication frequency of the node. Further, the calculation of the node noise degree vector further includes the following steps: collecting the communication records of the node in a specific time period; calculating the activity and connectivity of the node using the communication records; generating the node noise degree vector based on the activity and connectivity. Further, in the process of optimizing the community structure by the clustering algorithm, the similarity and distance metrics between nodes are considered to enhance the homogeneity of the community. Further, the similarity and distance metrics between nodes are calculated based on the node noise degree vector and historical interaction data. Further, a feedback mechanism is also provided to allow users to evaluate and adjust the generated optimal partitioning results to further improve the accuracy of community division.

[0012] As an implementation mode, in the optimal partition calculation step, the community structure is optimized by the node noise degree vector and the clustering algorithm. Further, the clustering algorithm optimization includes a verification step for evaluating the quality of the community structure after each clustering, and adjusting the parameters by a predetermined evaluation criterion. Still further, the verification step uses a modular quality index to measure the cohesion and separation of the community structure, and adjusts the number of clusters or boundaries in the clustering algorithm according to the result of the index. Still further, the process of optimizing the community structure also includes a feedback loop, which uses user feedback or community member activity data to further refine the boundaries of the community. Still further, the activity data used in the feedback loop includes but is not limited to the frequency of interaction between users, the amount of information transferred, or events in which they participate in common. Still further, the system can dynamically update the community structure based on real-time data streams to adapt to node changes in social networks or communication networks.

[0013] As an embodiment, in the graph generation step, the improved CL algorithm is used to generate edges within the community and between communities. Further, in the graph generation step, the improved CL algorithm includes a step of adjusting the edge generation probability to simulate the strength of real social relationships. Still further, the adjustment of the edge generation probability is based on the interaction data between nodes and pre-set social model parameters. Still further, the improved CL algorithm further includes a step for limiting the number of edges in the generated graph to avoid generating an overly dense or sparse network structure. Still further, the step of limiting the number of edges is achieved by dynamically adjusting the edge generation threshold in the algorithm. Still further, the improved CL algorithm also includes an adaptive learning mechanism that optimizes algorithm parameters based on quality feedback of the generated graph. Still further, the adaptive learning mechanism uses machine learning methods, such as reinforcement learning or neural networks, to continuously improve the quality of graph generation.

[0014] As an implementation mode, in the weight protection step, at least one differential privacy protection algorithm is used to add noise to the weight of the edge. Further, the at least one differential privacy protection algorithm includes one or more combinations of Laplace mechanism or Gaussian mechanism. Further, the Laplace mechanism implements privacy protection by adding random noise from Laplace distribution to each weight, wherein the scale parameter of the noise is determined by the privacy budget ε. Further, the Gaussian mechanism implements privacy protection by adding random noise from Gaussian distribution to the weight, wherein the mean and variance of the noise are also determined by the privacy budget ε. Further, the weight protection step also includes a noise sensitivity adjustment process for adjusting the noise addition strategy according to the importance and distribution characteristics of the weight. Further, the noise sensitivity adjustment process is based on statistical analysis of the weight, such as the frequency distribution of the weight or the correlation between the weight and the importance of the node. Further, the weight protection step also includes a noise vector optimization process for minimizing the difference between the weight distribution after adding noise and the original weight distribution.

[0015] As an implementation method, the weight protection algorithm adopts: adding noise to the total weight of each node, and then allocating noise according to the proportion of each edge to the total weight of the node; or, adding noise to the weight frequency vector, and realizing the change between information granularity and noise amount through the number of groups. Further, the scale parameter λ of the noise in the Laplace mechanism is calculated according to the privacy budget ∈ by the formula λ=1 / ∈. Further, the privacy budget ∈ is pre-set according to the required privacy protection level and the sensitivity of the data set. Further, the weight noise adding process includes a weight adjustment step to ensure that the weight after adding noise still reflects the relative strength of the relationship between nodes. Further, the weight adjustment step is implemented by dividing the weight after adding noise by a scaling factor, which is determined based on the statistical characteristics of the weight distribution. Further, the weight protection step also includes an error correction mechanism for reducing weight distortion caused by adding noise. Further, the error correction mechanism uses a calibration table based on historical data to fine-tune the weight after adding noise to better approximate the original weight.

[0016] As an implementation mode, it is applicable to distributed environments and peer-to-peer networks that do not rely on global graph information. Furthermore, the scaling factor used in the weight adjustment step is determined based on the standardized ratio of the weight distribution before and after noise addition. Still further, the scaling factor is calculated using the following formula: scaling factor = standard deviation of weights before noise addition / standard deviation of weights after noise addition. Still further, the standard deviation of the weights after noise addition is obtained by statistically analyzing the noisy weights. Still further, the weight adjustment step also includes a verification link to ensure that the adjusted weights meet predetermined distribution characteristics. Still further, the verification link uses a chi-square test or other statistical test method to evaluate the consistency of the distribution of the adjusted weights with the expected distribution. Still further, if the weights after weight adjustment do not meet the requirements of the verification link, the system will automatically readjust the scaling factor and repeat the weight adjustment step.

[0017] The present invention also provides a central server, which is suitable for a weighted graph generation method based on localized differential privacy, and is characterized in that it includes: a subgraph construction module, which is used to generate a subgraph according to non-privacy edge data uploaded by a user; a community division module, which is used to divide the subgraph into communities; a clustering module, which is used to cluster nodes according to a noise degree vector and a clustering algorithm; a graph generation module, which is used to generate a weighted graph using an improved CL algorithm; and a weight protection module, which is used to protect the weights of the generated weighted graph.

[0018] As an implementation mode, the subgraph construction module further includes a data verification unit for ensuring the accuracy and integrity of the non-privacy edge data uploaded by the user. Further, the community division module adopts at least one predefined community detection algorithm, such as a modular optimization algorithm or a greedy algorithm, to identify and divide the community structure. Further, the clustering module uses a noise degree vector to adjust the similarity threshold in the clustering algorithm to enhance the privacy protection effect of clustering. Further, the clustering module also includes a clustering result evaluation unit for evaluating the clustering quality and providing feedback to optimize the clustering process. Further, the improved CL algorithm of the graph generation module includes dynamically adjusting the generation probability of the edge to simulate the complex relationship between nodes in the weighted graph. Further, the weight protection module adopts at least one differential privacy technology, such as Laplace noise or Gaussian noise, to maintain the practicality of the data while protecting privacy. Further, the weight protection module also includes a noise adjustment unit for adjusting the degree of noise addition according to the importance and sensitivity of the weight.

[0019] The present invention also provides a weighted graph generation method based on localized differential privacy, comprising the following steps: obtaining non-private edge data uploaded by users, and generating subgraphs using the non-private edge data; performing community partitioning on the subgraphs using a community partitioning algorithm; uploading node noise degree vectors to calculate the optimal partition, and performing node clustering using a clustering algorithm; generating graphs using an improved CL algorithm; protecting weights and assigning weights to edges.

[0020] As an implementation method, the non-private edge is an edge that the user does not mind making public, and a subgraph of the original graph is formed by uploading the non-private edge. For a user, that is, a node, some edges are private information and some edges are non-private information. The central server assigns a number to each node, and then each node sends the non-private information to the central server in the form of a vector or dictionary. Taking node B as an example, AB is a private edge and BD is a non-private edge. Node B sends the vector [0,0,0,4,0,0,0,0,0,0,0,0] or the dictionary {"4",4}, where the first 4 in the dictionary {"4",4} is the number of the D node and the second 4 is the weight. After receiving the non-private edge vector or dictionary of each node, the central server constructs an adjacency matrix to obtain a subgraph composed of non-private edges. Even in very special cases, that is, all edges of the node are private edges, the central server can construct a subgraph that is not completely accurate based on the background knowledge it has collected.

[0021] As an implementation method, the community partitioning algorithm is used to solve the inaccuracy of random partitioning in the initial partitioning of the unweighted graph generation framework. The initial partitioning using subgraphs constructed with non-privacy edges and some community detection (partitioning) algorithms such as the Leiden algorithm and the Louvain algorithm is more accurate than random partitioning without any information, and is also conducive to subsequent partitioning.

[0022] As an implementation method, k-means clustering is used because social networks often have obvious community structures. After the initial division, it is necessary to upload the noisy adjacency vectors based on the initial division, and then use the k-means algorithm to divide again. This is to prepare for the subsequent generation of edges between communities and edges within communities.

[0023] As an implementation method, the random graph generation algorithm can be used to generate edges within the community first, and then generate edges between communities. The nodes within the community are more closely connected, while the nodes between communities are not closely connected, so these two situations need to be processed separately when generating edges.

[0024] As an implementation method, the method for protecting weights includes adding noise to the total weight of each node, and then allocating noise according to the proportion of each edge in the node to form a noise weight frequency vector, and then uploading the probability of the generated weight to the central node. Each node adds noise to the edge weight, and the Laplace mechanism is still adopted. The present invention assumes that the maximum and minimum weights of the graph are M and m, and its sensitivity is M-m+1. Assuming the privacy budget is ∈, the added Laplace noise is Lap(0,(M-m+1) / ∈), and then the noise is allocated according to the proportion of the edge weight to the sum of all edge weights of the node, and the weight of each weight after adding noise must be limited between m and M (it is worth noting that for non-privacy edges, the weight does not need to be noised). If the noisy weight is uploaded directly to the central server, the number of edges of the node will be leaked, and the attacker may obtain the user's privacy based on background knowledge, so it is necessary to upload it in a frequency manner here, that is, upload an M-m+1-dimensional vector, each The number of weights after noise is put into the dimension (you can also upload a dictionary with key as weight and value as the frequency of the weight after noise). For example, node G has 3 edges with weights of 6, 7, and 7 respectively. Its non-private edges 6 and 7 do not need to be processed, and its private edge 7 needs to be noised. Assume that its value after noise is 4, which is between the minimum weight 2 and the maximum weight 8, so it does not need to be processed (take m when it is less than m and take M when it is greater than M). Then upload the noise weight frequency vector [0,0,1,0,0,0,0] or upload the dictionary {"4":1}. The weight frequency vector does not leak the number of edges, because if the private edges after noise are k 4s, the same weight frequency vector or dictionary will be obtained regardless of k.

[0025] [a1,a2,...,a n ], [b1,b2,...,b n ]The distance between two vectors (L1) is as shown in the following table Calculated. Figure 1 As an example, the original frequency vector of node A is [1,0,0,1,1,0,0,0,0,0,0,0]. Assume that Figure 1 The weight of edge AD in is changed from 2 to 3. Then the weight frequency vector of A after modification is [0,1,0,1,1,0,0,0,0,0,0,0] and the L1 distance of is 2 as shown in the above formula. Its sensitivity is calculated according to the literature of Dwork & McSherry et al. (2006), that is, the sensitivity is 2. Reference: Dwork, C., McSherry, F., Nissim, K., Smith, A.: Calibrating noise to sensitivity in private data analysis. In Proceeding of 3rd Theory of Cryptography Conference. TCC 2006, pp. 265–284. Springer (2006).

[0026] As an implementation method, the protection method also includes considering reducing the sensitivity when adding noise, and adding noise to the weight frequency vector to obtain better results. Weight protection algorithm 2, considering that the sensitivity of method 1 is too large when the weight range is large, it will add too much noise, and consider reducing the sensitivity to 2, that is, the weight of each node is represented by a vector with a dimension of M-m+1, and each dimension is the number of privacy edges of the node at the weight. For example, node G has 3 edges, including 2 non-privacy edges and 1 privacy edge. The privacy edge is used to generate the vector [0,0,0,0,0,1,0], and then the noise of Lap(0,2 / ∈) is added. Assuming that the generated noise vector is [0,0,1,0,0,0,0], it is combined with the non-privacy edge to obtain the vector [0,0,1,0,1,1,0], and finally the noise weight frequency vector [0,0,0.33,0,0.33,0] is obtained and uploaded to the central server. In claim 6, when the weight range is large, too much noise will be added and the weight will be seriously tilted toward m and M. This method can reduce the above disadvantages.

[0027] As an implementation method, the community division algorithm utilizes community detection technology in graph theory to maximize the density of connections within a community while minimizing connections between communities.

[0028] As an implementation method, the improved CL algorithm further includes optimizing the generated graph to improve the naturalness and authenticity of the topological structure of the graph. The CL algorithm generates edges between nodes with the same probability, which does not meet this scenario and needs to be expanded. The original probability is After modification, it becomes P_(u∈c_m,w∈c_n)=d_(c_m c_n) / (N_m N_n), where m and n represent communities, u and v represent nodes, and N_m N_n represents the sum of the degrees of community m and community n. In this way, edges between communities and edges within communities can be generated with different probabilities.

[0029] The present invention also provides a weighted graph generation system based on localized differential privacy, a central server and at least one network node, wherein the central server further includes: a subgraph construction module for generating a subgraph consisting of non-privacy edges; a community division module for performing community division on the subgraph; a clustering module for performing clustering according to the node noise degree vector and the k-means algorithm; a graph generation module for generating a graph using an improved CL algorithm; and a weight protection module for protecting weights and assigning weights to edges.

[0030] Compared with the traditional weighted graph generation method and system, the present invention has significant advantages: first, the present invention does not rely on global graph information, is suitable for distributed environments and peer-to-peer networks, and can protect user privacy; second, the present invention improves the accuracy and effectiveness of graph generation by introducing community division and clustering technology; third, the weight protection method proposed in the present invention can retain the utility of graph data while protecting privacy; finally, the method of the present invention has good adaptability and flexibility, and can be adjusted and optimized according to different needs.

[0031] In view of the deficiencies of the prior art, the present invention provides a novel weighted graph generation method based on localized differential privacy, which generates a weighted graph with certain data utility while protecting user privacy. The solution of the present invention has any of the following advantages: it is independent of global graph information, suitable for distributed environments and peer-to-peer networks, and can still effectively protect user privacy in the absence of global graph information; it focuses on the generation of graph data, especially the generation of weighted graph data while protecting user privacy; it does not require the use of complex machine learning or deep learning algorithms, and can collect and generate graph data without leaking user privacy. It can be seen that the present invention proposes a brand-new weighted graph generation method, which has not been solved in the prior art.

[0032] Additional aspects and advantages of the present invention will be given in part in the following description, which will become obvious from the following description, or may be learned through practice of the present invention. BRIEF DESCRIPTION OF THE DRAWINGS

[0033] Figure 1 An initial example of a weighted graph is shown, which includes multiple nodes, multiple edges, the weight of each edge, and the connection relationship between them; this diagram is used to illustrate the structure and representation of the graph data of the weighted graph before the localized differential privacy protection method is applied.

[0034] Figure 2 yes Figure 1 Schematic diagram of the adjacency matrix of the graph data of the weighted graph shown.

[0035] Figure 3 An example of a subgraph generated by obtaining non-private edge data uploaded by a user is shown. This figure shows a subgraph composed of non-private edges when the ratio of a user's private edges to non-private edges is 1:1.

[0036] Figure 4 The result of community division of all nodes according to the community division algorithm is shown; this figure is divided into 4 communities, showing how to group nodes to protect user privacy.

[0037] Figure 5 The process of re-dividing nodes into communities based on noise degree vectors and clustering algorithms is shown; this figure illustrates how to use noise vectors and clustering algorithms such as k-means to re-divide communities for each node and further optimize the community division.

[0038] Figure 6 A schematic diagram of the network structure of a weighted graph protected by localized differential privacy is shown; this diagram shows how the central server forms a network structure with each node and conducts network communication or data contact.

[0039] Figure 7 The process of generating a weighted graph using a random graph generation algorithm and assigning values ​​to the edges is shown; this figure shows how to generate weights based on a noise frequency vector and how to assign these weights to the edges in the graph.

[0040] Figure 8 It is a flowchart of the central server collecting non-private edges; this figure describes in detail the steps of how users divide edges into private and non-private and upload non-private edges to the central server.

[0041] Fig. 9 The logical flow of the first weight protection method (also known as "weight protection method 1", "algorithm 1", etc.) is demonstrated; the first weight protection method includes adding noise to the total weight of each node, and how to distribute noise according to the proportion of each edge in the node.

[0042] Fig.10The logical flow of the second weight protection method (also known as "weight protection method 2", "algorithm 2", etc.) is demonstrated; the second weight protection method includes adding noise to the weight frequency vector, and how to achieve the change between information granularity and noise amount through the number of groups.

[0043] Fig.11 The Hellinger distance between the graphs generated by baseline method 1, baseline method 2 and the method of the present invention (this framework method) on the first data set (soc-sign-bitcoinalpha) and the original graph is shown; it can be found that the weight Hellinger distance of the present method is the smallest, indicating that the weight of the graph constructed by this method is closer to the original graph.

[0044] Fig.12 The Hellinger distances between the graphs generated by baseline method 1, baseline method 2 and the method of the present invention and the original graph on the second data set (soc-sign-bitcoinotc) are shown. It can be found that the weight Hellinger distance of the method is the smallest, indicating that the weight of the graph constructed by the method is closer to the original graph.

[0045] Fig.13 The relative errors of modularity coefficients between the graphs generated by baseline method 1, baseline method 2 and the method of the present invention on the first data set (soc-sign-bitcoinalpha) and the original graph are shown. It can be found that the present method is optimal under low privacy budget and suboptimal under high privacy budget.

[0046] Fig.14 The relative errors of the modularity coefficients between the graphs generated by baseline method 1, baseline method 2 and this framework method and the original graph on the second dataset (soc-sign-bitcoinotc) are shown. It can be found that this method is optimal under low privacy budget and suboptimal under high privacy budget.

[0047] Fig.15 The clustering coefficient errors between the graphs generated by baseline method 1, baseline method 2 and this framework method and the original graph on the first data set (soc-sign-bitcoinalpha) are shown. It can be found that the relative error of the clustering coefficient of this method is the smallest.

[0048] Fig.16 The clustering coefficient errors between the graphs generated by baseline method 1, baseline method 2 and this framework method and the original graph on the second data set (soc-sign-bitcoinotc) are shown. It can be found that the relative error of the clustering coefficient of this method is the smallest.

[0049] Fig.17The weight importance error between the graph generated by baseline method 1, baseline method 2 and this framework method and the original graph on the first dataset (soc-sign-bitcoinalpha) is shown. It can be found that the weight importance error of this method is the best under low privacy budget and the second best under high privacy budget.

[0050] Fig.18 The weight importance error between the graph generated by baseline method 1, baseline method 2 and this framework method and the original graph on the second dataset (soc-sign-bitcoinotc) is shown. It can be found that the weight importance error of this method is the best under low privacy budget and the next best under high privacy budget. DETAILED DESCRIPTION

[0051] The embodiments of the present invention are described in detail below, examples of which are shown in the accompanying drawings, wherein the same or similar reference numerals throughout represent the same or similar elements or elements having the same or similar functions. The embodiments described below with reference to the accompanying drawings are exemplary and are only used to explain the present invention, and cannot be interpreted as limiting the present invention.

[0052] It can be understood by those skilled in the art that the relevant modules mentioned in the present invention are hardware devices for executing one or more of the steps, measures, and schemes in the operations, methods, and processes described in the present application. The hardware devices can be specially designed and manufactured for the required purpose, or known devices in general-purpose computers or other known hardware devices can be used. The general-purpose computer has a program stored therein that is selectively activated or reconfigured.

[0053] It will be understood by those skilled in the art that, unless expressly stated, the singular forms "one", "said", and "the" used herein may also include plural forms. It should be further understood that the term "comprising" used in the specification of the present invention refers to the presence of the features, integers, steps, operations, elements and / or components, but does not exclude the presence or addition of one or more other features, integers, steps, operations, elements, components and / or groups thereof. It should be understood that when the present invention refers to an element being "connected" or "coupled" to another element, it may be directly connected or coupled to the other element, or there may be an intermediate element. In addition, the "connection" or "coupling" used herein may include wireless connection or coupling. The term "and / or" used herein includes any unit and all combinations of one or more associated listed items.

[0054] It will be understood by those skilled in the art that, unless otherwise defined, all terms (including technical and scientific terms) used herein have the same meaning as those generally understood by those skilled in the art in the art to which the present invention belongs. It should also be understood that terms such as those defined in common dictionaries should be understood to have meanings consistent with the meanings in the context of the prior art, and will not be interpreted with idealized or overly formal meanings unless defined as herein.

[0055] The present invention provides a weighted graph generation method based on localized differential privacy, comprising the following steps: constructing a subgraph using non-privacy edges; performing community partitioning on the subgraph using a community partitioning algorithm; uploading node noise degree vectors to calculate the optimal partition, and performing clustering using k-means; generating a graph using an improved CL algorithm; protecting weights and assigning weights to edges.

[0056] The present invention also provides a central server, which is suitable for the weighted graph generation method based on localized differential privacy described in claims 1 to 8, and is characterized in that it includes: a subgraph construction module, which is used to generate a subgraph based on the non-privacy edge data uploaded by the user; a community division module, which is used to divide the subgraph into communities; a clustering module, which is used to cluster nodes according to the noise degree vector and the clustering algorithm; a graph generation module, which is used to generate a weighted graph using an improved CL algorithm; and a weight protection module, which is used to protect the weights of the generated weighted graph.

[0057] The present invention also provides a weighted graph generation system based on localized differential privacy, comprising: a central server and at least one network node, wherein the central server further comprises: a subgraph construction module for generating a subgraph consisting of non-privacy edges; a community division module for performing community division on the subgraph; a clustering module for performing clustering according to the node noise degree vector and the k-means algorithm; a graph generation module for generating a graph using an improved CL algorithm; and a weight protection module for protecting weights and assigning weights to edges.

[0058] The weighted graph generation method and system based on localized differential privacy provided by the present invention do not rely on global graph information, are suitable for distributed environments and peer-to-peer networks, and can protect user privacy. By introducing community division and clustering technology, the accuracy and effectiveness of graph generation are improved. The proposed weight protection method can retain the utility of graph data while protecting privacy. It has good adaptability and flexibility and can be adjusted and optimized according to different needs.

[0059] Figure 1 An initial example of a weighted graph is shown, which includes multiple nodes, multiple edges, the weight of each edge, and the connection relationship between them; this figure is used to illustrate the structure and representation of weighted graph data before the local differential privacy protection method is applied. Figure 1 As shown, the weighted graph in the initial state includes at least one of the following elements: multiple nodes (e.g., A, B, C, D, ..., L), edges (e.g., AB, AC, AD, CD, ...), edge weights (e.g., the weight of the AB edge is 6, the weight of the AC edge is 5, the weight of the AD edge is 2, ...), and the relationship between each node and each edge (including: connected, unconnected, etc.). Each node represents a user, each edge represents a connection between users, and the edge weight can represent the closeness of the connection or the frequency of communication. For example, each node is Figure 1 The (A, B, C, D, ..., L) in the social network represents an independent user, and each edge is Figure 1 The (AB, AC, AD, CD, ...) in the graph represent the social connection or relationship between two users. The edge weight can be used to represent the association between different nodes (i.e., the degree of association) in numbers. In different application scenarios, the weights of different graphs have different meanings. In social networks, they can represent the closeness of the connection between two people, and in computer networks, they can represent the traffic between nodes.

[0060] , Figure 1 This paper provides an intuitive demonstration of an initial example of a weighted graph, which consists of multiple nodes, edges, and the weights between them, and clearly shows the structure and representation of weighted graph data before applying the localized differential privacy protection method. Figure 1 In the present invention, the following elements can be seen: a series of nodes (labeled as A, B, C, D, ..., L), representing independent users in a social network or independent devices in a computer network; a series of edges (such as AB, AC, AD, CD, etc.), representing social connections or network connections between nodes; and the weight of each edge (for example, the weight of the AB edge is 6, the weight of the AC edge is 5, the weight of the AD edge is 2, etc.), which quantifies the closeness of the connection between the nodes or the frequency of communication. The relationship between each node and the edge, including the connected and unconnected states, is reflected in the graph. The weight of the edge can have different meanings, depending on the application scenario. For example, in social network analysis, the weight may indicate the closeness of the connection between two users; while in a computer network, the weight may indicate the amount of traffic between nodes. Figure 1 The weighted graph in not only shows the static structure of nodes and edges, but also implies the dynamic interaction relationship between nodes. This representation method provides a basis for subsequent data processing and analysis, and also provides the necessary graph structure information for applying localized differential privacy protection methods.

[0061] Figure 2 yes Figure 1The adjacency matrix diagram of the graph data of the weighted graph is shown. The numbers at the intersection of the corresponding rows and columns in the adjacency matrix of the graph are the weights of the two nodes, and the connection relationship between them can also be reflected in the adjacency matrix. If the numbers at the rows and columns corresponding to the two nodes in the adjacency matrix are not 0, it means that there is an edge connection. If it is 0, there is no edge connection. In this figure, the central server will number each node and inform each node, such as node A is number 1, B is number 2, and so on. Without considering privacy, the node directly uploads the adjacency vector. The dimension of the vector is the number of nodes in the graph, and each bit of the adjacency vector represents the weight between the two nodes. As an embodiment, Figure 1 The midpoints AL are numbered from 1 to 12. Figure 1 The weighted graph can be transformed into the relationship between different nodes, so that the central server splices the adjacency vectors of each node into an adjacency matrix. Figure 2 As shown, the adjacency list of node A can be represented as a 12-dimensional vector [0,6,5,2,0,0,0,0,0,0,0,0], the i-th bit of which represents the edge relationship and weight between node A and other nodes, and the adjacency vector of node B can be represented as [6,0,0,4,0,0,0,0,0,0,0,0]; then, the central server concatenates the adjacency vectors of each node into an adjacency matrix to construct a global graph. That is to say, the central server obtains the adjacency vector of each node, so that there is a global view, and a global graph of node connection relationships can be constructed. In practical applications, the initial graph may contain millions of nodes and edges, which requires the algorithm of the present invention to be able to efficiently process large-scale data sets.

[0062] , Figure 2 Provides a schematic diagram of the adjacency matrix of weighted graph data, which is a Figure 1 The mathematical representation of the weighted graph shown in FIG. In the adjacency matrix, the weight between any two nodes is represented by the element at the intersection of the corresponding row and column in the matrix. At the same time, a non-zero value of the element indicates that there is an edge connection between the two nodes, while a zero value indicates that there is no direct connection. In this embodiment, the central server is responsible for assigning a unique number to each node in the graph and notifying each node of its number. For example, node A is numbered 1, node B is 2, and so on. In the absence of privacy issues, each node uploads its adjacency vector to the central server. The dimension of each adjacency vector is equal to the number of nodes in the graph, and each element in the vector represents the weight between the node and other nodes. Figure 1Taking nodes A to L in as an example, these nodes are numbered from 1 to 12. The adjacency vector of node A can be expressed as a 12-dimensional vector [0,6,5,2,0,0,0,0,0,0,0,0], where the value of the i-th position represents the weight between node A and the node numbered i. Similarly, the adjacency vector of node B is [6,0,0,4,0,0,0,0,0,0,0,0,0]. The central server integrates the collected adjacency vectors of each node to construct a complete adjacency matrix, thereby obtaining a global view of the weighted graph. In this way, the central server can construct a global graph that reflects the connection relationship of all nodes. When processing large-scale data sets in practical applications, such as graphs containing millions of nodes and edges, the algorithm of the present invention needs to have efficient processing capabilities to ensure that the adjacency matrix can be generated quickly and accurately and subsequent graph analysis can be performed.

[0063] As an implementation method, after receiving the non-private edge vector or dictionary of each node, the central server constructs an adjacency matrix to obtain a subgraph composed of non-private edges. Figure 1 Take node A as an example: First, the central server will number each node in alphabetical order, A is 1, B is 2, and so on. Assume that all edges are non-private edges (although it is impossible, but it is a good example), A has an edge relationship with B, C, and D, that is, 2, 3, and 4 have an edge relationship, and upload the adjacency list [0, 6, 5, 2, 0, 0, 0, 0, 0, 0], and the value is the weight. After the central server receives the adjacency list of each node, it can be directly assembled into a matrix (A is 1 and put it in the first row, B is 2 and put it in the second row, and the adjacency lists of all nodes are stacked up by row to form an adjacency matrix). With the adjacency matrix, the graph can be constructed.

[0064] Even in very special cases, that is, all edges of a node are private edges, the central server can construct a not-so-completely-accurate subgraph based on the background knowledge it has collected. For example, in extreme cases, every edge is private to the user, that is, he does not want to tell the central server whether he has an edge with this node. The central server can construct a subgraph based on the existing knowledge in the existing Internet. For example, if user A uses TikTok, Xiaohongshu, etc., and his follow list has B or C, then the central server can assume that A is related to B, and thus construct a not-so-accurate subgraph.

[0065] Figure 3An example of a subgraph generated by obtaining non-private edge data uploaded by a user is shown; this figure shows a subgraph composed of non-private edges when the ratio of a user's private edges to non-private edges is 1:1. Local differential privacy means that there is no trusted center, and users process data locally and submit it to an untrusted center for aggregation. The specific algorithm for local differential privacy can be used as follows: Assuming that two graphs differ by only one edge, the two graphs are adjacent data sets. For two adjacent data sets D, D′, the randomization algorithm A satisfies Pr[A(D)∈O]≤e ε Pr[A(D′)∈O], then algorithm A satisfies ε differential privacy. In the step of "obtaining non-private edge data uploaded by the user", the user's own privacy preference is judged, and the data of other users who are connected to the user are selectively obtained. These non-private edges constitute the basic structure of the subgraph, providing a starting point for subsequent community division and graph generation. The construction of the subgraph is a key step in privacy protection because it determines which information is public and which information needs to be protected. If the user uploads a complete adjacency vector, then after the central server receives its value, it is spliced ​​into a complete adjacency matrix to obtain a completely accurate global graph; however, in fact, some edges are private to the user, and the user is not willing to let the central server obtain the data. In the existing design, all edges are private edges; however, the actual situation is that not all edges are private edges, and there are also non-private edges (edge ​​relationships that users are willing to make public). Figure 3 The edges in can be understood as non-private edges. Figure 1 There are (for example, AB, AC) and Figure 3 The non-private edges can be understood as private edges. Introducing non-private edges into the construction of an initial edge subgraph is more conducive to the accuracy of subsequent community divisions, and solves the problem that the initial partition is random. At the same time, even if the user believes that all edges are private edges, this method can also be applied, that is, it degenerates into random division, or the central server can build a subgraph based on some public data on the Internet. Figure 3 It is the subgraph generated by the central server after the user uploads the non-privacy edge. This involves the trade-off between privacy protection and accuracy. Assume one case, each node uploads all actual connection relationships to the central server, so that the central server can build the most accurate global graph, but the node has no privacy at all; assume the second case, the edges uploaded by each node to the central server are all processed with privacy protection, that is, it is impossible to determine whether any edge is a real edge. This can achieve the greatest degree of privacy protection, but the graph generated by the central server is very different from the actual graph. A compromise method is adopted here, that is, the user chooses to upload some non-privacy edges by himself, and the central server is responsible for collecting the non-privacy edges that the user chooses to upload.

[0066] , Figure 3An example is provided to illustrate how to generate a subgraph based on the non-private edge data uploaded by the user when the ratio of the user's private edges to the non-private edges is equal. This process is a key link in achieving local differential privacy protection, ensuring the privacy of user data while providing an infrastructure for further graph analysis. In the present invention, the implementation of local differential privacy relies on an assumption that if two graphs differ by only one edge, they are considered to be adjacent data sets. For these adjacent data sets, the present invention adopts a specific randomization algorithm A, which can effectively aggregate the data while meeting specific differential privacy standards. In the step of "obtaining non-private edge data uploaded by the user", the system allows the user to selectively upload data of other users who are connected to him according to the user's privacy preference. These data form the basis of the subgraph and provide a starting point for subsequent community division and graph generation. Figure 3 The edges in are represented as non-private edges, and Figure 1 exists in but Figure 3 The edges not displayed in the data are considered private edges. In this way, even if the user chooses not to upload all the edges, the central server can still build a subgraph based on the received non-private edge data. This not only solves the problem of the accuracy of community division when all edges are considered private edges, but also provides users with a way to balance privacy protection with data accuracy. If the user uploads a complete adjacency vector, the central server can build a completely accurate global graph. However, this will sacrifice the user's privacy. On the contrary, if all uploaded edges are processed with privacy protection, although the maximum privacy protection is achieved, the graph generated by the central server will be very different from the actual graph. The present invention adopts a compromise method, allowing users to choose to upload some non-private edges, and the central server is responsible for collecting these data. In this way, the user's privacy is protected and the necessary data support for building a global graph is provided.

[0067] Figure 4 The results of community division of all nodes according to the community division algorithm are shown; this figure is divided into 4 communities, showing how to group nodes to protect user privacy. As an application scenario, for example, in social networks, Figure 4As shown in the figure, the community partitioning algorithm divides all nodes into different communities (for example, communities 1, 2, 3, and 4). Different nodes within each community are closely connected by edges (for example, BD, CD), while the connections between communities are relatively few (for example, there is only one DE edge between community 2 and community 3). This division helps to reasonably group user groups while maintaining the global structure of the graph. The results of community partitioning directly affect the quality of graph generation and the effectiveness of privacy protection. In the division of the prior art, random partitioning is adopted because there is no subgraph, which makes the result of the initial partition random and has a serious impact on the subsequent partitioning. When there is a subgraph, firstly according to Figure 2 The subgraph of the network is divided into communities by applying community detection algorithms, such as Leiden algorithm and Louvain algorithm, and the number of communities and nodes in each community are recorded, and then each node generates a vector. Figure 3 For example, in node A Figure 3 According to the community partitioning algorithm, the nodes in the network are divided into four groups: node A is the first group (i.e., community 1); nodes B, C, D, and E are the second group (i.e., community 2); nodes F, G, H, and I are the third group (i.e., community 3); and nodes J, K, and L are the fourth group (i.e., community 4). After each node obtains the specific grouping information, since the node knows which nodes it is connected to, a vector formed by the number of edges connected to the nodes in each group is formed. Each dimension of the vector is the number of edges connected between the node and the nodes in the group. Taking node A as an example, it is connected to nodes B, C, and D in group 2, but not to nodes in other groups, so its vector is [0,3,0,0]; taking node B as an example, it is connected to A in group 1 and B in group 2, so its vector is [1,1,0,0]. Since an attacker can directly upload the above vector based on the vector and related background knowledge, which may cause the leakage of user privacy, the Laplace mechanism in differential privacy is used to add noise to each dimension of the vector, and finally the noise vector is transmitted to the central server.

[0068] The non-private edges are edges that the user does not mind making public, and a subgraph of the original graph is constructed by uploading non-private edges. For a user, that is, a node, some edges are private information and some are non-private information. The central server assigns a number to each node, and then each node sends the non-private information to the central server in the form of a vector or dictionary. Taking node B as an example, AB is a private edge and BD is a non-private edge. Node B sends the vector [0,0,0,4,0,0,0,0,0,0,0,0] or the dictionary {"4",4}, where the first 4 in the dictionary {"4",4} is the number of the D node and the second 4 is the weight. After receiving the non-private edge vectors or dictionaries of each node, the central server constructs an adjacency matrix to obtain a subgraph composed of non-private edges. Even in very special cases, that is, all edges of the node are private edges, the central server can construct a subgraph that is not completely accurate based on the background knowledge it has collected. The node noise degree vector indicates that each node belongs to a different partition after partitioning. Each node needs to upload a vector that adds differential privacy noise. Each dimension of the vector is the number of edges between the node and the nodes in the community with the same number. Figure 3 Take A as an example, A, B, C, D, E are community 1, F, G, H, I are community 2, J, K, L are community 3, then a vector with the total number of communities will be uploaded, there are 3 communities, that is, the dimension is 3, because A knows that it is connected to B, C, D, and has no connection with other nodes, so the vector of A without adding differential privacy noise is [3, 0, 0]. If the vector is uploaded directly in this form, it will leak its own privacy information, so it is necessary to add Laplace noise that satisfies differential privacy to place the central server in combination with some background knowledge to infer the privacy of the user. The role of the noise degree vector is to pave the way for the subsequent k-means grouping, because the k-means algorithm requires a vector, and this vector is the node noise degree vector uploaded after partitioning using some common community partitioning algorithms.

[0069] , Figure 4 The results of applying a community partitioning algorithm are presented, which divides all nodes in the network into four different communities. This partitioning is crucial to protecting user privacy because it reduces unnecessary connections between nodes, thereby reducing the risk of privacy leakage. In the application scenario of social networks, such as Figure 4As shown in the figure, the community partitioning algorithm effectively groups nodes so that nodes in the same community are closely connected by edges, such as the connection between nodes B and D, and between C and D. At the same time, the number of connections between different communities is reduced to a minimum, such as community 2 and community 3 are connected by only one edge DE. Such a partitioning strategy helps to reasonably assign users to communities while maintaining the global structure of the network. The results of community partitioning have a direct impact on the quality of graph data and the effectiveness of privacy protection. In traditional technologies, community partitioning is often performed randomly due to the lack of subgraph information, which may lead to randomness in the initial partitioning results and have an adverse effect on future partitioning steps. However, in the present invention, firstly, according to Figure 2 For the subgraph shown in the figure, a community detection algorithm, such as the Leiden algorithm or the Louvain algorithm, is used to divide the nodes into preliminary communities and record the number of communities and member nodes. Figure 3 Take node A in as an example, according to the community division algorithm, node A is assigned to group 1 (community 1). Then, each node generates a vector based on its connection with other nodes, and each dimension of the vector represents the number of connections between the node and other nodes in the same community. For example, node A is connected to nodes B, C, and D of group 2 (community 2), so its vector is represented as [0,3,0,0]. In order to further protect user privacy and prevent attackers from inferring privacy information through vectors, the present invention uses the Laplace mechanism in differential privacy technology to add noise to each dimension of the vector. The noisy vector, i.e., the noise vector, is then securely transmitted to the central server, thereby completing the division of the community without leaking user privacy. Through the above method, the present invention not only improves the accuracy and efficiency of community division, but also enhances the protection of user privacy by introducing differential privacy technology.

[0070] Figure 5The process of repartitioning and optimizing the community of nodes in a social network by using a noise degree vector combined with a clustering algorithm is described in detail. This step of the present invention is the core of the community partitioning method, which aims to improve the quality of the community structure by increasing randomness and privacy protection. In this process, the noise degree vector of each node is first calculated, which is generated based on the connection characteristics of the node and the preset privacy protection level. Subsequently, the k-means clustering algorithm is used to re-cluster all nodes according to the noise degree vector. This step helps to discover a tighter community structure in the social network while protecting user privacy. In order to further enhance the randomness and privacy protection of community partitioning, the present invention introduces an improved CL algorithm to generate edges within the community. The improvement of the CL algorithm is that it can adjust the generation probability of edges according to the characteristics of the community structure, so as to better simulate real social relationships. After the edges within the community are generated, a weight protection step is performed to perform differential privacy protection on the weights of the edges. This step ensures that even when publishing or sharing weighted graph data, no sensitive information of any single user or community is leaked. The weight protection method uses advanced noise addition technology to process the weight information to prevent the user's privacy information from being inferred from the weight. Figure 5 Through a series of logical processes and examples, the present invention clearly demonstrates how to optimize community division and generate a weighted graph that reflects the strength of real social relationships while protecting user privacy. This method is not only applicable to social networks, but can also be extended to other application scenarios that require community division and privacy protection.

[0071] The CL algorithm can be found in the following literature: William, A., Chung, F., Lu LY.: A random graph model for massive graphs. In Proceeding of the Thirty-Second Annual ACM Symposium on Theory of Computing. STOC 2000, pp. 171–180. ACM (2000). The improved CL algorithm introduced in the present invention can be understood as further improving the existing CL algorithm, so that the improved CL algorithm of the present invention can adjust the edge generation probability according to the characteristics of the community structure, enhance the randomness of community division and privacy protection, so as to better simulate real social relationships.

[0072] , the present invention is a process of re-dividing nodes into communities according to the noise degree vector and the corresponding clustering algorithm; this figure illustrates how to use the noise vector and the clustering algorithm to re-divide each node into a community and further optimize the community division. As an application scenario, for example, in a social network, in the step of "dividing each node into a community using the noise vector and the clustering algorithm", first, the noise degree vector of each node is calculated, and then the nodes are re-clustered using the clustering algorithm to optimize the community division. As an implementation method, the clustering algorithm can use the k-means algorithm. Then, according to the community structure characteristics of the social network, noise is introduced to enhance the randomness and privacy protection of the community division, and the improved CL algorithm is used to generate the edges within the community. Then, the weight protection step is used to protect the weights of the edges to ensure that the generated weighted graph can reflect the true strength of social relationships without leaking user privacy.

[0073] As an implementation method, the improved CL algorithm further includes optimizing the generated graph to improve the naturalness and authenticity of the topological structure of the graph. The CL algorithm generates edges between nodes with the same probability, which does not meet this scenario and needs to be expanded. The original probability is After modification, it becomes P_(u∈c_m,w∈c_n)=d_(c_m c_n) / (N_m N_n), where m and n represent communities, u and v represent nodes, and N_m N_n represents the sum of the degrees of community m and community n. In this way, edges between communities and edges within communities can be generated with different probabilities.

[0074] Social networks have obvious community structures. For example, employees of a company or classmates have close connections, but the connections with people from other companies or classmates from other schools are not so close. It is like the edges of nodes within the community are more dense, while the edges between nodes and other community nodes are sparser. Therefore, the present invention adopts the k-means algorithm, which is a classic cluster analysis method for dividing data points into k clusters. Its main goal is to divide n data points into k non-overlapping clusters so that the sum of the distances between each data point and the center of the cluster to which it belongs (i.e., the mean of all points in the cluster, called the centroid or centroid) is minimized. This process is called intra-cluster aggregation measure, which reflects the closeness of the cluster. The basic steps of the k-means algorithm are as follows: randomly select k data points as the initial centroid, or pre-specify them by other methods; assign each data point to the cluster represented by the nearest centroid. The closest distance is usually calculated using Euclidean distance, but other distance metrics can also be used; recalculate the centroid of each cluster, that is, the mean of all points in the cluster; repeat the assignment and update steps until the stopping condition is met, such as the change in the centroid is less than a certain threshold, the preset number of iterations is reached, or the members of the cluster no longer change; when the model converges or other stopping conditions are met, the algorithm terminates and outputs the final cluster partitioning result. The characteristics of the k-means algorithm include: simple and efficient: the algorithm logic is simple, easy to implement, and computationally efficient. Widely used: applicable to a variety of data sets and fields, and is the preferred method for many clustering tasks. Parameter selection: the user is required to specify the k value, that is, the number of clusters, which may require domain knowledge or the use of techniques such as the elbow method to assist in the decision. Sensitive to the initial centroid: the convergence result of the algorithm may depend on the choice of the initial centroid, and multiple runs may be required to avoid local optimality. Assuming spherical clusters: k-means assumes that clusters are convex, spherical with similar sizes, which may not be applicable to all types of data distributions. Variants of the k-means algorithm include k-means++ (an improved initialization method), fuzzy k-means (to handle cases where a data point belongs to multiple clusters), and versions with different distance metrics or optimization techniques. Although k-means is a very popular clustering method, its assumptions and limitations need to be considered when using it.

[0075] In addition to the k-means algorithm, there are many clustering algorithms that can be used for community partitioning or cluster analysis of graph data, each of which has its own characteristics and applicable scenarios. For example, Hierarchical Clustering: Clustering is performed by creating a hierarchy of clusters, which can be agglomerated (bottom-up) or divisive (top-down). DBSCAN (Density-Based Spatial Clustering of Applications with Noise): A density-based clustering algorithm that can identify clusters of arbitrary shapes and has good robustness to noise points. Spectral Clustering: Uses the eigenvectors of the Laplacian matrix of the graph to perform clustering, which is particularly suitable for discovering communities with complex structures. Density Peak Clustering: A clustering method based on local density and distance to the nearest neighbor, which does not require a preset number of clusters.

[0076] As an optional implementation, the first weight protection method is described below. The implementation process of the first weight protection method in the present invention includes: using the Laplace mechanism to add noise to the weights of the edges between nodes in the social network to achieve privacy protection. In this method, the maximum weight M and the minimum weight m in the weighted graph of the social network are first defined, so as to determine the sensitivity of the weight as M-m+1. Privacy budget ∈ is a key parameter of this method. According to this parameter, the present invention introduces Laplace noise The noise is used to adjust the weight of each node edge to protect user privacy. During the noise addition process, the weight of each edge is allocated with corresponding noise according to its proportion to the total weight of all edges of the node, ensuring that the weight after noise addition is within the range of [m,M]. In particular, for non-privacy edges, the present invention does not perform noise addition processing on them to maintain the original characteristics of the graph data. However, for privacy edges, noise addition is a necessary step. In order to avoid the privacy leakage problem that may be caused by directly uploading the noisy weights, the present invention adopts a frequency upload method. Specifically, the present invention generates a vector of length M-m+1, in which each dimension represents the frequency of occurrence of a noisy weight. In addition, it can also be uploaded in the form of a dictionary, where the key is the weight and the value is the frequency of occurrence of the weight after noise addition. Taking node G as an example, assume that it has 3 edges with weights of 6, 7 and 7, respectively, of which 7 is a privacy edge that needs to be noised. After adding noise, if the weight becomes 4, the present invention will upload a vector such as [0,0,1,0,0,0,0], or upload a dictionary {"4":1} to represent the frequency of the edge with a weight of 4 after adding noise. The advantage of this method is that even if the weights of multiple edges are the same after adding noise, the uploaded frequency vector or dictionary will not change, thereby effectively avoiding the leakage of edge number information. The first weight protection method clearly demonstrates the implementation steps and privacy protection logic of the weight protection method of the present invention, and proves the innovation and effectiveness of the present invention in protecting user privacy and maintaining the practicality of graph data.

[0077] ,The first weight protection method uses the Laplace mechanism to add noise to the weights of the edges between each node. Assume Figure 4 The maximum weight and minimum weight of the weighted graph of the social network in are M and m respectively, then the sensitivity of the weighted graph of the social network is M-m+1. Assuming the privacy budget is ∈, the added Laplace noise is Then the noise is distributed according to the ratio of the edge weight to the sum of all edge weights of the node, and the weight of each weight after adding noise should be limited between m and M, but the weight does not need to be added noise for non-privacy edges. If the noisy weight is uploaded directly to the central server, the number of edges of the node will be leaked, and the attacker may obtain the user's privacy based on background knowledge, so it is necessary to upload it in a frequency manner here, that is, upload an M-m+1-dimensional vector, and put the number of weights in each dimension after adding noise. You can also upload a dictionary with the key as the weight and the value as the frequency of the weight after noise addition. For example, node G has three edges (non-private edge GE, private edge GF, non-private edge GI), and the weights of these three edges are: non-private edge GE weight is 6, private edge GF weight is 7, and non-private edge GI weight is 7; node G's non-private edges GE and GI do not need to be noised, but node G's private edge GF needs to be noised; assuming that the value of the private edge GF after noise addition is 4, 4 is between the minimum weight 2 and the maximum weight 8, so it does not need to be processed (when it is less than m, take m; when it is greater than M, take M); then, upload the noise weight frequency vector [0,0,1,0,0,0,0] or upload the dictionary {"4":1}. This method can ensure that the weight frequency vector does not leak the number of edges, because if the private edges after noise addition are k 4s, the same weight frequency vector or dictionary will be obtained regardless of k.

[0078] As another optional implementation, the second weight protection method is described below. Considering that the sensitivity of the first weight protection method is too high when the weight range is large, it will add too much noise. For example, consider reducing the sensitivity to 2, that is, the weight of each node is represented by a vector with a dimension of M-m+1, and each dimension is the number of privacy edges of the node at the weight. For example, node G has 3 edges, including 2 non-privacy edges and 1 privacy edge. The privacy edge is used to generate the vector [0,0,0,0,0,1,0], and then added Assume that the generated noise vector is [0,0,1,0,0,0,0], and then combine it with the non-private edge to get the vector [0,0,0,0,1,1,0]. Finally, the noise weight frequency vector [0,0,0.33,0,0.33,0.33,0] is obtained and uploaded to the central server. The dimension of the vector can also be reduced. Suppose it is reduced to k dimensions. Then the value of each dimension after reduction is the sum of the entire value of the adjacent [(M-m+1) / k]. Taking node G as an example, assuming k=3, then 7 / 3 is rounded up to 3, and the three adjacent dimensions of the element vector are merged. The vector after the non-privacy edge is merged is [1,0,0]. Suppose the generated noise vector is [1,0,0], and then combined with the reduced vector [0,2,0] obtained by the non-privacy edge, the noise weight frequency vector [0.33,0.66,0] is finally obtained. When the central server receives the reduced vector, it converts it into [0.11,0.11,0.11,0.22,0.22,0.22,0]. In the weight generation stage, the frequency of the noise weight frequency vector is sampled as probability. Since there are two nodes on an edge, the average of the weights sampled from the two nodes can be taken when generating weights.

[0079] As a further development of weight protection method 1, the present invention proposes a second weight protection method, which aims to solve the problem of excessive sensitivity when the weight range is large. This method reduces sensitivity and introduces noise to more finely control the level of privacy protection. In this method, the weight of each node is represented as a vector whose dimension is equal to the difference between the maximum weight M and the minimum weight m plus 1, that is, M-m+1. Each dimension of the vector corresponds to a specific weight, and the value on it represents the number of privacy edges of the node at this weight. For example, for node G, if it has 3 edges, including 2 non-private edges and 1 private edge, then an initial vector [0,0,0,0,0,1,0] can be generated to represent the number of private edges at different weight levels. Next, Laplace noise is added to this initial vector. Where ∈ is the privacy budget parameter. Assuming that the added noise vector is [0,0,1,0,0,0,0], combined with the information of the non-private edge, the present invention updates the vector to [0,0,1,0,1,1,0]. Finally, this vector is converted into a weight frequency vector, which represents the frequency of occurrence of each weight in the node edge. For example, if the above vector is converted into a frequency vector, [0,0,0.33,0,0.33,0.33,0] is obtained, and then this frequency vector is uploaded to the central server. In order to further optimize this method, it is possible to consider reducing the dimension of the weight vector from M-m+1 to k dimensions, where k is an integer less than Mm. This can be achieved by grouping the weight range and merging similar weights, thereby reducing the dimension of the vector. For example, if k=3, the present invention may merge weights 0 to 3 into one dimension, weights 4 to 6 into a second dimension, and so on. In the weight generation stage, the frequencies in the noise weight frequency vector are used as probability distributions to sample weights for the edges of each node. Since each edge connects two nodes, the present invention can take the average of the weights sampled from the two endpoint nodes to determine the final weight of the edge. This method not only reduces the amount of noise introduced, but also maintains the distribution characteristics of the edge weights through the sampling mechanism, thereby protecting privacy while retaining the practicality of the graph data as much as possible.

[0080] Attached Figure 3-5 The key process of uploading noisy degree vectors and their role in community partitioning and graph generation are elaborated in detail. Specifically, the uploading and application of noisy degree vectors are divided into two stages, each of which targets different goals and needs. The first stage of uploading, that is, the first uploading of noisy degree vectors, is for preliminary community partitioning. At this stage, the user has uploaded non-private side information, and the central server uses this information to build an initial subgraph. Subsequently, based on the structure of the subgraph, the central server executes a community partitioning algorithm, such as the Leiden algorithm or the Louvain algorithm, to identify and partition the community structure in the graph. The second stage of uploading, that is, the second uploading of noisy degree vectors, is based on the first community partitioning. This time, the uploaded noisy degree vectors are used in an extended CL algorithm to generate a more refined graph structure. At this stage, each node performs a second community partitioning through a classification algorithm (such as the k-means algorithm) based on the results of the first community partitioning and its own noisy degree vector. This helps to further refine and optimize the boundaries of the community and provide more accurate community structure information for graph generation. Through the uploading and application of noisy degree vectors in these two stages, the method of the present invention not only protects the privacy of users, but also improves the accuracy and effectiveness of graph generation. The first community division ensures that the initial structure of the graph is consistent with the actual connection relationship of the users, and the second community division further optimizes the community structure of the graph on this basis, laying the foundation for the final generation of a high-quality weighted graph.

[0081] Analyzing the correlation between data is a basic and important technology in the field of data mining. It is used to discover the correlation between data in large databases, thereby mining the hidden relationships in the data, and is also conducive to improving the efficiency of data utilization. In the prior art, graph analysis, covariance matrix, regression analysis and other methods are usually used to analyze the correlation between data. For example, a univariate regression method is used for two variable data. According to the changes between the two variable data, the regression coefficient is determined, and then the value of the variable data is analyzed. However, when the existing method is used to analyze the correlation of data, the analysis results are greatly affected by the number of data, and the correlation of the analyzed data is relatively fixed, and the correlation between the data cannot be accurately used to mine the value of the data. Therefore, the present invention applies a new localized differential privacy protection method to generate a weighted graph.

[0082] Figure 6 The schematic diagram of the network structure using localized differential privacy to protect weighted graphs is shown; this figure shows how the central server forms a network structure with each node and conducts network communication or data connection. The network structure includes a server (also called a "Chinese server") and at least one node (also called a "device", "terminal", "user", etc.). When the number of nodes is more than 2, the server conducts network communication or data link with each node respectively, and the server is then called a central server. Figure 6 As shown, the central server assigns an identifier to each node (for example, nodes 1, 2, and 3) and generates a subgraph of the network structure, and then performs community division; the central server receives the noise degree vector uploaded by each node 1-3 and performs community division; then, the central server sends the community division result to each node 1-3 and generates a new network subgraph; then, the central server assigns values ​​to the edges according to the noise weight frequency vector.

[0083] Figure 7 The process of protecting weighted graphs using localized differential privacy is demonstrated. First, a weighted subgraph is generated through the non-private edges uploaded by the user, or a weighted subgraph is obtained by collecting the background knowledge of the nodes. Then, the subgraph is divided into communities using a community detection algorithm (for example, the Leiden algorithm, the Louvain algorithm, etc.). Then, each node is re-divided into communities based on the divided communities and the uploaded noise degree vector combined with a classification algorithm (for example, the k-means algorithm, etc.). Since the CL algorithm generates edges with a certain probability, it needs to be expanded to adapt to high probabilities between communities and low probabilities between communities. The original probability in the CL algorithm is The extended CL algorithm is Where m and n represent communities, u and v represent nodes, and N m N nDenotes the sum of the degrees of community m and community n. Then, the weight of the weighted graph is protected using the optional weight protection algorithm provided above, and finally a weight is assigned to each edge.

[0084] Figure 8 The process of collecting non-private edges is presented in detail, which is one of the key steps in the method of the present invention. In this process, users selectively upload non-private information of other users connected to them based on their own privacy settings. This information is then collected by the central server and used to construct a subgraph of the initial graph data. The core of the design of this process is to ensure that users have full control over their privacy information while ensuring that the necessary data support is provided for generating global or local graphs. Users can submit non-private edge information to the central server in two ways: one is to upload an adjacency vector, which contains the connection relationship and corresponding weights between the user and other nodes; the other is to upload a dictionary, which contains the edge information between the user and a specific node. In the attached Figure 8 In the process, each step is designed to protect user privacy while ensuring the practicality and accuracy of the data. When uploading non-privacy information, users can clearly specify which information they are willing to make public, and the central server builds a subgraph based on this information, laying the foundation for subsequent graph analysis and processing. Through this process, the present invention not only respects and protects the privacy rights of users, but also provides a flexible and secure method for the generation and analysis of graph data. This method is particularly useful in distributed systems or peer-to-peer networks, because in such environments, nodes may only have local information and do not have a complete view of the global graph.

[0085] like Figure 8 As shown in Figure 1, when collecting non-private edges, users can selectively upload non-private information of users they are connected to based on their privacy settings. This information is collected by the central server and used to construct a subgraph of the initial graph. The process is designed to ensure that users can control their own privacy information while providing the necessary data for the generation of weighted graphs. Users submit non-private edge information to the central server by uploading adjacency vectors or dictionaries.

[0086] Fig. 9 The flowchart of weight protection method 1 is shown in detail. The core of this method is to protect the total weight of the node by introducing noise, while ensuring the high practicality and sensitivity of the graph data. The implementation steps of this method are as follows:

[0087] Calculation phase: For each node, calculate the sum of the weights of the edges it owns to obtain the total weight of the node.

[0088] Noise adding stage: According to the set privacy protection level, the scale of Laplace noise is determined, and the corresponding amount of noise is added to the total weight of each node to protect the node weight from being accurately inferred.

[0089] Distribution stage: The total weight after adding noise is distributed to each edge of the node according to the proportion of each edge to the total weight of the node, forming a noise weight frequency vector.

[0090] Through this noise adding mechanism, even if the edge weight information is made public, the attacker cannot accurately restore the original weight information due to the presence of noise, thus effectively protecting user privacy.

[0091] Further, Fig. 9 The specific implementation steps of Algorithm 1 described in are as follows:

[0092] Initialize a weight attribute for each node to record the sum of the weights of all edges of the node.

[0093] Generate a Laplace noise value for each node, with a scale parameter of Where M and m are the maximum and minimum possible values ​​of the weight, respectively, and ε is the privacy budget.

[0094] According to the proportion of the weight of each edge to the total weight of the node, the noise value is assigned to each edge of the node, and the assigned weight is ensured to be within the range of [M, m].

[0095] Generate an array of length M-m+1 to record the frequency distribution of weights after adding noise. Taking M=2, m=1 as an example, the length of the array is 2, and the first position of the array records the number of edges with a weight of 1.

[0096] To avoid leaking the number of node edges, the weight frequency array is converted into frequency information. In the subsequent generation of the weighted graph, the edge weight can be determined by generating weights for two nodes and taking the average value. Fig. 9 The described weight protection method 1 not only performs well in protecting user privacy, but also maintains the practicality and accuracy of graph data through carefully designed noise addition and distribution strategies.

[0097] like Fig. 9As shown, weight protection method 1 aims to protect the total weight of the node by adding noise. This method has high sensitivity while maintaining the practicality of graph data. In the implementation process, the total weight of each node is first calculated, and then the corresponding Laplace noise is added to the total weight according to the predetermined privacy protection level. Next, according to the proportion of each edge in the total weight of the node, the noise is allocated to each edge to form a noise weight frequency vector. In this way, even if the weight information of the edge is disclosed, the original weight cannot be accurately inferred due to the addition of noise, thereby protecting user privacy. According to the following algorithm 1, first a weight attribute is generated for each node. The value of this attribute is the sum of the weights of each edge of the node. A noise value is generated for each node. The noise value satisfies Laplace noise, where the second parameter is Then, for each edge of the node, noise is allocated according to the proportion of the value of the weight attribute, and the weight should be between M and m after adding noise. Finally, a value of length M-m+1 is generated, and the number of weights M-m+i-1 is placed at the i-th position. Assuming M is 2 and m is 1, the first position of the array of length 2 is the number of weights 1. Since uploading the array directly will cause the number of edges of the node to be leaked, it is necessary to convert it into frequency. When generating edges later, you can choose to generate weights for the two nodes separately and then take the average.

[0098]

[0099] Fig.10 The logical flow of weight protection method 2 is described in detail. The method aims to reduce the sensitivity in the process of adding noise and optimize the privacy protection effect of weight frequency vector. This method pays special attention to reducing the impact of adding or deleting a single edge on the node weight frequency vector. This goal is achieved by introducing Laplace noise, which effectively reduces the sensitivity of the data. When implementing weight protection method 2, facing the situation of a large weight range, the present invention adopts grouping technology to adjust the balance between information granularity and noise amount. Specifically, the algorithm first divides the weight range M-m+1 into k groups to adapt to different weight intervals. Taking the example parameters m=1, M=10, k=2 as an example, weights 1 to 5 are classified into the first group, and weights 6 to 10 are classified into the second group. Then, the weights of each edge of each node are grouped and counted, and Laplace noise is added independently in each group to protect the weight information. In order to further protect privacy and prevent the uploaded weight frequency vector from leaking the number of node edges, the present invention converts the weight frequency vector into frequency information. During the graph generation phase, weights are randomly selected from the selected group through a sampling method, and the average weight of the two nodes is calculated to determine the final weight of the edge. Fig.10The described method not only improves the level of privacy protection, but also maintains the practicality and accuracy of graph data through carefully designed noise addition strategies and grouping techniques. This innovative weight protection method provides high flexibility and effectiveness for privacy protection in different application scenarios.

[0100] like Fig.10 As shown in Figure 2, weight protection method 2 focuses on reducing the sensitivity when adding noise and optimizing the privacy protection effect of weight frequency vectors. When implementing this method, considering that adding or deleting only one edge will affect the weight frequency vector of the node, this sensitivity can be reduced by adding Laplace noise to the weight frequency vector. In addition, when the difference between the maximum and minimum values ​​of the weight is large, the balance between information granularity and noise amount can be adjusted by grouping adjacent weight frequency vectors. This method not only improves the strength of privacy protection, but also maintains the practicality of graph data. According to the following algorithm 2, first divide M-m+1 into k groups. Assuming m is 1, M is 10, and k is 2, weights 1 to 5 are divided into 1 group, and weights 6 to 10 are divided into 1 group. The weights of each edge of the node are counted by group, and then Laplace noise is added to each group. Since directly uploading the array will cause the number of edges of the node to be leaked, it is necessary to convert it into frequency. When the weights are generated later, sampling is performed, and then a weight within the group is randomly assigned to the selected group, and finally the average of the two nodes is taken.

[0101]

[0102] Fig. 9 and Fig.10 The two different weight protection methods of the present invention are jointly explained, which reflect how the present invention achieves an innovative balance between protecting user privacy and preserving graph structure and weight information. The present invention demonstrates its adaptability by applying different noise addition strategies in the weight protection stage, and can meet diverse application scenarios and privacy protection requirements. Fig. 9 In , the first weight protection method is described. This method adds noise to the total weight of each node and distributes the noise according to the proportion of each edge to the total weight of the node, thereby maintaining the practicality of the graph data while protecting privacy. This method is particularly suitable for scenarios with high requirements for privacy protection of weight information. Fig.10In the paper, a second weight protection method is presented, which focuses on reducing the sensitivity when adding noise and enhancing the privacy protection effect by optimizing the weight frequency vector. This method is particularly effective when the weight range is large, because it can reduce the amount of noise added, thereby maximizing the retention of the original characteristics of the graph data while protecting privacy. Through these two methods, the present invention provides users with a flexible privacy protection solution, allowing users to choose the most appropriate weight protection strategy based on specific application requirements and privacy protection levels. This flexibility and adaptability is a significant advantage of the present invention and an important manifestation of its innovativeness.

[0103] like Fig. 9 and Fig.10 As shown, the above two weight protection methods provided by the present invention both reflect the innovative point of the present invention in striking a balance between protecting user privacy and retaining graph structure information and weight information. By introducing different noise addition strategies in the weight protection stage, the present invention can adapt to different application scenarios and privacy protection requirements, and provide users with a flexible privacy protection solution.

[0104] Adding noise that meets the requirements of differential privacy to each vector is reflected in any of the following three parts: 1) After the initial community division, each node needs to send a noisy vector to the central server, and the noise meets the differential privacy; 2) When using k-means for community division, the noisy vector is also sent to the central server, and the noise meets the differential privacy; 3) When protecting weights, the two methods also need to meet the differential privacy when adding noise to the weights. The step of adding noise to the total weight of the node in method 1 and the step of adding noise to the weight frequency in method 2.

[0105] Fig.11The comparison results of the framework method of the present invention and the other two baseline methods under the weighted hellinger distance evaluation index are shown. The figure shows the Hellinger distance between the graph generated by baseline method 1, baseline method 2 and the method of the present invention (this framework method) on the first data set (soc-sign-bitcoinalpha) and the original graph. The soc-sign-bitcoinalpha data set can be found in the following literature: Kumar, S., Spezzano, F., Subrahmanian, VS, Faloutsos, C.: Edge Weight Predic tion in Weighted Signed Networks. In Proceeding of IEEE International Conference on Data Mining. ICDC 2016. IEEE (2016). Baseline method 1, which combines the RABV protocol with generalized random response. Method 2 is that all users belong to one group, and then the CL algorithm is used to generate the graph. The specific implementation process of the comparative test can refer to the following literature: Reference 1: Ye, QQ., Hu, HB., Au, MH., Meng, XF., Xiao, XK.: LF-GDPR: A Framework for Estimating Graph Metrics With Local Differential Privacy. IEEE Transactions on Knowledge and Data Engineering 34(10), 4905-4920(2022). Reference 2: Wang, TH., Lopuhaa-Zwakenberg, M., L, ZT., Skoric, B., Li, NH.: Locally Differentially Private Frequency Estimation with Consistency. In Proceeding of Network and Distributed System Security Symposium. NDSS2020. ISOC(2020). It can be found that the weight Hellinger distance of this method is the smallest, indicating that the weight of the graph constructed by this method is closer to the original graph. The weighted Hellinger distance is used to measure the similarity of weight distributions. The closer it is to 0, the more similar the weight distributions are. Fig.11 In the present invention, we can see the framework method (such as Figure 7As shown in the figure, the method is superior to the other two methods in terms of weight protection. This shows that the present invention can better maintain the original characteristics of the weight distribution while protecting the weights. The Hellinger distance is used to measure the similarity between two distributions. The larger the Hellinger distance, the more dissimilar the distributions are, and the smaller the Hellinger distance, the closer the distributions are. Modularity is an indicator used to measure the strength of the community structure in a graph. The higher the modularity, the stronger the community structure, and vice versa. The clustering coefficient is more inclined to indicate the property that two nodes have common neighbors. The higher the clustering coefficient, the higher the possibility of having common neighbors, and vice versa. The weight importance error in this patent refers to the error between the top 10% of the total weights of the nodes in the graph and the top 10% of the total weights of the nodes in the generated graph.

[0106] like Fig.11 As shown in the figure, on the first data set (soc-sign-bitcoinalpha), the weight Hellinger distance between the graphs generated by baseline method 1, baseline method 2 and the method of the present invention (this framework method) and the original graph is compared. The weight Hellinger distance is a statistical indicator to measure the similarity of the weight distribution of two graphs, which can reflect the closeness of the generated graph to the original graph in terms of weight information. In this figure, the X-axis represents different privacy budget settings, and the Y-axis represents the weight Hellinger distance. The curve of the method of the present invention is kept at the lowest level at all privacy budget levels, showing that under various privacy protection requirements, the method can effectively maintain the weight distribution characteristics of the original graph, and the weight Hellinger distance is the smallest, indicating that the weight distribution of the generated graph is closest to the original graph. The weight Hellinger distance of the curve of baseline method 1 changes with the increase of privacy budget, which may be related to the way the method balances privacy protection and data utility. The weight Hellinger distance of baseline method 2 is higher due to the random edge generation method, indicating that it is not as accurate as the method of the present invention in protecting weight information. The method of the present invention optimizes the graph generation process by introducing differential privacy technology and combining two different weight protection algorithms, so that the generated graph maintains a high degree of consistency with the original graph in terms of weight information. Fig.11 The results in further confirm the effectiveness of the proposed method in weight protection, especially in the case of low privacy budget, the proposed method can effectively protect the weight information while maintaining the practicality of graph data.

[0107] Fig.12The comparison analysis of the weighted Hellinger distance between the graphs generated by baseline method 1, baseline method 2 and the method of the present invention (this framework method) and the original graph on the second data set (soc-sign-bitcoinotc) is shown. The soc-sign-bitcoinotc data set can be found in the following literature: Kumar, S., Hooi, B., Makhija, D., Kumar, M., Faloutsos, C., VS, Faloutsos.: REV2: Fraudulent User Prediction in Rating Platforms. In Proceeding of the Eleventh ACM International Conference on Web Search and Data Mining February. WSDM 2018, pp. 333-341. ACM (2018). The weighted Hellinger distance is an important indicator to measure the similarity of the weight distribution of two graphs, which can reflect the closeness of the generated graph to the original graph in terms of weight information. In this figure, the X-axis represents different privacy budget settings, and the Y-axis represents the weighted Hellinger distance. The curve of the method of the present invention remains at the lowest level within the entire privacy budget range, showing that under various privacy protection requirements, the method can effectively maintain the weight distribution characteristics of the original graph, and the weight Hellinger distance is the smallest, indicating that the weight distribution of the generated graph is closest to the original graph. The curve of baseline method 1 shows that as the privacy budget increases, the weight Hellinger distance increases. This may be because the randomness introduced by the privacy protection measures affects the accuracy of the weights. The weight Hellinger distance of baseline method 2 is higher due to the random way of generating edges, indicating that it is not as accurate as the method of the present invention in protecting weight information. The method of the present invention optimizes the graph generation process by introducing differential privacy technology and combining two different weight protection algorithms, so that the generated graph maintains a high degree of consistency with the original graph in terms of weight information. Appendix Fig.12 The results in further confirm the effectiveness of the proposed method in weight protection, especially in the case of low privacy budget, the proposed method can effectively protect the weight information while maintaining the practicality of graph data.

[0108] like Fig.12As shown, we can see the advantages of the method of the present invention in weight protection, especially in the case of low privacy budget, the method of the present invention can effectively protect weight information while maintaining the practicality of graph data. This method is little affected by the privacy budget. It is speculated that the reason is that the weight range is too large, resulting in a large sensitivity. Too much noise is added, which will cause the weight to shift toward the minimum m and the maximum M. Even if the privacy budget increases, its impact on the weight hellinger distance is also very small. By comparing baseline method 1 and baseline method 2, it can be found that method 2 can better control the amount of noise when adding noise, thereby reducing the impact on data utility while protecting privacy. In this figure, the number of groups is the same as the weight range M-m+1. It can be found that due to the small sensitivity, when the privacy budget changes, the noise will change significantly, but due to the small amount of noise added, method 2 will not make the weight tilt too much toward m and M like method 1.

[0109] Fig.13 The figure shows the relative error comparison of the modularity coefficient between the graphs generated by baseline method 1, baseline method 2 and the method of the present invention (this framework method) and the original graph on the first data set (soc-sign-bitcoinalpha). The modularity coefficient is a key indicator to measure the strength of the community structure of the graph, reflecting the quality of the division and the compactness of the community in the graph. In this figure, the X-axis represents different privacy budget settings, and the Y-axis represents the relative error of the modularity coefficient, that is, the percentage difference between the modularity coefficient of the generated graph and the modularity coefficient of the original graph. The curve of the method of the present invention reaches the lowest point under low privacy budget, showing the optimal error control, while under high privacy budget, the error control is inferior to baseline method 1 but still better than baseline method 2. The curve of baseline method 1 gradually decreases with the increase of privacy budget, which may be because the increase of privacy budget allows more noise to be added, thereby balancing the error to a certain extent. Baseline method 2 has a large error in modularity coefficient due to the random generation of edges, and is less affected by the change of privacy budget, which indicates that its community structure is more seriously damaged. By combining the community division algorithm and the improved graph generation strategy, the method of the present invention effectively retains the community structure characteristics of the graph while protecting user privacy. Appendix Fig.13 The results in further confirm that the graph generated by the method of the present invention maintains a high consistency with the original graph in terms of modularity coefficient under different privacy protection levels, verifying the effectiveness and superiority of the present invention in protecting community structure.

[0110] Fig.14The comparative analysis of the relative errors of the modularity coefficients of the graphs generated by baseline method 1, baseline method 2 and the method of the present invention (this framework method) and the original graph on the second data set (soc-sign-bitcoinotc) is shown. The modularity coefficient is an important indicator to measure the strength of the community structure of the graph and reflects the quality of the community division in the graph. In this figure, the X-axis represents different privacy budget settings, and the Y-axis represents the relative error of the modularity coefficient, that is, the percentage difference between the modularity coefficient of the generated graph and the modularity coefficient of the original graph. The curve of the method of the present invention remains at a low level at all privacy budget levels, showing that under various privacy protection requirements, this method can effectively maintain the community structure characteristics of the original graph, and the error control is better than baseline method 1 and baseline method 2. The curve of baseline method 1 shows that as the privacy budget increases, the modularity coefficient error decreases, but the overall error is still high. Due to the random generation of edges, the modularity coefficient error of baseline method 2 is large, and the relative error does not change much with the increase of privacy budget, indicating that it has a more serious damage to the community structure of the graph. The method of the present invention optimizes the graph generation process by introducing a community partitioning algorithm and a graph generation strategy, combined with differential privacy technology, so that the generated graph is closer to the original graph in terms of modularity coefficient. Fig.14 The results in further confirm the effectiveness of the method of the present invention in maintaining the community structure characteristics of the graph, especially in generating a high-quality weighted graph with community structure characteristics close to the original graph while protecting user privacy.

[0111] Fig.15 The comparison of clustering coefficient errors between the graphs generated by baseline method 1, baseline method 2 and the method of the present invention (this framework method) and the original graph on the first data set (soc-sign-bitcoinalpha) is shown. The clustering coefficient is an important indicator to measure the degree of node clustering in the graph, reflecting the closeness of the connection between the node and its neighbors. In this figure, the X-axis represents different privacy budget settings, and the Y-axis represents the relative error of the clustering coefficient, that is, the percentage difference between the clustering coefficient of the generated graph and the clustering coefficient of the original graph. The curve of the method of the present invention remains at a low level at all privacy budget levels, showing that under various privacy protection requirements, this method can effectively maintain the clustering characteristics of the original graph, and the error control is better than baseline method 1 and baseline method 2. The curve of baseline method 1 shows that the clustering coefficient error fluctuates greatly under different privacy budgets, indicating that this method is not stable enough between privacy protection and graph feature preservation. Due to the random generation of edges, the clustering coefficient error of baseline method 2 is high, and the relative error does not change much with the increase of privacy budget, indicating that it seriously damages the clustering structure of the graph. The method of the present invention optimizes the graph generation process by introducing community division and clustering algorithms and combining differential privacy technology, so that the generated graph is closer to the original graph in terms of clustering coefficient. Fig.15The results in further confirm the effectiveness of the proposed method in maintaining graph clustering characteristics, especially in generating high-quality weighted graphs with structural features close to the original graph while protecting user privacy.

[0112] Fig.16 The clustering coefficient error comparison between the graphs generated by baseline method 1, baseline method 2 and the method of the present invention (this framework method) and the original graph on the second data set (soc-sign-bitcoinotc) is provided. The clustering coefficient is an important indicator to measure the degree of clustering of nodes in a graph. A high clustering coefficient means that the nodes in the graph are more likely to be connected to the neighbors of their neighbors, forming a close community structure. Fig.16 In the figure, the X-axis represents different privacy budget levels, and the Y-axis represents the relative error of the clustering coefficient. The curve of the method of the present invention is maintained at the lowest level within the entire privacy budget range, showing that the clustering characteristics of the original graph can be well maintained under different privacy protection strengths, and the error can be effectively controlled even under high privacy budgets. The curve of baseline method 1 fluctuates greatly, showing that its clustering coefficient error is more obviously affected by the privacy budget, and the error is higher at certain privacy budget levels. Due to the random way of generating edges, the clustering coefficient error of baseline method 2 is large and relatively stable, indicating that the generated graph is quite different from the original graph in clustering structure. The method of the present invention effectively retains the clustering characteristics of the graph while protecting user privacy through carefully designed community division and graph generation algorithms. Appendix Fig.16 The results verify the superiority of the proposed method in generating weighted graphs with high-quality community structures, especially in maintaining the clustering coefficient of the graph, where the proposed method shows significant advantages.

[0113] Fig.17 The weight importance error between the graphs generated by baseline method 1, baseline method 2 and the method of the present invention (this framework method) and the original graph on the second dataset (soc-sign-bitcoinotc) is shown. The graph generated by the method of the present invention has the best error performance in weight importance compared with the original graph, especially in the case of low privacy budget, the weight importance error of this method is the best, and it is suboptimal in the case of high privacy budget. Fig.17In the figure, the X-axis represents different privacy budget levels, and the Y-axis represents the weight importance error, which is calculated by comparing the error between the top 10% of the total weights of the nodes in the generated graph and the top 10% of the total weights of the nodes in the original graph. The figure shows the error curves corresponding to the three methods, among which the curve of the method of the present invention is significantly lower than that of baseline method 1 and baseline method 2 in the low privacy budget area, indicating that the method is more effective in protecting weight information. As the privacy budget increases, the weight importance error of the method of the present invention increases, but compared with baseline method 1 and baseline method 2, its growth rate is smaller, showing better stability and robustness. The error curve of baseline method 1 fluctuates greatly, showing that the performance is not stable enough under different privacy budgets. However, since baseline method 2 randomly generates edges between all nodes, the structure of the graph is severely damaged, and its weight importance error is high, and it is less affected by changes in privacy budget. Through a carefully designed weight protection algorithm, the method of the present invention can control the error well at different privacy budget levels, ensuring that the generated weighted graph maintains a high consistency with the original graph in weight importance. This result verifies the effectiveness of the method of the present invention in weight protection, as well as its adaptability and flexibility in different application scenarios.

[0114] Fig.18 The comparison of weight importance errors between the generated graph and the original graph of baseline method 1, baseline method 2 and the method of the present invention (this framework method) on the second data set (soc-sign-bitcoinotc) is shown. The method of the present invention performs well in controlling the weight importance error, especially under the setting of low privacy budget, achieving error minimization, and under the setting of high privacy budget, the error control is also better than baseline method 1 and baseline method 2. In this figure, the X-axis represents different privacy budget settings, and the Y-axis represents the weight importance error, which is quantified by comparing the difference between the top 10% of the total node weights of the generated graph and the original graph. It can be seen intuitively from the curve that the curve of the method of the present invention is significantly lower than that of baseline method 1 and baseline method 2 in the low privacy budget area, indicating that under strict privacy protection conditions, the method of the present invention can more accurately maintain the weight distribution characteristics of the original graph. With the increase of privacy budget, although the weight importance error of the method of the present invention has increased, it still remains at a low level overall, showing good adaptability and stability. In contrast, the error fluctuation of baseline method 1 is large, indicating that its performance under different privacy budgets is not stable enough. The baseline method 2 has a high error in weight importance due to the random edge generation method and is insensitive to changes in the privacy budget. The method of the present invention effectively balances the relationship between privacy protection and graph data practicality through two different differential privacy protection algorithms. Fig.18 The results in further confirm the superiority of the proposed method in weight protection and its application potential under different privacy protection requirements.

[0115] When implementing these methods, the present invention adopts meticulous experimental design and strict evaluation criteria to ensure the reliability and validity of the experimental results. Through these experiments, the present invention not only verifies the advantages of the method of the present invention in different evaluation indicators, but also demonstrates its potential and value in practical applications. In the implementation process, the present invention first uses a community partitioning algorithm to perform preliminary community partitioning on nodes, and then generates edges within the community and between communities through an optimized graph generation strategy, such as an extension of the CL algorithm. In addition, the present invention also protects weights and adopts two different differential privacy protection algorithms to adapt to different privacy protection requirements. These measures work together to make the method of the present invention outperform the baseline method in terms of clustering coefficient, proving that the present invention can effectively generate weighted graphs with high-quality community structures while protecting user privacy.

[0116] The innovation or technical advantage of the solution of the present invention lies in any of the following aspects: (1) Targeting weighted graph data: The solution of the present invention is particularly targeted at weighted graph data, while previous studies have mostly focused on unweighted graphs or attribute graphs. (2) Using local information rather than global information: In a scenario where no node or third party has global graph information, the solution of the present invention can effectively generate weighted graphs, which is missing in the prior art. (3) Balancing privacy and practicality: The solution of the present invention aims to find a balance between protecting user privacy and preserving the practicality of graph data. (4) Innovative weight protection algorithm: The solution of the present invention proposes two different differential privacy protection algorithms in the weight protection stage, which are suitable for high-sensitivity and low-sensitivity scenarios respectively, which is not seen in the prior art.

[0117] The above are only several preferred embodiments of the present invention. The letters in brackets in the text part and the letters in the diagrams in the drawings only represent the name symbols of the module or step. The specific meanings shall be subject to the description of the embodiment and the Chinese meaning. It should be pointed out that for ordinary technicians in this technical field, several improvements and modifications can be made without departing from the principle of the present invention, and these improvements and modifications should also be regarded as the protection scope of the present invention.

Claims

1. A weighted graph generation method based on localized differential privacy, The following steps are involved: Use the non-private edges of each node in the network structure to build a subgraph and divide the subgraph into communities; According to the result of the community division, the node noise degree vector is uploaded to calculate the optimal partition; According to the result of the optimal partitioning, clustering is performed using a clustering algorithm; According to the clustering result, a weighted graph is generated using an improved CL algorithm; The weights of the generated weighted graph are protected, and weights are assigned to the edges of each node.

2. The method according to claim 1, It is characterized in that In the subgraph construction step, users selectively upload non-private edge data according to their privacy preferences.

3. The method according to claim 1 or 2, It is characterized in that In the community division step, a community detection algorithm is used to perform preliminary community division on the subgraph.

4. The method according to claim 3, It is characterized in that In the optimal partition calculation step, the community structure is optimized through the node noise degree vector and clustering algorithm.

5. The method according to claim 4, It is characterized in that In the graph generation step, the improved CL algorithm is used to generate intra-community edges and inter-community edges.

6. The method according to claim 5, It is characterized in that In the weight protection step, at least one differential privacy protection algorithm is used to perform noise processing on the edge weights.

7. The method according to claim 6, It is characterized in that The weight protection algorithm adopts: Add noise to the total weight of each node, and then distribute the noise according to the proportion of each edge to the total weight of the node to form a noise weight frequency vector, and then generate the probability of the weight and upload it to the central node; or, The weight frequency vector is noised, and the change between information granularity and noise amount is achieved through the number of groups. Then, a noise weight frequency vector is formed, and the probability of regenerating the weight is uploaded to the central node.

8. The method according to any one of claims 7, It is characterized in that The method for protecting weights includes adding noise to the total weight of each node, and then allocating noise according to the proportion of each edge to the node to form a noise weight frequency vector, and then uploading the probability of regenerating weights to the central node further includes: The Laplace mechanism is used to add noise to the weights of the edges between each node. The maximum and minimum weights of the weighted graph of the social network are calculated as M and m respectively. Then the sensitivity of the weighted graph of the social network is M-m+1. The privacy budget is calculated as ∈, and the added Laplace noise is Then the noise is distributed according to the ratio of edge weight to the sum of all edge weights of the node, and the weight of each weight after noise addition is limited to between m and M, but the weight does not need to be noised for non-privacy edges; determine whether the noisy weight will directly leak the number of edges of the node. If the judgment is "yes", the noisy weight vector needs to be uploaded in a frequent manner, that is, an M-m+1-dimensional vector is uploaded, and the number of noisy weights in each dimension is placed to prevent attackers from obtaining the user's privacy based on background knowledge.

9. The method according to any one of claims 1 to 8, It is characterized in that Applicable to distributed environments and peer-to-peer networks that do not rely on global graph information.

10. A central server, applicable to the weighted graph generation method based on localized differential privacy according to claims 1 to 8, It is characterized in that include: Subgraph construction module, used to generate subgraphs based on non-private edge data uploaded by users; Community division module, used to divide the subgraph into communities; A clustering module, used to cluster nodes according to the noise degree vector and clustering algorithm; A graph generation module is used to generate weighted graphs using the improved CL algorithm; The weight protection module is used to protect the weights of the generated weighted graph.

Images