Secure and efficient federal learning method and system based on secret sharing and differential privacy

Abstract

The invention discloses a secure and efficient federal learning method and system based on secret sharing and differential privacy, and the method comprises the steps: firstly, determining a super client through a super client selection method; and then, after each client finishes local model training, sharing quantitative gradient updating with the server and the super client based on secret sharing. In order to reduce communication overhead and ensure model precision, the client executes dynamic gradient compression before sharing. Then, the super client and the server cooperate to complete gradient aggregation, and differential privacy noise is added into the secretly shared gradient; and after the server recovers the disturbed gradient update, the global model is updated, all the clients download the latest global model, and a new round of iteration is entered. The accuracy of the model is improved, and the training of the model is accelerated.

Description

Technical Field

[0001] The present invention belongs to the field of information security technology and relates to a federated learning method and system, and specifically to a secure and efficient federated learning method and system based on secret sharing and differential privacy. Background Art

[0002] Federated learning is a distributed learning framework that aims to enable multiple clients to collaboratively train a global model under the coordination of a central server. Federated learning usually keeps the client's data locally and only exchanges model updates. However, this is not enough to eliminate privacy issues in distributed learning, as attackers can still infer sensitive information from shared intermediate results (such as model parameters and gradient updates). To address the above issues, researchers usually integrate privacy-preserving techniques such as secure multi-party computation and differential privacy into federated learning. Both techniques have their own advantages and disadvantages. Schemes based on secure multi-party computation can guarantee strong privacy during training without sacrificing model accuracy, but they cannot protect the trained model. Therefore, they are still vulnerable to attacks that rely only on model access, namely membership inference attacks, where the attacker aims to infer membership information in the training dataset. Schemes based on differential privacy introduce random noise in the gradient to defend against the above attacks, but at the cost of sacrificing model accuracy.

[0003] It is natural to combine differential privacy with secure multi-party computation and leverage their advantages to enhance the overall privacy of federated learning. The current solution is to use differential privacy stochastic gradient descent for local model training and then run a secure multi-party computation protocol. However, this model has the following two problems. From the perspective of secure multi-party computation, they usually rely on complex cryptographic primitives (such as homomorphic encryption) and therefore require high computational and communication overheads. From the perspective of differential privacy, although each client can utilize differential privacy stochastic gradient descent to solve the privacy problem, the noise accumulated due to aggregation will cause a significant decrease in model accuracy. Therefore, it remains a challenge to combine differential privacy with secure multi-party computation in federated learning to achieve efficient and accurate training. Summary of the invention

[0004] In view of the deficiencies in the prior art, the present invention provides a secure and efficient federated learning method and system based on secret sharing and differential privacy, which improves the accuracy of the model and accelerates the training of the model.

[0005] The technical solution adopted by the method of the present invention is: a secure and efficient federated learning method based on secret sharing and differential privacy, involving entities including a server and N clients, where N is a preset value;

[0006] The following steps are involved:

[0007] Step 1: The server determines a super client;

[0008] Step 2: Each client i∈[N] uses its private dataset D i Train a local model to get gradient updates Indicates the gradient update of client i in round r, and obtains the compressed gradient update

[0009] Step 3: Each client i quantizes the compressed gradient update to obtain The quantized gradient updates are then shared with the server and super client based on secret sharing The super client and server complete local aggregation, denoted as

[0010] Step 4: The super client and server collaborate to complete the gradient update aggregation and add differential privacy noise to the secret shared gradient, which are recorded as

[0011] Step 5: The server recovers the disturbed global gradient and updates the global model. All clients download the latest global model and start a new round of iteration.

[0012] Preferably, the specific implementation of step 1 includes the following sub-steps:

[0013] Step 1.1: The server first initializes a time record table and configures the corresponding parameters, including selecting the number of rounds R s , offline decision threshold number of rounds H≤R s , the maximum waiting time of each round of servers is t max ;

[0014] Step 1.2: The server is based on the actual training time t of each client i i To update the time record table T i , if t i ≤t max By accumulating t i To record, that is, T i =T i +t i ; Otherwise, by accumulating t max To record, that is, T i =T i +t max ; R s After rounds, if T i ≥t max ×H, then client i is considered offline;

[0015] Step 1.3: The server selects the client with the shortest training time as the super client according to the time record table, that is, arg min i T i .

[0016] Preferably, the specific implementation of step 2 includes the following sub-steps:

