Multi-party cooperation graph calculation method with theoretical optimal calculation and communication complexity

Abstract

The invention relates to the technical field of graph calculation, in particular to a multi-party cooperation graph calculation method with theoretical optimal calculation and communication complexity, and the method comprises the steps: obtaining graph data of each participant, the graph data of each participant comprising node data and edge data; a target iteration round of a graph algorithm is obtained, and the graph algorithm carries out operation with the node as the center; the graph algorithm is iteratively executed in a target iteration round, node data and outgoing edge data of each participant are secretly shared to neighbor participants, and in the process of iteratively executing the graph algorithm in each round, for each participant, each outgoing edge update variable is calculated according to the node data and the outgoing edge data, the node data is updated according to the incoming edge data, and the node data is updated according to the incoming edge data. The incoming edge data includes update variables shared by the neighbor participants. Therefore, the problem that the scale of graph data which can be processed by multi-party cooperation graph calculation is limited due to relatively high cross-participant calculation overhead and transmission overhead in related technologies is solved.

Description

Technical Field

[0001] This application relates to the field of graph computing technology, and in particular to a multi-party collaborative graph computing method with theoretically optimal computational and communication complexity. Background Technology

[0002] Graph computing, broadly speaking, refers to the processing and computation of data with a graph structure. A graph structure consists of nodes and edges between them, with edges reflecting the relationships between the nodes. The core objective of graph computing is to extract specific information from graph-structured data. However, due to restrictions imposed by data privacy laws and commercial competition among graph data owners, directly sharing raw graph data is not feasible. Therefore, collaborative, privacy-preserving graph data analysis has become an increasingly urgent practical need, a problem also known as multi-party collaborative graph computing.

[0003] Multi-party collaborative graph computation techniques can be divided into two approaches. One approach involves outsourcing the graph data of each graph data owner in a secret sharing manner, with several third-party servers jointly performing computations on the encrypted graph data and finally feeding back the results to the respective graph data owners. In practice, this requires frequent execution of secure ordering protocols for the encrypted data, resulting in high cross-server computation and transmission overhead. The other approach involves each graph data owner directly distributing their graph data (privacy-protected) to other graph data owners in a secret sharing manner, with each owner collaboratively running a cryptographic protocol to complete the encrypted graph data computation. In practice, relying on two-party secure computation protocols with relatively high computation and transmission overhead, the scale of graphs that can be processed remains very limited, and the graph data processed by different subtasks overlaps. The computation and transmission complexity of executing a single node-centric computation iteration is the sum of the overhead of all participants. As the number of participants increases, the overall computation and transmission overhead will increase significantly. Summary of the Invention

[0004] This application provides a method, apparatus, electronic device, storage medium, and program product for multi-party collaborative graph computation with theoretically optimal computational and communication complexity, in order to solve the problem that the high computational and transmission overhead across participants in related technologies limits the scale of graph data that can be processed in multi-party collaborative graph computation.

[0005] The first aspect of this application provides a multi-party collaborative graph computation method with theoretically optimal computational and communication complexity, comprising the following steps: obtaining graph data for each participant, wherein the graph data for each participant includes node data and edge data, wherein the node data includes multiple node elements, and the edge data includes outgoing edge data and incoming edge data; obtaining the target iteration round of the graph algorithm, wherein the target iteration round of the graph algorithm is determined through negotiation among multiple participants, and the graph algorithm is performed with nodes as the center; iteratively executing the graph algorithm within the target iteration round, and secretly sharing the node data and outgoing edge data of each participant with neighboring participants, wherein, during the iterative execution of the graph algorithm in each round, for each participant, update variables are calculated on each outgoing edge based on the node data and outgoing edge data, and node data is updated based on incoming edge data, wherein the incoming edge data includes update variables shared by neighboring participants.

[0006] Optionally, the update variable is calculated for each outgoing edge based on the node data and outgoing edge data, including: expanding and arranging each node element using a random expansion permutation protocol so that the number of node elements is equal to the number of outgoing edge elements in the outgoing edge data, and the positions of each node element and outgoing edge element correspond; and calculating the update variable element by element for each node element and outgoing edge element.

[0007] Optionally, updating node data based on incoming edge data includes: rearranging incoming edge elements in the incoming edge data using a random expansion permutation protocol, such that incoming edge elements with the same target node are placed in adjacent positions, wherein the incoming edge elements are update variables secretly shared by neighboring participants; aggregating incoming edge elements with the same target node in the incoming edge data using a random grouping aggregation protocol; expanding and permuting the incoming edge elements in the incoming edge data using a random expansion permutation protocol, extracting the aggregation result, such that the number of incoming edge elements is equal to the number of node elements, and the position of the update variable corresponds to the position of the target node; and calculating the updated node data element by element for both the incoming edge elements and the node elements.

[0008] Optionally, the blind expansion permutation protocol includes: obtaining the input vector of the secret shared state and the expansion permutation relationship of the vector elements, wherein the expansion permutation relationship is provided by any of the multiple participants and is used to control the mapping of each vector element in the output vector to the vector elements in the input vector; expanding and permuting the input vector based on the expansion permutation relationship to obtain the output vector of the secret shared state.

