Cross-language federated knowledge graph embedding method for privacy protection

Abstract

The invention discloses a cross-language federated knowledge graph embedding method for privacy protection, which belongs to the field of federated knowledge graph embedding and cryptography and comprises an initialization stage, a local training stage, an intra-group knowledge sharing stage and an inter-group knowledge alignment stage. The participants mainly comprise a knowledge graph client, a computing server and an assistant, the assistant is responsible for generating a secret key and a random number, the knowledge graph client uses private knowledge graph training locally to obtain a knowledge graph embedded model, an embedded vector of an aligned entity / relationship is selected according to a partial alignment set, and the embedded vector is encrypted and uploaded; and the computing server performs aggregation operation on the embedded vectors of the same entity / relationship and returns the aggregation operation to a corresponding client, the client verifies an aggregation result at a certain probability, and the operation is repeated until a specified number of rounds is reached. According to the method, cross-language federated knowledge graph embedding can be carried out on the premise of privacy protection, and cheating behaviors of the server are defended.

Description

Technical Field

[0001] The present invention belongs to the field of federated knowledge graph embedding and cryptography, and in particular relates to a privacy-preserving cross-language federated knowledge graph embedding method. Background Art

[0002] A knowledge graph is a knowledge base that represents entities and their relationships through triples. Knowledge graph embedding maps entities and relationships in a knowledge graph into a low-dimensional vector space for subsequent computation and reasoning. While knowledge graphs from different institutions may be complementary, their privacy concerns prevent them from sharing private knowledge graphs to optimize their own. Federated learning technology allows all parties to jointly train models without disclosing private data, effectively resolving the "data silo" problem of knowledge graphs. However, it still requires protection of intermediate parameters during training, such as knowledge graph embedding vectors.

[0003] Existing privacy-preserving federated knowledge graph embedding schemes consider same-language knowledge graphs, meaning that all knowledge graphs belong to the same language. Therefore, the complete alignment set of each pair of knowledge graphs can be directly obtained through privacy-preserving intersection techniques. Essentially, alignment is performed through string matching, with entities / relations with the same string being aligned (representing the same entity / relationship in reality). However, for cross-lingual knowledge graphs, the knowledge graphs must first be unified into the same language space. This relies on the accuracy of translation alignment tools, and because each knowledge graph has different naming methods, even aligned entities / relations will not have exactly the same entity names / relationship names after alignment into the same language space (for example, "football" can be translated as "soccer" or "football"). Therefore, it is impossible to obtain the complete alignment set of the knowledge graph, only a partial alignment set. Therefore, considering the scenario of cross-lingual knowledge graphs, how to use partial alignment sets for federated knowledge graph embedding training is a question worth studying. At the same time, existing solutions assume that the server is semi-honest and will strictly abide by the provisions of the protocol. However, in the real world, the server may be rational and deviate from the execution of the protocol to achieve its own goals. For example, returning incorrect aggregation results will affect the client's model performance. Therefore, we need to consider how to resist server cheating. Summary of the Invention

[0004] To solve the above technical problems, the present invention provides a privacy-preserving cross-language federated knowledge graph embedding method, comprising:

[0005] According to the client's agreement and preset security parameters, the knowledge graph embedding model and key are initialized, the deposit is uploaded to the blockchain, and the clients are randomly divided into two groups;

[0006] According to the initialized knowledge graph embedding model, each client locally uses a private knowledge graph to train a local knowledge graph embedding model;

[0007] During the intra-group knowledge sharing phase, based on the intra-group alignment table, each client in each group selects an embedding vector that aligns entities / relationships with other clients in the same group, encrypts it, and uploads it to the server. The server then performs aggregation operations based on the partial alignment set and returns the aggregated results within the group for the same entity / relationship. The client selects a verification client to verify the aggregation results. If the verification passes, the local embedding vector is updated.

[0008] During the inter-group knowledge alignment phase, two client groups collaborate based on the inter-group alignment table. Each client selects an embedding vector that aligns the entity / relationship with the other client group, encrypts it, and uploads it to the server. Aggregation is performed and the aggregated results of the two groups for the same entity / relationship are returned. The collaborator selects a verification client from each client group to verify the aggregated results. If the verification passes, the local embedding vector is updated and alignment training is performed.