[0017] Step 2.1: Client i obtains a local private dataset D i After training the local model, we get the gradient update for the rth round

[0018] Step 2.2: Client i based on compression function Compress locally to get in It is a hyperparameter used to control the degree of compression, and its value range is uniformly distributed between 0 and 1;

[0019] Step 2.3: Use different compression levels for different training rounds r According to the gradient update L 2 Adaptive adjustment of norm Among them, α and β are hyperparameters and satisfy α+β=1.

[0020] Preferably, in step 2.2, for the gradient update Its jth component is compressed as: in express The sign of the random variable is sgn(0)=1. The definition is as follows:

[0021]

[0022] Where f is an integer that satisfies and therefore, yes compression interval.

[0023] Preferably, the specific implementation of step 3 includes the following sub-steps:

[0024] Step 3.1: Each client quantizes the compressed gradient update to obtain

[0025] Step 3.2: Client i generates a random mask And share it to the server, and Share with super clients;

[0026] Step 3.3: The super client locally aggregates the received shares, i.e. The server aggregates the received shares, i.e.

[0027] Preferably, in step 3.1, each client uses a quantization function to calculate Among them, γ() represents the mapping function; is an element-wise rounding function defined as follows:

[0028]

[0029] Among them, q controls the quantization loss, Indicates not greater than The largest integer of ;

[0030] The mapping function γ(x) is defined to map negative integers to values ​​modulo p:

[0031]

[0032] Preferably, the specific implementation of step 4 includes the following sub-steps:

[0033] Step 4.1: Super client computes locally The server computes locally Then, we decompose the super client and server bit by bit to get <z 0 > c ,…, <z k-2 > c and <z 0 > s ,…, <z k-2 > s , where k is the number of bits; finally, the super client calculates where f c express <x> c The number of digits, m∈[0,k-2]; server calculation where f s express <x> s The number of digits,

[0034] Step 4.2: Super Client Calculation Server Computing Then, we decompose the super client and server bit by bit to get 0 > c ,…, k-1 > c and 0 > s ,…, k-1 > s , where k is the number of bits; then, the super client calculates Server Computing Finally, the super client computes Server Computing

[0035] Step 4.3: Super Client Calculation Server Computing

[0036] Step 4.4: Super Client Calculation Server Computing The super client then computes Server Computing

[0037] Step 4.5: Super Client Sampling Noise Server sampling noise Finally, the super client adds noise, i.e. The server adds noise, i.e.

[0038] Preferably, the specific implementation of step 5 includes the following sub-steps:

[0039] Step 5.1: The super client will Upload to the server, the server calculates

[0040] Step 5.2: Server completes global model update

[0041] Step 5.3: All clients download the new global model and then start a new round of local model training; when the number of training rounds reaches the preset value, the federated learning task is completed. ​​​​

[0042] Preferably, in step 5.2, the server completes the global model update by applying a gradient descent algorithm, and the specific implementation includes the following sub-steps:

[0043] Step 5.2.1: The server determines the learning rate η of the gradient descent algorithm;

[0044] Step 5.2.2: Server calculation where w r are the current global model parameters, is the aggregated gradient update, w r+1 are the updated global model parameters.

[0045] The technical solution adopted by the system of the present invention is: a secure and efficient federated learning system based on secret sharing and differential privacy, comprising:

[0046] one or more processors;

[0047] A storage device is used to store one or more programs. When the one or more programs are executed by the one or more processors, the one or more processors implement the secure and efficient federated learning method based on secret sharing and differential privacy.

[0048] Compared with the prior art, the beneficial effects of the present invention include:

[0049] (1) This paper proposes an efficient and privacy-preserving federated learning framework, which can not only provide strong privacy protection for gradient updates, but also defend against member reasoning attacks.

[0050] (2) The present invention integrates differential privacy into secure multi-party computation by designing gradient sharing and gradient perturbation protocols. In order to ensure the effective completion of the protocol between the server and the client in the present invention, a super client selection method is proposed. The present invention also proposes a dynamic gradient compression method to reduce communication overhead and maintain global model accuracy. BRIEF DESCRIPTION OF THE DRAWINGS

[0051] The technical solution of this invention is further described below using embodiments and specific implementation methods. In addition, some drawings are also used in the process of describing the technical solution. For those skilled in the art, other drawings and the intention of the invention can also be obtained based on these drawings without paying creative labor.

[0052] Figure 1 is a schematic diagram of a method flow of an embodiment of the present invention;