[0009] Optionally, the random grouping aggregation protocol includes: obtaining the input vector of the secret shared state, the grouping information of the vector elements, and the aggregation operation, wherein the grouping signal includes a group corresponding to each vector element, vector elements of the same group are placed in a continuous sub-vector of the vector, the input vector is divided into at least one segment, and each segment corresponds to a group; the aggregation operation and the grouping information are used to aggregate the vector elements within each group of the input vector, and the aggregation result is placed in the first vector element of the corresponding group to obtain the output vector of the secret shared state.

[0010] Optionally, after secretly sharing the node data and outgoing edge data of each participant with the neighboring participants, the method further includes: before the start of each round of iterative execution of the graph algorithm, converting the two-party addition secret shared data into three-party redundant addition secret shared data; and after the end of each round of iterative execution of the graph algorithm, converting the three-party redundant addition secret shared data into two-party addition secret shared data.

[0011] The second aspect of this application provides a multi-party collaborative graph computing device with theoretically optimal computational and communication complexity, comprising: a first acquisition module for acquiring graph data of each participant, wherein the graph data of each participant includes node data and edge data, the node data including multiple node elements, and the edge data including outgoing edge data and incoming edge data; a second acquisition module for acquiring the target iteration round of the graph algorithm, wherein the target iteration round of the graph algorithm is determined through negotiation among multiple participants, and the graph algorithm is performed with nodes as the center; and a calculation module for iteratively executing the graph algorithm within the target iteration round, secretly sharing the node data and outgoing edge data of each participant with neighboring participants, wherein during the iterative execution of the graph algorithm in each round, for each participant, update variables are calculated on each outgoing edge based on the node data and outgoing edge data, and node data is updated based on incoming edge data, wherein the incoming edge data includes update variables shared by neighboring participants.

[0012] Optionally, the calculation module is further used to expand and arrange each node element using a random expansion permutation protocol, so that the number of node elements is equal to the number of outgoing edge elements in the outgoing edge data, and the positions of each node element and outgoing edge element correspond; and to calculate the update variable element by element for each node element and outgoing edge element.

[0013] Optionally, the calculation module is further configured to rearrange the incoming edge elements in the incoming edge data using a random expansion permutation protocol, so that incoming edge elements with the same target node are placed in adjacent positions, wherein the incoming edge elements are update variables secretly shared by the neighboring participants; aggregate the incoming edge elements with the same target node in the incoming edge data using a random grouping aggregation protocol; expand and permutate the incoming edge elements in the incoming edge data using a random expansion permutation protocol, extract the aggregation result, so that the number of incoming edge elements is equal to the number of node elements, and the position of the update variable corresponds to the position of the target node; and perform element-wise calculations on the incoming edge elements and node elements to obtain the updated node data.

[0014] Optionally, the blind expansion permutation protocol includes: obtaining the input vector of the secret shared state and the expansion permutation relationship of the vector elements, wherein the expansion permutation relationship is provided by any of the multiple participants and is used to control the mapping of each vector element in the output vector to the vector elements in the input vector; expanding and permuting the input vector based on the expansion permutation relationship to obtain the output vector of the secret shared state.

[0015] Optionally, the random grouping aggregation protocol includes: obtaining the input vector of the secret shared state, the grouping information of the vector elements, and the aggregation operation, wherein the grouping signal includes a group corresponding to each vector element, vector elements of the same group are placed in a continuous sub-vector of the vector, the input vector is divided into at least one segment, and each segment corresponds to a group; the aggregation operation and the grouping information are used to aggregate the vector elements within each group of the input vector, and the aggregation result is placed in the first vector element of the corresponding group to obtain the output vector of the secret shared state.

[0016] Optionally, the multi-party collaborative graph computing device with theoretically optimal computational and communication complexity further includes: a conversion module, used to convert the two-party additive secret shared data into three-party redundant additive secret shared data before each round of graph algorithm execution begins, after each round of graph algorithm execution ends; and to convert the three-party redundant additive secret shared data into two-party additive secret shared data.

[0017] A third aspect of this application provides an electronic device, including: a memory, a processor, and a computer program stored in the memory and executable on the processor. The processor executes the program to implement the multi-party collaborative graph computation method with theoretically optimal computational and communication complexity as described in the above embodiments.

[0018] A fourth aspect of this application provides a computer-readable storage medium having a computer program stored thereon, which is executed by a processor to implement a multi-party collaborative graph computation method with theoretically optimal computational and communication complexity as described in the above embodiments.

[0019] The fifth aspect of this application provides a computer program that, when executed, is used to implement the multi-party collaborative graph computation method with theoretically optimal computational and communication complexity as described in the above embodiments.

[0020] Therefore, this application has the following beneficial effects:

[0021] This application embodiment achieves efficient and privacy-preserving data analysis by secretly sharing the node data and outgoing edge data of each participant with neighboring participants, and calculating and updating variables based on the node data and outgoing edge data and updating node data using incoming edge data in each iteration round. It achieves theoretically optimal asymptotic complexity and can significantly reduce the computational overhead of each participant and the transmission overhead across participants when processing large-scale graph data, thereby reducing the overall multi-party collaborative graph computation time and greatly increasing the scale of graph data that can be processed by multi-party collaborative graph computation.

[0022] Additional aspects and advantages of this application will be set forth in part in the description which follows, and in part will be obvious from the description, or may be learned by practice of this application. Attached Figure Description

[0023] The above and / or additional aspects and advantages of this application will become apparent and readily understood from the following description of the embodiments taken in conjunction with the accompanying drawings, wherein:

[0024] Figure 1 This is a flowchart illustrating a multi-party collaboration graph computation method with theoretically optimal computational and communication complexity, according to an embodiment of this application.

[0025] Figure 2 This is a schematic diagram of a blind expansion permutation protocol according to an embodiment of this application;

[0026] Figure 3 This is a schematic diagram of a randomized grouping aggregation protocol according to an embodiment of this application;

[0027] Figure 4 This is a schematic diagram of a secret sharing conversion mechanism provided according to an embodiment of this application;

[0028] Figure 5 This is an example diagram of a multi-party collaborative graph computing device with theoretically optimal computational and communication complexity according to an embodiment of this application;

[0029] Figure 6 This is a schematic diagram of the structure of an electronic device according to an embodiment of this application. Detailed Implementation

[0030] The embodiments of this application are described in detail below. Examples of the embodiments are shown in the accompanying drawings, wherein the same or similar reference numerals denote the same or similar elements or elements having the same or similar functions throughout. The embodiments described below with reference to the accompanying drawings are exemplary and intended to explain this application, and should not be construed as limiting this application.

[0031] The following description, with reference to the accompanying drawings, describes a method, apparatus, electronic device, storage medium, and program product for multi-party collaborative graph computation with theoretically optimal computational and communication complexity according to embodiments of this application. Addressing the problems mentioned in the background art, this application provides a method for multi-party collaborative graph computation with theoretically optimal computational and communication complexity. In this method, by secretly sharing the node data and outgoing edge data of each participant with neighboring participants, and calculating and updating variables based on the node data and outgoing edge data in each iteration round, and updating node data using incoming edge data, efficient and privacy-preserving data analysis is achieved, reaching theoretically optimal asymptotic complexity. When processing large-scale graph data, it can significantly reduce the computational overhead of each participant and the transmission overhead across participants, thereby reducing the overall multi-party collaborative graph computation time and greatly increasing the scale of graph data that multi-party collaborative graph computation can handle.

[0032] Specifically, Figure 1 This is a flowchart illustrating a multi-party collaboration graph computation method with theoretically optimal computational and communication complexity, provided in an embodiment of this application.

[0033] like Figure 1 As shown, the multi-party collaboration graph computation method with theoretically optimal computational and communication complexity includes the following steps:

[0034] In step S101, the graph data of each participant is obtained. The graph data of each participant includes node data and edge data. The node data includes multiple node elements, and the edge data includes outgoing edge data and incoming edge data.

[0035] It is understood that graph data consists of several vertex nodes and edge data between them, with the edge data reflecting the relationships between nodes. In this embodiment, the vertex node data includes multiple vertex nodes, and the edge data includes outgoing edge data and incoming edge data. A vertex node corresponds to a node in the graph data, such as an account in a bank transfer graph; an outgoing edge is an outgoing edge of a vertex node, such as a transfer initiated from one bank account to another; and an incoming edge is an incoming edge of a vertex node, such as a transfer received by one bank account from another bank account.

[0036] For example, a graph can be formally represented as a tuple (V, E), where V is a list of nodes and E is a list of edges. Each element in V represents a node (e.g., an account in a bank transfer graph), denoted as the tuple v = (v.id, v.data), where v.id represents the unique identifier of the node (ID, e.g., the account number of a bank account), and v.data represents the data of the node (e.g., the balance of the bank account). Each element in E represents a directed edge (e.g., a transfer in a bank transfer graph), denoted as the triple e = (e.src, e.dst, e.data), where e.src represents the ID of the source node of the edge (e.g., the account number of the sender corresponding to the transfer), e.dst represents the ID of the destination node of the edge (e.g., the account number of the recipient corresponding to the transfer), and e.data represents the data stored on the edge (e.g., the amount of the transfer, the time). A directed edge e = (e.src, e.dst, e.data) is called the outgoing edge of node e.src and the incoming edge of node e.dst.

[0037] In step S102, the target iteration round of the graph algorithm is obtained. The target iteration round of the graph algorithm is determined by multiple participants through negotiation. The graph algorithm performs operations with nodes as the center.

[0038] In this embodiment, a graph algorithm is an algorithm that takes graph data as input and outputs updated graph data or specific information extracted from the graph data. Traditional graph algorithms include breadth-first search, shortest path algorithm, PageRank, network flow algorithm, and graph pattern mining algorithm. Graph neural networks, which have become increasingly popular in recent years, can also be classified as emerging graph algorithms. In distributed graph computing, to improve the parallelism of graph algorithm execution, various graph algorithms are often abstracted into node-centric operations. Within this abstraction, the execution process of a graph algorithm is broken down into several rounds of algorithm iterations. Before iteratively executing the graph algorithm, multiple participants negotiate and determine the details of the graph algorithm, identify the target number of iterations, and perform operations centered on nodes, including Scatter and Gather operations.

[0039] In step S103, the graph algorithm is iteratively executed within the target iteration round, and the node data and outgoing edge data of each participant are secretly shared with the neighboring participants. In each iteration of the graph algorithm, for each participant, the update variable on each outgoing edge is calculated based on the node data and outgoing edge data, and the node data is updated based on the incoming edge data, which includes the update variable shared by the neighboring participants.

[0040] It is understandable that, during each iteration of the graph algorithm, in this embodiment, each participant transmits the data of each node to its neighbors through outgoing edges. Subsequently, each node collects the data transmitted by its neighbors through incoming edges to update its own internal data. The execution process of the graph algorithm is broken down into several iterations, each containing the following two stages:

[0041] Scatter operation: Send the data v.data of each node to each of its outgoing edges e, and obtain an update variable u on each outgoing edge through the operation of node data and outgoing edge data;

[0042] The Gather operation: Each node collects the update variables u generated on each of its incoming edges e, concatenates them with the node data, and updates the data v.data of each node based on this.

[0043] It's important to note that conceptually, the updated variable `u` is the same in the Scatter and Gather phases. However, in practice, they represent the results of operations in different directions (outgoing or incoming edges): In the Scatter operation, `u` is calculated and sent out by the current node; in the Gather operation, `u` is calculated by neighboring nodes and passed in via incoming edges. For a specific node, the `u` it generates in the Scatter phase will become the `u` received by its neighboring nodes in the Gather phase.

[0044] In one embodiment of this application, the calculation of update variables on each outgoing edge based on node data and outgoing edge data includes: expanding and arranging each node element using a random expansion permutation protocol so that the number of node elements is equal to the number of outgoing edge elements in the outgoing edge data, and the positions of each node element and outgoing edge element correspond; and calculating update variables element by element for each node element and outgoing edge element.

[0045] For ease of understanding, the embodiments of this application can be implemented by combining a specific example to perform the Scatter operation in the above embodiments. Assume there are N participants, where P i i∈[N] provides its node data V i and all associated edge data E i,j E j,i j∈[N] (including internal edges and edges across participants), and the details of the graph algorithm determined through negotiation among multiple participants, including the calculation of the maximum Iter iteration with the node as the center and the Scatter calculation. Gather calculation

[0046] In this embodiment of the application, the input of ScatterTask is <V i >, <E i,*>, Corresponding to P i The nodes, outgoing edges, and Scatter operators The output of ScatterTask is i,* > refers to the updated variable generated on each outgoing edge. The ScatterTask execution steps are:

[0047] (1)(P i ,P i+1(modN) Using the Blind Extended Permutation Protocol (OEP), for <V i Perform an extended permutation to make its sum of elements equal to the sum of the elements in the permutation. <E i,* > They are equal, and at the same time, the position of each node element corresponds to the position of its outgoing edge, resulting in

[0048] (2)(P i ,P i+1(modN) )use right and <E i,* Perform element-by-element calculations to obtain i,* >

[0049] The blind expansion permutation protocol includes: obtaining the input vector of the secret shared state and the expansion permutation relationship of the vector elements, wherein the expansion permutation relationship is provided by any of the multiple participants and is used to control the mapping of each vector element in the output vector to the vector elements in the input vector; and expanding and permuting the input vector based on the expansion permutation relationship to obtain the output vector of the secret shared state.

[0050] It is understandable that, such as Figure 2 As shown, the goal of the blindly expanding permutation protocol is to expand and permutate a vector of a secret shared state. Expanding and permuting means reordering the elements of the vector. This process may involve deleting some elements or repeating some elements multiple times (in other words, expanding and permuting can be seen as a generalization of full permutations). The input to the expanding and permutation protocol consists of two parts: the vector of the secret shared state and an expanding and permutation relation (provided by one of the multiple protocol participants, used to control which element in the input vector each element in the output vector corresponds to). The output of the expanding and permutation protocol is a secretly shared permuted vector.

[0051] ​​In one embodiment of this application, updating node data based on update variables on each incoming edge generated from the incoming edge data includes: rearranging the incoming edge elements in the incoming edge data using a random expansion permutation protocol, such that incoming edge elements with the same target node are placed in adjacent positions, wherein the incoming edge elements are update variables shared by neighboring participants; aggregating the incoming edge elements with the same target node in the incoming edge data using a random grouping aggregation protocol; expanding and permuting the incoming edge elements in the incoming edge data using a random expansion permutation protocol, extracting the aggregation result, such that the number of incoming edge elements is equal to the number of node elements, and the position of the update variable corresponds to the position of the target node; and calculating the updated node data element by element by element using the incoming edge elements and node elements.

[0052] Based on the above embodiments, the input to GatherTask is <V i >, *,i >, Corresponding to P i The nodes, incoming edges, and the Gather operator. The output of GatherTask is <V i ′>, which refers to the updated node data.

[0053] The execution steps of GatherTask are as follows:

[0054] (1)(P i ,P i+1(modN) Using the blind expansion permutation protocol, for *,i Perform a rearrangement so that update variables with the same target node are placed as... *,i Adjacent positions in >;

[0055] (2)(P i ,P i+1(modN) Using the random grouping aggregation protocol, for *,i Aggregate update variables that are the same as the target node;

[0056] (3)(P i ,P i+1(modN) Using the blind expansion permutation protocol, for *,i Perform an expanded permutation, extract the aggregated result, and sum its element count. <V i If the values ​​are equal, update the position of the variable to correspond to the position of the target node, and obtain...

[0057] (4)(P i ,P i+1(modN) )use For <V o > and Perform element-by-element calculations to obtain <V​​​​​o ′>.

[0058] The random grouping and aggregation protocol includes: obtaining the input vector of the secret shared state, the grouping information of the vector elements, and the aggregation operation. The grouping signal includes each vector element corresponding to a group, and vector elements in the same group are placed in a continuous sub-vector of the vector. The input vector is divided into at least one segment, and each segment corresponds to a group. The aggregation operation and the grouping information are used to aggregate the vector elements in each group of the input vector, and the aggregation result is placed in the first vector element of the corresponding group to obtain the output vector of the secret shared state.

[0059] Specifically, the goal of the blind grouping aggregation protocol is to group and aggregate a vector of secret shared states, such as... Figure 3 As shown, the input to the protocol consists of three parts: first, a vector of the secret-shared state; second, a vector element grouping information (recording which group each vector element belongs to; note that elements in the same group are placed in a continuous subvector of the vector, meaning the secret-shared input vector can be divided into several segments, each corresponding to a group); and third, an aggregation operation. (Satisfies the commutative and associative laws). During protocol execution, the following is used: Aggregate the elements within each group and place the aggregated result in the first element of that group. The protocol outputs a vector of secret shared state, where the first element of each group stores the aggregated result for that group.

[0060] In summary, each iteration of the algorithm within maxIter in this application embodiment includes the following steps:

[0061] (a) For all i∈[N], in (P) i ,P i+1(mod N) ) between get i,* >, corresponding to in <V i > The update variable generated on each outgoing edge;

[0062] (b) Depending on the target node, i,* >Decompose to obtain i,0 >, i,1 >,…, i,N-1 >, which points to the local graph of each participant;

[0063] (c) Each participant performs a secret shared redistribution of updated variables, so that... 0,i >, 1,i >,…, N-1,i >In (P)​​​​​​​​i ,P i+1(modN) Secretly shared between them;

[0064] (d)(P i ,P i+1(modN) )right 1,i >,…, N-1,i > By splicing, we get *,i >;

[0065] (e) For all i∈[N], in (P) i ,P i+1(modN) ) between Get the updated node data <V i >

[0066] (f) will <V i Assigned to <V i >, and proceed to the next iteration.

[0067] In the execution flow of this application, for each round of node-centric computation iteration, the graph data processed by different ScatterTasks do not overlap, and the graph data processed by different GatherTasks do not overlap. Since the computation and transmission costs of each ScatterTask and GatherTask are linear in complexity, and the computation and transmission costs of (c) secret sharing redistribution are also linear in complexity, the complexity of executing a single round of node-centric computation iteration is O(|V|+|E|), where |V| is the sum of the number of vertices in the graphs of all participants, and |E| is the sum of the number of edges in the graphs of all participants.

[0068] It should be noted that the complexity in this embodiment is independent of the number of participants and is linear with the number of nodes and edges, which is theoretically optimal.

[0069] In one embodiment of this application, after secretly sharing the node data and outgoing edge data of each participant with the neighboring participants, the method further includes: before the start of each round of iterative execution of the graph algorithm, converting the two-party addition secret shared data into three-party redundant addition secret shared data; and after the end of each round of iterative execution of the graph algorithm, converting the three-party redundant addition secret shared data into two-party addition secret shared data.

[0070] ​​​Understandably, to further optimize computational and communication overhead, this application introduces a secret sharing conversion mechanism. By employing different secret sharing schemes at different stages of framework execution (e.g., converting from two-party additive secret sharing to three-party redundant additive secret sharing), the efficiency of the specific protocol is improved without compromising privacy protection attributes. Therefore, in the application embodiment, the initial stage graph data secret sharing and secret sharing redistribution are based on two-party additive secret sharing, while the execution of ScatterTask and GatherTask is based on three-party redundant additive secret sharing. The two states are interconnected through secret sharing conversion, as shown in Figure 4.

[0071] The two sides share a secret in the addition process: the process splits an integer x into two random numbers of the form x ≡ < x > 0 + <x>1 mod L, where x, <x>0 and <x>1 are all rings integers above, <x>0 in Uniform random distribution <x>0 and <x>1 is distributed to two participants. Only by combining the secret shared fragments of the two participants can x be recovered; otherwise, no information about x can be obtained. In the following text, ... <x>Denotes x as the secret shared by both parties in addition;

[0072] Three-way redundant addition secret sharing: This process splits an integer x into three random numbers, in the form of... and exist Uniform random distribution The fragments were distributed among the three participants, meaning each participant received two of the three shared secret fragments. Under this setup, every two participants could reconstruct x. (The text below will refer to x as...) Let x represent the state of secret sharing among the three parties.

[0073] Specifically, in the preceding process description, both ScatterTask and GatherTask are involved in two parties (P) i ,P i+1(modN) The execution between ScatterTask and GatherTask relies on a two-party secure computation protocol. Since a secure multi-party computation protocol based on three-party redundant addition secret sharing has higher multiplication execution efficiency (i.e., lower computation and transmission overhead) compared to a two-party addition secret sharing protocol, this proposal suggests transforming the two-party addition secret sharing data into a three-party redundant addition secret sharing at the beginning of ScatterTask and GatherTask execution, ensuring the data is executed between (P...) i ,P i+1(modN) ,P i+2(modN) The three parties secretly share data, enabling the execution of ScatterTask and GatherTask based on an efficient three-party secure computation protocol. At the end of ScatterTask and GatherTask, the three-party redundant additive secret sharing is transformed into a two-party additive secret sharing, ensuring secure redistribution of secret sharing execution. Therefore, in the above embodiment, the updated node data of each party is generated through the execution graph algorithm, where P... i Node data V i In the participation of party P i and P i+1 The two parties secretly shared the information, denoted as <V i ′>.

[0074] In summary, this application proposes the first multi-party collaborative graph computation method with theoretically optimal computational and communication complexity. This method supports multiple graph data owners to jointly analyze graph data while ensuring that no participating party can access the original graph data of other participating parties, thus ensuring the privacy protection of graph data. In this method, the execution process of the graph algorithm is abstracted into several rounds of algorithm iteration centered on nodes. Through the design of a distributed computing architecture, the framework achieves an asymptotic complexity of O(|V|+|E|) for the computation and transmission overhead (i.e., the sum of the computation and transmission overhead of all participating parties) for each round of algorithm iteration, where |V| is the sum of the number of nodes (vertices) in the graph of all participating parties, and |E| is the sum of the number of edges (edges) in the graph of all participating parties. This asymptotic complexity is theoretically optimal because in a single graph algorithm iteration, each node and each edge in the graph is visited at least once; therefore, linear complexity is already the theoretically optimal complexity.

[0075] Secondly, this application further introduces a secret sharing conversion mechanism. By adopting different secret sharing schemes at different stages of execution, data privacy is guaranteed. Large-scale graph data analysis can be carried out jointly without disclosing sensitive information, which greatly improves processing efficiency and cooperation flexibility.

[0076] The multi-party collaborative graph computation method proposed in this application, which has theoretically optimal computational and communication complexity, achieves efficient and privacy-preserving data analysis by secretly sharing the node data and outgoing edge data of each participant with neighboring participants. In each iteration, it calculates and updates variables based on the node data and outgoing edge data and updates node data using incoming edge data. It achieves theoretically optimal asymptotic complexity and can significantly reduce the computational overhead of each participant and the transmission overhead across participants when processing large-scale graph data. This reduces the overall multi-party collaborative graph computation time and greatly increases the scale of graph data that can be processed by multi-party collaborative graph computation. It is applicable to many fields such as anti-financial fraud and knowledge graph analysis.

[0077] Next, referring to the accompanying drawings, a multi-party collaborative graph computing device with theoretically optimal computational and communication complexity, according to an embodiment of this application, is described.

[0078] Figure 5 This is a block diagram of a multi-party collaborative graph computing device with theoretically optimal computational and communication complexity, according to an embodiment of this application.

[0079] like Figure 5 As shown, the multi-party collaborative graph computing device 10 with theoretically optimal computational and communication complexity includes: a first acquisition module 100, a second acquisition module 200, and a computing module 300.

[0080] The first acquisition module 100 is used to acquire graph data of each participant. The graph data of each participant includes node data and edge data. The node data includes multiple node elements, and the edge data includes outgoing edge data and incoming edge data. The second acquisition module 200 is used to acquire the target iteration round of the graph algorithm. The target iteration round of the graph algorithm is determined by multiple participants through negotiation. The graph algorithm is performed with nodes as the center. The calculation module 300 is used to iteratively execute the graph algorithm within the target iteration round. The node data and outgoing edge data of each participant are secretly shared with neighboring participants. During the iterative execution of the graph algorithm in each round, for each participant, the update variable on each outgoing edge is calculated based on the node data and outgoing edge data, and the node data is updated based on the incoming edge data. The incoming edge data includes the update variable shared by neighboring participants.

[0081] In one embodiment of this application, the calculation module 300 is further configured to expand and arrange each node element using a random expansion permutation protocol, so that the number of node elements is equal to the number of outgoing edge elements in the outgoing edge data, and the positions of each node element and outgoing edge element correspond; and to perform element-by-element calculation on the node elements and outgoing edge elements to obtain the update variable.

[0082] In one embodiment of this application, the calculation module 300 is further configured to rearrange the incoming edge elements in the incoming edge data using a random expansion permutation protocol, so that incoming edge elements with the same target node are placed in adjacent positions, wherein the incoming edge elements are update variables shared by neighboring participants; aggregate the incoming edge elements with the same target node in the incoming edge data using a random grouping aggregation protocol; expand and permutate the incoming edge elements in the incoming edge data using a random expansion permutation protocol, extract the aggregation result, so that the number of incoming edge elements is equal to the number of node elements, and the position of the update variable corresponds to the position of the target node; and perform element-by-element calculation on the incoming edge elements and node elements to obtain the updated node data.

[0083] In one embodiment of this application, the random extended permutation protocol includes: obtaining the input vector of the secret shared state and the extended permutation relationship of the vector elements, wherein the extended permutation relationship is provided by any of the multiple participants and is used to control the mapping of each vector element in the output vector to the vector elements in the input vector; and extending the input vector based on the extended permutation relationship to obtain the output vector of the secret shared state.

[0084] In one embodiment of this application, the random grouping aggregation protocol includes: obtaining the input vector of the secret shared state, grouping information of the vector elements, and aggregation operation, wherein the grouping signal includes a group corresponding to each vector element, vector elements of the same group are placed in a continuous sub-vector of the vector, the input vector is divided into at least one segment, and each segment corresponds to a group; the aggregation operation and grouping information are used to aggregate the vector elements within each group of the input vector, and the aggregation result is placed in the first vector element of the corresponding group to obtain the output vector of the secret shared state.

[0085] In one embodiment of this application, the multi-party collaborative graph computing device 10 with theoretically optimal computational and communication complexity further includes: a conversion module, used to convert the two-party addition secret shared data into three-party redundant addition secret shared data before the start of each round of iterative execution of the graph algorithm after secretly sharing the node data and outgoing edge data of each participant with the neighboring participants; and to convert the three-party redundant addition secret shared data into two-party addition secret shared data after the end of each round of iterative execution of the graph algorithm.

[0086] It should be noted that the foregoing explanation of the embodiment of the multi-party collaborative graph calculation method with theoretically optimal computational and communication complexity also applies to the multi-party collaborative graph calculation device with theoretically optimal computational and communication complexity in this embodiment, and will not be repeated here.

[0087] The multi-party collaborative graph computing device proposed in this application, which possesses theoretically optimal computational and communication complexity, achieves efficient and privacy-preserving data analysis by secretly sharing the node data and outgoing edge data of each participant with neighboring participants. In each iteration round, it calculates and updates variables based on the node data and outgoing edge data and updates node data using incoming edge data. This achieves theoretically optimal asymptotic complexity and can significantly reduce the computational overhead of each participant and the transmission overhead across participants when processing large-scale graph data. This reduces the overall multi-party collaborative graph computing time and greatly increases the scale of graph data that can be processed by multi-party collaborative graph computing. It is applicable to many fields such as anti-financial fraud and knowledge graph analysis.

[0088] Figure 6 A schematic diagram of the structure of an electronic device provided in an embodiment of this application. The electronic device may include:

[0089] The memory 601, the processor 602, and the computer program stored on the memory 601 and capable of running on the processor 602.

[0090] When the processor 602 executes the program, it implements the multi-party collaborative graph calculation method with theoretically optimal computational and communication complexity provided in the above embodiments.

[0091] Furthermore, electronic devices also include:

[0092] Communication interface 603 is used for communication between memory 601 and processor 602.

[0093] The memory 601 is used to store computer programs that can run on the processor 602.

[0094] The memory 601 may include high-speed RAM (Random Access Memory) memory, and may also include non-volatile memory, such as at least one disk storage.

[0095] If the memory 601, processor 602, and communication interface 603 are implemented independently, then the communication interface 603, memory 601, and processor 602 can be interconnected via a bus to complete communication between them. The bus can be an ISA (Industry Standard Architecture) bus, a PCI (Peripheral Component Interconnect) bus, or an EISA (Extended Industry Standard Architecture) bus, etc. The bus can be divided into address bus, data bus, control bus, etc. For ease of representation, Figure 6 The bus is represented by a single thick line, but this does not mean that there is only one bus or one type of bus.

[0096] Optionally, in a specific implementation, if the memory 601, processor 602, and communication interface 603 are integrated on a single chip, then the memory 601, processor 602, and communication interface 603 can communicate with each other through an internal interface.

[0097] The processor 602 may be a CPU (Central Processing Unit), an ASIC (Application Specific Integrated Circuit), or one or more integrated circuits configured to implement the embodiments of this application.

[0098] This application also provides a computer-readable storage medium storing a computer program that, when executed by a processor, implements the above-described multi-party collaborative graph computation method with theoretically optimal computational and communication complexity.

[0099] This application also provides a computer program, which, when executed, is used to implement the multi-party collaborative graph computation method with theoretically optimal computational and communication complexity as described in the above embodiments.

[0100] In the description of this specification, the references to "one embodiment," "some embodiments," "example," "specific example," or "some examples," etc., indicate that a specific feature, structure, material, or characteristic described in connection with that embodiment or example is included in at least one embodiment or example of this application. In this specification, the illustrative expressions of the above terms do not necessarily refer to the same embodiment or example. Furthermore, the specific features, structures, materials, or characteristics described may be combined in any suitable manner in one or more embodiments or examples. Moreover, without contradiction, those skilled in the art can combine and integrate the different embodiments or examples described in this specification, as well as the features of different embodiments or examples.

[0101] Furthermore, the terms "first" and "second" are used for descriptive purposes only and should not be construed as indicating or implying relative importance or implicitly specifying the number of technical features indicated. Thus, a feature defined as "first" or "second" may explicitly or implicitly include at least one of that feature. In the description of this application, "N" means at least two, such as two, three, etc., unless otherwise explicitly specified.

[0102] Any process or method described in the flowchart or otherwise herein can be understood as representing a module, segment, or portion of code comprising one or N executable instructions for implementing custom logic functions or processes, and the scope of the preferred embodiments of this application includes additional implementations in which functions may be performed not in the order shown or discussed, including substantially simultaneously or in reverse order depending on the functions involved, as should be understood by those skilled in the art to which embodiments of this application pertain.

[0103] It should be understood that various parts of this application can be implemented using hardware, software, firmware, or a combination thereof. In the above embodiments, steps or methods can be implemented using software or firmware stored in memory and executed by a suitable instruction execution system. For example, if implemented in hardware, as in another embodiment, it can be implemented using any of the following techniques known in the art, or a combination thereof: discrete logic circuits having logic gates for implementing logical functions on data signals, application-specific integrated circuits (ASICs) having suitable combinational logic gates, programmable gate arrays (FPGAs), field-programmable gate arrays (FPGAs), etc.

[0104] Those skilled in the art will understand that all or part of the steps of the methods implementing the above embodiments can be implemented by a program instructing related hardware. The program can be stored in a computer-readable storage medium, and when executed, the program includes one or a combination of the steps of the method embodiments.

[0105] Although embodiments of this application have been shown and described above, it is understood that the above embodiments are exemplary and should not be construed as limiting this application. Those skilled in the art can make changes, modifications, substitutions and variations to the above embodiments within the scope of this application.< / x> < / x> < / x> < / x> < / x> < / x> < / x>

Claims

1. A method for calculating multi-party collaborative graphs with theoretically optimal computational and communication complexity, characterized in that, Includes the following steps: Obtain graph data for each participant, wherein the graph data for each participant includes node data and edge data, wherein the node data includes multiple node elements, and the edge data includes outgoing edge data and incoming edge data; The target iteration round of the graph algorithm is obtained, wherein the multiple participating parties determine the target iteration round of the graph algorithm through negotiation, and the graph algorithm performs operations with nodes as the center; The graph algorithm is executed iteratively within the target iteration round, and the node data and outgoing edge data of each participant are secretly shared with the neighboring participants. During the execution of the graph algorithm in each iteration round, for each participant, update variables are calculated on each outgoing edge based on the node data and outgoing edge data, and the node data is updated based on the incoming edge data, which includes update variables shared by the neighboring participants.

2. The multi-party cooperation graph calculation method with theoretically optimal computational and communication complexity as described in claim 1, characterized in that, The step of calculating the update variable on each outgoing edge based on the node data and the outgoing edge data includes: The random expansion permutation protocol is used to expand and permutate each node element so that the number of node elements is equal to the number of outgoing edge elements in the outgoing edge data, and the position of each node element corresponds to that of the outgoing edge element. The update variable is obtained by calculating each element of the node element and the outgoing edge element.

3. The multi-party collaboration graph calculation method with theoretically optimal computational and communication complexity as described in claim 1, characterized in that, The step of updating the node data based on the incoming edge data includes: The incoming edge elements in the incoming edge data are rearranged using the random expansion permutation protocol, so that incoming edge elements with the same target node are placed in adjacent positions. The incoming edge elements are update variables secretly shared by the neighbor participants. The random grouping aggregation protocol is used to aggregate incoming edge elements with the same target node in the incoming edge data; The random expansion permutation protocol is used to expand and permutate the incoming edge elements in the incoming edge data, and the aggregation result is extracted so that the number of incoming edge elements is equal to the number of node elements, and the position of the updated variable corresponds to the position of the target node. The updated node data is obtained by performing element-by-element calculations on the incoming edge elements and the node elements.

4. The multi-party collaboration graph calculation method with theoretically optimal computational and communication complexity according to claim 2 or 3, characterized in that, The blind expansion permutation protocol includes: Obtain the input vector and extended permutation relationship of the vector elements of the secret shared state, wherein the extended permutation relationship is provided by any of the multiple participants and is used to control the mapping of each vector element in the output vector to the vector elements in the input vector; The input vector is expanded and permuted based on the expanded permutation relationship to obtain the output vector of the secret shared state.

5. The multi-party collaboration graph calculation method with theoretically optimal computational and communication complexity according to claim 3, characterized in that, The blind grouping aggregation protocol includes: The input vector for obtaining the secret shared state, the grouping information of the vector elements, and the aggregation operation are described. The grouping signal includes a group corresponding to each vector element. Vector elements in the same group are placed in a continuous sub-vector of the vector. The input vector is divided into at least one segment, and each segment corresponds to a group. The aggregation operation and the grouping information are used to aggregate the vector elements within each group of the input vector, and the aggregation result is placed in the first vector element of the corresponding group to obtain the output vector of the secret shared state.

6. The multi-party cooperation graph calculation method with theoretically optimal computational and communication complexity according to claim 1, characterized in that, After secretly sharing the node data and outgoing edge data of each participant with the neighboring participants, the process also includes: Before each iteration of the graph algorithm begins, the two-party addition secret shared data is transformed into three-party redundant addition secret shared data; After each iteration of the graph algorithm, the three-way redundant addition secret shared data is transformed into two-way addition secret shared data.

7. A multi-party collaborative graph computing device with theoretically optimal computational and communication complexity, characterized in that, include: The first acquisition module is used to acquire graph data for each participant. The graph data for each participant includes node data and edge data. The node data includes multiple node elements, and the edge data includes outgoing edge data and incoming edge data. The second acquisition module is used to acquire the target iteration round of the graph algorithm, wherein the multiple participating parties determine the target iteration round of the graph algorithm through negotiation, and the graph algorithm performs operations with nodes as the center; The calculation module is used to iteratively execute the graph algorithm within the target iteration round, and secretly share the node data and outgoing edge data of each participant with the neighboring participants. In each iteration of the graph algorithm, for each participant, update variables are calculated on each outgoing edge based on the node data and outgoing edge data, and the node data is updated based on the incoming edge data, which includes update variables shared by the neighboring participants.

8. An electronic device, characterized in that, include: A memory, a processor, and a computer program stored in the memory and executable on the processor, the processor executing the program to implement the multi-party collaborative graph computation method with theoretically optimal computational and communication complexity as described in any one of claims 1-6.

9. A computer-readable storage medium having a computer program or instructions stored thereon, characterized in that, When the computer program or instructions are executed, they implement the multi-party collaborative graph computation method with theoretically optimal computational and communication complexity as described in any one of claims 1-6.

10. A computer program product, comprising a computer program or instructions, characterized in that, When the computer program or instructions are executed, they implement the multi-party collaborative graph computation method with theoretically optimal computational and communication complexity as described in any one of claims 1-6.

Images