[0009] Based on the verification results during the training process, if the client discovers that the server is cheating, it will upload evidence, and the blockchain will deduct its deposit and divide it equally among the clients, while returning the deposit of each client; if the training ends normally, all client deposits will be transferred to the server, and the server's own deposit will be returned.

[0010] Preferably, the process of initializing the knowledge graph embedding model and key according to the client's agreement and preset security parameters, uploading the deposit to the blockchain, and randomly dividing the clients into two groups includes:

[0011] According to the client's prior agreement, each client initializes the knowledge graph embedding model and vector dimensions and uploads the deposit to the blockchain;

[0012] Based on the preset security parameters, the assistant generates a homomorphic encryption public-private key pair, sends the public key to the computing server, and sends the public-private key to each client;

[0013] The computing server randomly divides the clients into two groups and generates intra-group alignment tables and inter-group alignment tables based on the grouping results and partial alignment sets.

[0014] Preferably, the process of each client using a private knowledge graph to train locally to obtain a local knowledge graph embedding model includes: each client uses a private knowledge graph locally to perform knowledge graph embedding training according to the initialized model parameters to obtain a local knowledge graph embedding model, and the scoring function of the local stage training is related to the specific agreed knowledge graph embedding model.

[0015] Preferably, in the intra-group knowledge sharing stage, each client selects an embedding vector of an entity / relationship aligned with another group of clients according to the intra-group alignment table, encrypts the selected alignment vector using a homomorphic encryption public key to obtain an encrypted alignment vector, and uploads the encrypted alignment vector to the computing server.

[0016] Preferably, the client uses the homomorphic encryption private key to decrypt the returned aggregation result to obtain the decrypted aggregation result, and chooses to perform an aggregation result verification operation with a certain probability, and updates the local embedding vector if the verification passes.

[0017] Preferably, in the inter-group knowledge alignment stage, each client selects an embedding vector of an entity / relationship aligned with another group of clients according to the inter-group alignment table, encrypts the selected alignment vector using a homomorphic encryption public key to obtain an encrypted alignment vector, and uploads the encrypted alignment vector to the computing server.

[0018] Preferably, the computing server performs an aggregation operation on the encrypted alignment vectors of the same entity / relationship according to the inter-group alignment table, obtains the aggregation results of the two groups, and returns the aggregation results to the corresponding client.

[0019] Preferably, the client uses the homomorphic encryption private key to decrypt the returned aggregation result to obtain the decrypted aggregation result, and chooses to perform an aggregation result verification operation with a certain probability. If the verification passes, the local embedding vector is updated and alignment training is performed.

[0020] On the other hand, the present invention further provides an electronic device, comprising a memory, a processor, and a computing program stored in the memory and executable on the processor, wherein the method is implemented when the processor executes the computing program.

[0021] On the other hand, the present invention further provides a computer-readable storage medium, wherein the computer-readable storage medium stores a computer program, and the computer program implements the method when executed by a processor.

[0022] Compared with the prior art, the present invention has the following advantages and technical effects:

[0023] 1. This invention introduces homomorphic encryption technology, which ensures the privacy of both the alignment vector and the global embedding vector (i.e., the result of summing the alignment vectors). This is because the server can only obtain the alignment vector in its ciphertext state and operate on the ciphertext. Furthermore, it does not introduce noise that could affect the vector's usability.

[0024] 2. The present invention takes into account the cross-language knowledge graph scenario, divides the participating clients into two groups, and uses partial alignment sets. First, the intra-group vector aggregation sub-protocol is executed separately in groups to carry out intra-group knowledge sharing and optimize the intra-group client embedding vectors. Then, the two client groups collaborate to execute the inter-group knowledge alignment sub-protocol to optimize their respective embedding vectors and discover more potential triples.

[0025] 3. The present invention designs an aggregation result verification protocol. The client can perform a verification operation on the result with a certain probability after each aggregation operation, thereby detecting cheating behavior of the server. BRIEF DESCRIPTION OF THE DRAWINGS

[0026] The accompanying drawings, which constitute part of this application, are intended to provide a further understanding of this application. The exemplary embodiments and descriptions of this application are intended to explain this application and do not constitute an improper limitation on this application. In the accompanying drawings:

[0027] Figure 1 A system model diagram of a cross-language knowledge graph embedding method for implementing privacy protection according to an embodiment of the present invention;

[0028] Figure 2 This is an overall flow chart of the cross-language federated knowledge graph embedding method for implementing privacy protection in an embodiment of the present invention. DETAILED DESCRIPTION