[0053] Figure 2 It is a local model structure diagram of an embodiment of the present invention. DETAILED DESCRIPTION

[0054] In order to facilitate ordinary technicians in the field to understand and implement the present invention, the present invention is further described in detail below in conjunction with the accompanying drawings and embodiments. It should be understood that the implementation examples described herein are only used to illustrate and explain the present invention, and are not used to limit the present invention.

[0055] Federated learning aims to train neural network models using distributed data resources from multiple clients without sharing the original data. It has been widely used in various fields, such as network security, smart healthcare, and smart manufacturing. One of the common problems with federated learning is that gradient updates leak sensitive data privacy. Although integrating secure multi-party computing technology into federated learning can solve the privacy leakage problem, the trained model is still vulnerable to member reasoning attacks. Differential privacy can help defend against such attacks. However, the accuracy loss introduced by differential privacy makes it extremely challenging to strike a balance between privacy and accuracy.

[0056] Secret sharing is a cryptographic primitive that splits a secret value into different secret shares, each of which is managed by a different participant. A single participant cannot recover the secret value, and only when several participants work together can the secret value be recovered. At the same time, if a problem occurs to a participant within a certain range, the secret value can still be recovered through the collaboration of the remaining participants.

[0057] Differential privacy is a provable mathematical framework that adds carefully designed noise to samples. It ensures that any individual modification to a dataset does not significantly affect the output. Therefore, an attacker cannot infer the presence or absence of individual data in the dataset by analyzing the output.

[0058] This paper provides a possible solution for the deployment of federated learning based on secret sharing and differential privacy in practical scenarios. Differential privacy is integrated into secure multi-party computation by designing gradient sharing and gradient perturbation protocols. Then, a super client selection method is designed to ensure the effective completion of the protocol between the server and the client. Finally, a dynamic gradient compression method is designed to reduce communication overhead and maintain global model accuracy.

[0059] Please see Figure 1 , This embodiment provides a secure and efficient federated learning method based on secret sharing and differential privacy, involving entities including a server and N clients;

[0060] Step 1: The server determines a super client using a super client selection method;

[0061] In one embodiment, the specific implementation of step 1 includes the following sub-steps:

[0062] Step 1.1: The server first initializes a time record table and configures the corresponding parameters, including selecting the number of rounds R s , offline decision threshold number of rounds H≤R s , the maximum waiting time of each round of servers is t max ;

[0063] Step 1.2: The server is based on the actual training time t of each client i i To update the time record table T i , if t i ≤t max By accumulating t i To record, that is, T i =T i +t i ; Otherwise, by accumulating t max To record, that is, T i =T i +t max ; R s After rounds, if T i ≥t max ×H, then client i is considered offline;

[0064] Step 1.3: The server selects the client with the shortest training time as the super client according to the time record table, that is, arg min i T i .

[0065] Step 2: Each client i∈[N] uses its private dataset D i Train a local model to get gradient updates Represents the gradient update of client i in the rth round, and obtains the compressed gradient update based on the dynamic gradient compression method

[0066] In one embodiment, see Figure 2 , the local model is a feedforward neural network with multiple layers of interconnected nodes. It includes an input layer, one or more hidden layers, and an output layer. In each layer, a group of nodes performs linear or nonlinear transformations on the input signal and passes the processed information to the next layer. Linear transformations use weight matrices to linearly combine the inputs, while nonlinear transformations apply nonlinear activation functions (such as ReLU, Sigmoid, Tanh, etc.) to the results. In this system, the activation layer uses the ReLU activation function. This structure enables deep neural networks to learn complex features and show excellent performance in specific fields such as computer vision, natural language processing, and speech recognition.

[0067] The hidden layer includes one or more convolutional layers, which includes performing dot product calculations between the convolution kernel and the input matrix of the layer, and its activation function is usually ReLU; when the convolution kernel slides along the input matrix of the layer, the convolution operation generates a feature map, which is then contributed to the input of the next layer; followed by other layers, such as pooling layers and fully connected layers;

[0068] The convolution layer can generate a set of parallel feature maps, which are composed by sliding different convolution kernels on the input image and performing certain operations; at each sliding position, an element-by-element product and sum operation is performed between the convolution kernel and the input image to project the information in the receptive field to an element in the feature map; the size of the convolution kernel is much smaller than the input image, and it acts on the input image in an overlapping or parallel manner. All elements in a feature map are calculated by a convolution kernel, that is, a feature map shares the same weight and bias term;

[0069] The ReLU layer uses the function f(x)=max(0,x) as the activation function of this layer; it can enhance the nonlinear characteristics of the entire neural network without changing the convolutional layer calculation itself;

[0070] The pooling layer is actually a nonlinear form of downsampling. Among them, the maximum pooling is the most common. It divides the input image into several rectangular areas and outputs the maximum value for each sub-area. The pooling layer will continuously reduce the spatial size of the data, so the number of parameters and the amount of calculation will also decrease. Through the pooling layer, we can reduce the sensitivity of the convolution layer to the edge. The pooling layer calculates the output on a pooling window each time, and then moves the pooling window according to the stride. The pooling layer used has a stride of 2 and a pooling window of 2×2. The two-dimensional maximum pooling layer, and then takes the maximum value of the 4 numbers in each block, which will reduce the amount of data by 75%;

[0071] The fully connected layer connects each node in one layer to each node in another layer. After several convolutional and maximum pooling layers, the prediction part of the neural network model is completed through the fully connected layer. The nodes in the fully connected layer are associated with all activations in the previous layer; their activations can be calculated as an affine transformation, that is, multiplied by a matrix and then added with an offset.

[0072] In one embodiment, the deep neural network model is a globally initialized model;

[0073] In one embodiment, the specific implementation of step 2 includes the following sub-steps:

[0074] Step 2.1: Client i obtains a local private dataset D i After training the local model, we get the gradient update for the rth round

[0075] Step 2.2: Client i based on compression function Compress locally to get in is a hyperparameter used to control the degree of compression, and its value range is uniformly distributed between 0 and 1; specifically, for gradient update Its jth component is compressed as: in express The sign of the random variable is sgn(0)=1. The definition is as follows:

[0076]

[0077] Where f is an integer that satisfies and therefore, yes compression interval.

[0078] Step 2.3: To use different compression levels at different training epochs r According to the gradient update L 2 Adaptive adjustment of norm The specific adjustment formula is: Among them, α and β are hyperparameters and satisfy α+β=1.

[0079] Step 3: Each client i quantizes the compressed gradient update to obtain The quantized gradient updates are then shared with the server and super client based on secret sharing The super client and server complete local aggregation, denoted as

[0080] In one implementation, the specific implementation of step 3 includes the following sub-steps:

[0081] Step 3.1: Each client quantizes the compressed gradient update to obtain Specifically, each client uses a quantization function to calculate in is an element-wise rounding function defined as follows:

[0082]

[0083] Among them, q controls the quantization loss, Indicates not greater than The mapping function γ(x) is defined as mapping negative integers to values ​​modulo p:

[0084]

[0085] Step 3.2: Each client then shares its quantized local gradient update secret with the super client and the server; specifically, client i generates a random mask And share it to the server, and Share with super clients;

[0086] Step 3.3: The super client locally aggregates the received shares, i.e. The server aggregates the received shares, i.e.

[0087] Step 4: The super client and server collaborate to complete the gradient update aggregation and add differential privacy noise to the secret shared gradient, which are recorded as

[0088] In one implementation, the specific implementation of step 4 includes the following sub-steps:

[0089] Step 4.1: Super client computes locally The server computes locally Then, we decompose the super client and server bit by bit to get <z 0 > c ,…, <z k-2 > c and <z 0 > s ,…, <z k-2 > s , where k is the number of bits; finally, the super client calculates where f c express <x> c The number of digits, m∈[0,k-2]; server calculation where f s express <x> s The number of digits,

[0090] Step 4.2: Super Client Calculation Server Computing Then, we decompose the super client and server bit by bit to get 0 > c ,…, k-1 > c and 0 > s ,…, k-1 > s , where k is the number of bits; then, the super client calculates Server Computing Finally, the super client computes Server Computing

[0091] Step 4.3: Super Client Calculation Server Computing

[0092] Step 4.4: Super Client Calculation Server Computing The super client then computes Server Computing

[0093] Step 4.5: Super Client Sampling Noise Server sampling noise Finally, the super client adds noise, i.e. The server adds noise, i.e.

[0094] Step 5: The server recovers the disturbed global gradient and updates the global model. All clients download the latest global model and start a new round of iteration.

[0095] In one implementation, the specific implementation of step 5 includes the following sub-steps:

[0096] Step 5.1: The super client will Upload to the server, the server calculates

[0097] Step 5.2: The server completes the global model update by applying the gradient descent algorithm ​​​​