[0029] It should be noted that, in the absence of conflict, the embodiments and features of the embodiments in this application can be combined with each other. The present application will be described in detail below with reference to the accompanying drawings and in combination with the embodiments.

[0030] It should be noted that the steps shown in the flowcharts of the accompanying drawings can be executed in a computer system such as a set of computer-executable instructions, and that, although a logical order is shown in the flowcharts, in some cases, the steps shown or described can be executed in an order different from that shown here.

[0031] Example 1

[0032] like Figure 1-2 As shown, this embodiment provides a privacy-preserving cross-language federated knowledge graph embedding method, including:

[0033] Initialization phase: includes model initialization and key initialization, deposit upload, and random division of clients into two groups;

[0034] Local training phase: Each client uses its own private knowledge graph to train a local knowledge graph embedding model.

[0035] In-group knowledge sharing: Each client selects an embedding vector that aligns with the entity / relationship of another client group based on the alignment table. The embedding vector is encrypted and uploaded to the server. The server performs aggregation operations based on the partial alignment set and returns the aggregated results within the group for the same entity / relationship. The client selects a verification client to perform the verification operation on the aggregation results. If the verification passes, the local embedding vector is updated.

[0036] Inter-group knowledge alignment: Two client groups collaborate. Each client selects an embedding vector that aligns the entity / relationship with the other client group based on the inter-group alignment table. The embedding vector is encrypted and uploaded to the server. Aggregation operations are performed on the two groups of the same entity / relationship. Each client group selects a verification client to verify the aggregation results. If the verification passes, the local embedding vector is updated and alignment training is performed.

[0037] Ending phase: If a client discovers that the server is cheating, they can upload evidence. The blockchain will deduct their deposit and divide it equally among all clients, while also returning their own deposit. If the training ends normally, all client deposits are transferred to the server, and the server's own deposit is returned.

[0038] The initialization phase includes the following steps:

[0039] Step 1: Each client initializes the knowledge graph embedding model and vector dimension according to the prior agreement, uploads the deposit to the blockchain, and discloses the partial alignment set between the client knowledge graphs. Contains entities / relations that are partially aligned between the knowledge graph of the i-th client and the knowledge graph of the j-th client;

[0040] Step 2: The facilitator generates a homomorphically encrypted public-private key pair (hpk, hsk) based on the security parameter k and sends it to the participating parties. The client has the homomorphically encrypted public-private key pair, and the computing server only has the homomorphically encrypted public key.

[0041] Step 3. The computing server uploads the deposit to the blockchain as agreed, and then randomly divides the clients into two groups. Then, the alignment table within the group is generated based on the grouping results and the total alignment set T. and between-group alignment table Where T contains the partial alignment set of each client’s knowledge graph with other clients, Contains the entities / relations aligned within the group of clients of group j, Contains entities / relations aligned between the first group of clients and the second group of clients;

[0042] During the local training phase, each client uses its own private knowledge graph to perform knowledge graph embedding training locally to obtain its own knowledge graph embedding model. Contains the embedding vector obtained by training the i-th client in the j-th group. The scoring function trained in this stage is related to the specific agreed knowledge graph embedding model.

[0043] The intra-group knowledge sharing stage includes the following steps:

[0044] Step 1: Perform the operation separately in client groups. The clients in each group are aligned according to the alignment table within the group. Select the embedding vectors of entities / relations aligned with other clients in the group

[0045] Step 2: Each client uses the homomorphic encryption public key to select the alignment vector Encrypted And upload to the computing server;

[0046] Step 3: After the server collects the alignment vectors of the group of clients, it performs aggregation operation and returns the aggregation result. For clients in the group, the aggregation operation is as follows;

[0047]

[0048] Where n represents the number of clients in the corresponding client group;

[0049] Step 4: After the client receives the global vector in the group, it first uses the homomorphic encryption private key to decrypt it and obtain The verification operation is performed with probability a, and the assistant selects the verification client C v Responsible for performing aggregation result verification operations, and updating the local embedding vector if the verification passes;

[0050] Step 5. Repeat the above steps until the alignment table within the group is traversed. Each row in;

[0051] The content of the agreement is shown in Agreement 1:

[0052] Protocol 1: ACS-Aggregator, an intra-group vector aggregation protocol against hidden servers.

[0053] grammar:

[0054]

[0055] Private Input:

[0056] The i-th client in the j-th group Knowledge graph embedding model trained with private knowledge graph j∈[1,2],i∈[1,n j ].

[0057] Server S is responsible for the aggregation operation of the vector, and takes an empty string λ as input.

[0058] Common input:

[0059] Intra-group alignment table of client knowledge graph

[0060] Output:

[0061] The server S does not output any information, that is, it outputs the empty string λ.

[0062] Client Output the global embedding vector of the jth group of clients after aggregation

[0063] Interaction process:

[0064] Steps on the client side (C1): According to the alignment table within the group Select the local embedding vector corresponding to the entity or relationship aligned with other clients in the group and encrypt it and upload it to the server.

[0065] 1. Select in It is the vector corresponding to a certain aligned entity / relationship of the i-th client in the j-th group.

[0066] 2. Encrypt the alignment vector using the homomorphic encryption public key,

[0067] 3. Send To the server.

[0068] Server step (S1): Server S receives the jth group of clients Uploaded ciphertext state alignment vector After that, the alignment vectors uploaded by the group will be aggregated and the results will be Sent to the corresponding clients in the group.

[0069] 1. Calculation

[0070] 2. Sign the vector

[0071] 3. Send and σ for the jth group of clients

[0072] Steps on the client side (C2): After receiving the global embedding vector of the ciphertext state, the decryption operation is performed first to obtain With a probability of α, protocol 3 is selected to perform the aggregation result verification operation. If the verification passes or the current round does not verify, the local embedding vector is updated. If the verification fails, the proof material is uploaded to the blockchain and the server is penalized.

[0073] 1. Decrypt the received vector and get

[0074] 2. Execute Protocol 3 on the aggregation result with probability α, and choose not to perform the result verification operation in this round with probability 1-a.

[0075] 3. If the verification is passed or you choose not to verify this round, update

[0076] Repeat steps C1-C2 until the table is aligned within the group Each row is traversed.

[0077] Preferably, the inter-group knowledge alignment phase includes the following steps:

[0078] Step 1: Two client groups work together, and each client group is aligned according to the inter-group alignment table. Select the embedding vectors of entities / relations aligned with another set of clients

[0079] Step 2: Each client uses the homomorphic encryption public key to encrypt the selected alignment vector. And upload to the computing server;

[0080] Step 3: The server collects the alignment vectors of the two groups of clients, performs aggregation operations and returns two sets of aggregation results. and For two groups of clients, the aggregation operation is as follows:

[0081]

[0082] Where n represents the number of clients in the corresponding client group;

[0083] Step 4: After the client receives the two sets of global vectors, it first uses the homomorphic encryption private key to decrypt them and obtain and Then, a verification operation is performed with a probability of a. The client selects a verification client to perform the aggregation result verification operation. If the verification passes, the local embedding vector is updated and alignment training is performed. The loss is the Euclidean distance between the two vectors:

[0084]

[0085] Step 5. Repeat the above steps until the inter-group alignment table is traversed. Each row in;

[0086] The content of the agreement is shown in Agreement 2:

[0087] Protocol 2: ACS-Aligner, an inter-group knowledge alignment protocol against hidden servers

[0088] grammar:

[0089]

[0090] Private Input:

[0091] The i-th client in group 1 Knowledge graph embedding model trained with private knowledge graph i∈[1,n1].

[0092] The jth client in group 2 Knowledge graph embedding model trained with private knowledge graph j∈[1,n2].

[0093] Server S is responsible for the aggregation operation of the vector, and takes an empty string λ as input.

[0094] Common input:

[0095] Inter-group alignment table of client knowledge graph

[0096] Output:

[0097] The server S does not output any information, that is, it outputs the empty string λ.

[0098] The first set of aggregated global embedding vectors Eg100 and the second set of aggregated global embedding vectors Eg200 are output by all participating clients Cij.

[0099] Interaction process:

[0100] Client Step (C1): The first group of clients According to the between-group alignment table Select the local embedding vectors corresponding to the entities or relations aligned with another set of clients and encrypt them and upload them to the server.

[0101] 1. Select in It is the vector corresponding to a certain aligned entity / relationship of the i-th client in the first group.

[0102] 2. Encrypt the alignment vector using the homomorphic encryption public key,

[0103] 3. Send To the server.

[0104] The same goes for the second group.