[0098] In one embodiment, the gradient descent algorithm first determines the learning rate η of the gradient descent algorithm; then the server calculates where w r are the current global model parameters, is the aggregated gradient update, w r+1 are the updated global model parameters.

[0099] Step 5.3: All clients download the new global model and then start a new round of local model training; when the number of training rounds reaches the preset value, the federated learning task is completed.

[0100] This embodiment also provides a secure and efficient federated learning system based on secret sharing and differential privacy, which is characterized by including:

[0101] one or more processors;

[0102] A storage device is used to store one or more programs. When the one or more programs are executed by the one or more processors, the one or more processors implement the secure and efficient federated learning method based on secret sharing and differential privacy.

[0103] The present invention is further described below through specific experiments. Please see Table 1 for the test accuracy (%) experimental results of this embodiment and other solutions. Table 2 for the training time (s) and communication overhead (MB) experimental results of this embodiment and other solutions.

[0104] Table 1

[0105]

[0106] Table 2

[0107]

[0108] This experiment compares this implementation scheme with other schemes in terms of test accuracy, training time and communication overhead. Five data sets (MNIST, CIFAR-10, Tiny-ImageNet, SpeechCommands, SST2) were selected for the experiment. Table 1 shows the test accuracy of different schemes. It is observed that compared with the schemes based on differential privacy (i.e., DP-SCAFFOLD, FedProx and PRIVATEFL), this implementation scheme has the highest test accuracy, with a maximum improvement of 11.16%; compared with the schemes based on secret sharing (i.e., SecAgg, SecAgg+ and TurboAgg), this implementation scheme has the smallest loss in test accuracy, with a loss of only about 5%. Table 2 shows the training time and communication overhead of different schemes. It is found that this implementation scheme reduces the training time by 1.05 to 3.36 times (1.75 times on average) and reduces the communication overhead by 1.20 to 4.88 times (2.75 times on average). The above experiments show that this implementation scheme improves the accuracy of the model, accelerates the training of the model, and reduces the communication overhead.

[0109] The present invention designs a secure and efficient federated learning scheme based on secret sharing and differential privacy. Differential privacy is integrated into secure multi-party computation by designing gradient sharing and gradient perturbation protocols. Then, a super client selection method is proposed to ensure the effective completion of the protocol between the server and the client. Finally, a dynamic gradient compression method is designed to reduce communication overhead and maintain global model accuracy. Compared with previous schemes, the present invention provides more security for federated learning, accelerates model training, and reduces communication overhead. This provides a possible solution for the deployment of federated learning based on secret sharing and differential privacy in practical scenarios.

[0110] It should be understood that the embodiments described above are part of the embodiments of the present invention, rather than all of the embodiments. In addition, the technical features in the various embodiments or single embodiments provided by the present invention can be combined with each other arbitrarily to form a feasible technical solution. Such combination is not restricted by the sequence of steps and / or the structural composition mode, but must be based on the ability of ordinary technicians in the field to implement. When the combination of technical solutions is contradictory or cannot be implemented, it should be considered that such combination of technical solutions does not exist and is not within the protection scope required by the present invention.

[0111] It should be understood that the above description of the preferred embodiment is relatively detailed and cannot be regarded as limiting the scope of patent protection of the present invention. Under the enlightenment of the present invention, ordinary technicians in this field can also make substitutions or modifications without departing from the scope of protection of the claims of the present invention, which all fall within the scope of protection of the present invention. The scope of protection requested for the present invention shall be based on the attached claims.< / x> < / x> < / x> < / x>

Claims

1. A secure and efficient federated learning method based on secret sharing and differential privacy, involving a server and N clients, where: N is the preset value; It is characterized by comprising the following steps: Step 1: The server determines a super client; Step 2: Each client i∈[N] uses its private dataset D i Train a local model to get gradient updates Indicates the gradient update of client i in round r, and obtains the compressed gradient update Step 3: Each client i quantizes the compressed gradient update to obtain The quantized gradient updates are then shared with the server and super client based on secret sharing The super client and server complete local aggregation, denoted as Step 4: The super client and server collaborate to complete the gradient update aggregation and add differential privacy noise to the secret shared gradient, which are recorded as Step 5: The server recovers the disturbed global gradient and updates the global model. All clients download the latest global model and start a new round of iteration.

2. The secure and efficient federated learning method based on secret sharing and differential privacy according to claim 1, characterized in that: The specific implementation of step 1 includes the following sub-steps: Step 1.1: The server first initializes a time record table and configures the corresponding parameters, including selecting the number of rounds R s , offline decision threshold number of rounds H≤R s , the maximum waiting time of each round of servers is t max ; Step 1.2: The server is based on the actual training time t of each client i i To update the time record table T i , if t i ≤t max By accumulating t i To record, that is, T i =T i +t i ;otherwise , by accumulating t max To record, that is, T i =T i +t max ; R s After rounds, if T i ≥t max ×H, then client i is considered offline; Step 1.3: The server selects the client with the shortest training time as the super client according to the time record table, i.e. argmin i T i .

3. The secure and efficient federated learning method based on secret sharing and differential privacy according to claim 1, characterized in that: The specific implementation of step 2 includes the following sub-steps: Step 2.1: Client i obtains a local private dataset D i After training the local model, we get the gradient update for the rth round Step 2.2: Client i based on compression function Compress locally to get in It is a hyperparameter used to control the degree of compression, and its value range is uniformly distributed between 0 and 1; Step 2.3: Use different compression levels for different training rounds r Adaptive adjustment based on the L2 norm of the gradient update Among them, α and β are hyperparameters and satisfy α+β=1.

4. The secure and efficient federated learning method based on secret sharing and differential privacy according to claim 3, characterized in that: In step 2.2, for the gradient update Its jth component is compressed as: in express The sign of the random variable is sgn(0)=1. The definition is as follows: Where f is an integer that satisfies and therefore, yes compression interval.

5. The secure and efficient federated learning method based on secret sharing and differential privacy according to claim 1, characterized in that: The specific implementation of step 3 includes the following sub-steps: Step 3.1: Each client quantizes the compressed gradient update to obtain Step 3.2: Client i generates a random mask And share it to the server, and Share with super clients; Step 3.3: The super client locally aggregates the received shares, i.e. The server aggregates the received shares, i.e.

6. The secure and efficient federated learning method based on secret sharing and differential privacy according to claim 5, characterized in that: In step 3.1, each client uses the quantization function to calculate Among them, γ() represents the mapping function; is an element-wise rounding function defined as follows: Among them, q controls the quantization loss, Indicates not greater than The largest integer of ; The mapping function γ(x) is defined to map negative integers to values ​​modulo p:

7. The secure and efficient federated learning method based on secret sharing and differential privacy according to claim 1, characterized in that: The specific implementation of step 4 includes the following sub-steps: Step 4.1: Super client computes locally The server computes locally Then, we decompose the super client and server bit by bit to get <z0> c ,…, <z k-2 > c and <z0> s ,…, <z k-2 > s , where k is the number of bits; finally, the super client calculates where f c express <x> c The number of digits, Where m∈[0,k-2]; server calculation where f s express <x> s The number of digits, < / x> < / x> Step 4.2: Super Client Calculation Server Computing Then, we decompose the super client and server bit by bit to get <b0> c ,…, k-1 > c and <b0> s ,…, k-1 > s , where k is the number of bits; then, the super client calculates Server Computing Finally, the super client computes Server Computing ​ ​ Step 4.3: Super Client Calculation Server Computing Step 4.4: Super Client Calculation Server Computing The super client then computes Server Computing Step 4.5: Super Client Sampling Noise Server sampling noise Finally, the super client adds noise, i.e. The server adds noise, i.e.

8. The secure and efficient federated learning method based on secret sharing and differential privacy according to any one of claims 1 to 7, characterized in that: The specific implementation of step 5 includes the following sub-steps: Step 5.1: The super client will Upload to the server, the server calculates Step 5.2: Server completes global model update Step 5.3: All clients download the new global model and then start a new round of local model training; when the number of training rounds reaches the preset value, the federated learning task is completed.

9. The secure and efficient federated learning method based on secret sharing and differential privacy according to claim 8, characterized in that: In step 5.2, the server completes the global model update by applying the gradient descent algorithm. The specific implementation includes the following sub-steps: Step 5.2.1: The server determines the learning rate η of the gradient descent algorithm; Step 5.2.2: Server calculation where w r are the current global model parameters, is the aggregated gradient update, w r+1 are the updated global model parameters.

10. A secure and efficient federated learning system based on secret sharing and differential privacy, characterized in that: include: one or more processors; A storage device for storing one or more programs, which, when executed by the one or more processors, enables the one or more processors to implement the secure and efficient federated learning method based on secret sharing and differential privacy as described in any one of claims 1 to 9.

Images