[0105] Server step (S1): Server S receives the jth group of clients Uploaded ciphertext state alignment vector After that, the alignment vectors of the two groups will be aggregated and the aggregation results of the two groups will be and and its signatures σ1 and σ2 are sent to two groups of clients.

[0106] 1. Calculation and

[0107] 2. Sign the vector

[0108] 3. Send and To two groups of clients.

[0109] Client step (C2): Client Receive two aggregation results and After that, the decryption operation is performed first. Each client group chooses to execute Protocol 3 with a probability of α to verify the aggregation vector of its group. If the verification is successful or not verified in this round, the local embedding vector is updated and knowledge alignment training is performed again. If the verification fails, the proof material is uploaded to the blockchain and the server is punished.

[0110] 1. Decrypt the received vector and get and

[0111] 2. Each client group executes Protocol 3 on the aggregation result with probability α, and chooses not to perform the result verification operation in this round with probability 1-a.

[0112] 3. If the verification is passed or you choose not to verify this round, update

[0113] 4. Use two sets of aggregation results and For knowledge alignment training, the loss function is: in The corresponding first group of client entities and The corresponding second group of client entities are aligned entities.

[0114] Repeat steps C1-C2 until the groups are aligned. Each row is traversed.

[0115] The aggregation result verification operation in the intra-group knowledge sharing stage and the inter-group knowledge alignment stage includes the following steps:

[0116] Step 1: If the client chooses to perform aggregation result verification, the assistant generates a random number and sends it to the client. The assistant generates n-1 random numbers r1, r2, ... r according to the number of clients n in the client group. n-1 and verify the client random number v, and then calculate Then v and the i-th random number r i Sent to the i-th client in the group.

[0117] Step 2: After each client receives its own random number, it adds the random number to the alignment vector to obtain a pseudo alignment vector. For the intra-group knowledge sharing phase, the pseudo alignment vector of each client is:

[0118]

[0119] In the inter-group knowledge alignment phase, the pseudo alignment vector of each client is:

[0120]

[0121] The pseudo alignment vector is then sent to the verification client Authenticate Client The corresponding pseudo-alignment vectors are added together to obtain a result, and this result is compared with the aggregated result returned by the server. If they are the same, the client is notified that verification has passed and training continues. Otherwise, all parties are notified to stop training.

[0122] The specific content of the agreement is shown in Agreement 3:

[0123] Protocol 3: Validator protocol for cross-language federated knowledge graph embedding aggregation results

[0124] grammar:

[0125]

[0126] Private Input:

[0127] The i-th client in the j-th group Knowledge graph embedding model trained with private knowledge graph i∈[1,n j ].

[0128] The assistant S is responsible for the auxiliary operation of aggregation result verification and takes an empty string λ as input.

[0129] Common input:

[0130] When performing aggregation result verification of the ACS-Aggregator sub-protocol, T′ is the intra-group alignment table. When performing the aggregation result verification of the ACS-Aligner sub-protocol, T' is the inter-group alignment table.

[0131] Output:

[0132] The helper H does not output any information, that is, it outputs the empty string λ.

[0133] Client The output is the verification result o, and Continue means passed.

[0134] Interaction process:

[0135] Client step (C1): Client of group j Send a Verify signal to the helper H.

[0136] The assistant's steps (H1): After receiving the Verify signal, H performs the verification auxiliary operation.

[0137] 1. Generate a random number v, v∈[1,n j ],n j is the number of clients in group j, which means the vth client in group i is selected as the verification client

[0138] 2. Generate n j -1 verification random number calculate Then v and r i Sent to the i-th client of the j-th group to ensure the privacy of the local vector during the verification phase, where

[0139] Steps on the client side (C2): Receive random number v and verify random number r i After that, the pseudo local embedding vector is calculated and sent to the verification client.

[0140] 1. Select the local vector of the aligned entity / relation corresponding to this aggregation operation or

[0141] 2. Calculate pseudo local embedding vector or Sent to the authentication client

[0142] Steps to verify client (CV1): Receive the pseudo local embedding vector within the group calculate if or The blockchain smart contract is called to punish the cheating server, and then an Abort message is broadcast; otherwise, a Continue message is sent to continue the subsequent operation.

[0143] Client step (C3): Client If the Continue signal is received, subsequent training will continue; otherwise, this federated learning will be terminated.

[0144] The above are merely preferred embodiments of the present application, but the scope of protection of the present application is not limited thereto. Any changes or substitutions that can be easily conceived by a person skilled in the art within the technical scope disclosed in this application should be included in the scope of protection of the present application. Therefore, the scope of protection of the present application should be based on the scope of protection of the claims.

Claims

1. A privacy-preserving cross-language federated knowledge graph embedding method, characterized by: include: According to the client's agreement and preset security parameters, the knowledge graph embedding model and key are initialized, the deposit is uploaded to the blockchain, and the clients are randomly divided into two groups; According to the initialized knowledge graph embedding model, each client locally uses a private knowledge graph to train a local knowledge graph embedding model; During the intra-group knowledge sharing phase, based on the intra-group alignment table, each client in each group selects an embedding vector that aligns entities / relationships with those of other clients in the same group. The vector is encrypted and uploaded to the server. The server then performs aggregation operations based on the intra-group alignment table and returns the aggregated results for the same entity / relationship within the group. The client selects a verification client to verify the aggregated results. If the verification is successful, the local embedding vector is updated. During the inter-group knowledge alignment phase, two client groups collaborate based on the inter-group alignment table. Each client selects an embedding vector that aligns the entity / relationship with the other client group, encrypts it, and uploads it to the server. Aggregation is performed and the aggregated results of the two groups for the same entity / relationship are returned. The collaborator selects a verification client from each client group to verify the aggregated results. If the verification passes, the local embedding vector is updated and alignment training is performed. Based on the verification results during the training process, if the client discovers that the server is cheating, it will upload evidence, and the blockchain will deduct its deposit and divide it equally among the clients, while returning the deposit of each client; if the training ends normally, all client deposits will be transferred to the server, and the server's own deposit will be returned.

2. The method according to claim 1, characterized in that The process of initializing the knowledge graph embedding model and key according to preset security parameters, uploading the deposit to the blockchain, and randomly dividing the clients into two groups includes: According to the client's prior agreement, each client initializes the knowledge graph embedding model and vector dimensions and uploads the deposit to the blockchain; Based on the preset security parameters, the assistant generates a homomorphic encryption public-private key pair, sends the public key to the computing server, and sends the public-private key to each client; The computing server randomly divides the clients into two groups and generates intra-group alignment tables and inter-group alignment tables based on the grouping results and partial alignment sets.

3. The method according to claim 1, characterized in that The process in which each client uses a private knowledge graph to train locally to obtain a local knowledge graph embedding model includes: each client uses a private knowledge graph to perform knowledge graph embedding training locally according to the initialized model parameters to obtain a local knowledge graph embedding model, and the scoring function of the local stage training is related to the specific agreed knowledge graph embedding model.

4. The method according to claim 1, wherein In the intra-group knowledge sharing stage, each client selects an embedding vector that aligns entities / relationships with other clients in the same group based on the intra-group alignment table, encrypts the selected alignment vector using a homomorphic encryption public key to obtain the encrypted alignment vector, and uploads the encrypted alignment vector to the computing server.

5. The method according to claim 4, characterized in that The client uses the homomorphic encryption private key to decrypt the returned aggregation result to obtain the decrypted aggregation result, and chooses to perform an aggregation result verification operation with a certain probability. If the verification passes, the local embedding vector is updated.

6. The method according to claim 1, characterized in that In the inter-group knowledge alignment stage, each client selects an embedding vector of an entity / relationship aligned with another group of clients based on the inter-group alignment table, encrypts the selected alignment vector using a homomorphic encryption public key to obtain an encrypted alignment vector, and uploads the encrypted alignment vector to the computing server.

7. The method according to claim 6, characterized in that The computing server performs an aggregation operation on the encrypted alignment vectors of the same entity / relationship according to the inter-group alignment table, obtains the aggregation results of the two groups, and returns the aggregation results to the corresponding client.

8. The method according to claim 7, characterized in that The client uses the homomorphic encryption private key to decrypt the returned aggregation result to obtain the decrypted aggregation result, and chooses to perform an aggregation result verification operation with a certain probability. If the verification passes, the local embedding vector is updated and alignment training is performed.

9. An electronic device comprising a memory, a processor, and a computing program stored in the memory and executable on the processor, wherein: When the processor executes the computing program, the method according to any one of claims 1 to 8 is implemented.

10. A computer-readable storage medium storing a computer program, characterized in that: When the computer program is executed by a processor, the method according to any one of claims 1 to 8 is implemented.

Images