Secure and efficient federated learning method and system based on secret sharing and differential privacy
By combining secret sharing and differential privacy in federated learning and designing gradient sharing and gradient perturbation protocols, the balance problem between privacy protection and model accuracy is solved, efficient privacy protection and accuracy improvement are achieved, and communication overhead is reduced.
Patent Information
- Application Number
- CN202411859933.6
- Authority / Receiving Office
- CN · China
- Patent Type
- Patents(China)
- Current Assignee / Owner
- Filing Date
- 2024-12-17
- Publication Date
- 2025-09-26
- Estimated Expiration
- 2044-12-17
AI Technical Summary
Existing federated learning solutions have difficulty balancing privacy protection and model accuracy. Secure multi-party computing solutions have high computational and communication overheads, while differential privacy solutions lead to a decrease in model accuracy.
By combining secret sharing and differential privacy, a gradient sharing and gradient perturbation protocol is designed through super client selection, gradient compression and noise addition, and integrated into secure multi-party computing to reduce communication overhead and maintain model accuracy.
It achieves efficient privacy protection and defends against member inference attacks, while improving model accuracy, reducing communication overhead, and improving training efficiency.
Smart Images
Figure CN119903938B_ABST
Abstract
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 designed to enable multiple clients to collaboratively train a global model under the coordination of a central server. Federated learning typically stores client data locally and only exchanges model updates. However, this is insufficient 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 these issues, researchers typically 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 remain vulnerable to attacks that rely solely on model access, namely membership inference attacks, in which the attacker aims to infer membership information in the training dataset. Schemes based on differential privacy introduce random noise into the gradients to defend against these attacks, but at the expense of 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 use differential privacy stochastic gradient descent to solve the privacy problem, the noise accumulated due to aggregation will cause the model accuracy to drop significantly. Therefore, combining differential privacy with secure multi-party computation in federated learning to achieve efficient and accurate training remains a challenge. Summary of the Invention
[0004] In response to the shortcomings of the existing technology, 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, which are 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 denoted 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 the number of rounds R s , offline decision threshold number of rounds H≤R s , the maximum waiting time of each server in each round 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 has a local private dataset D i After training the local model, we get the gradient update for round r
[0018] Step 2.2: Client i based on compression function Perform local compression to obtain 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 Adaptive adjustment based on the L2 norm of the gradient update Where α and β are hyperparameters and satisfy α+β=1.
[0020] As a preference, in step 2.2, for gradient update Its jth component is compressed as: in express The sign of , and define sgn(0)=1; random variable 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 with 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 shares received, i.e.
[0027] As a preference, 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;
[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 Server computes locally Then, we decompose the super client and server into bits and 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, 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 into bits and get <b0> c ,…, k-1 > c and <b0> s ,…, k-1 > s , where k represents the number of bits; then, the super client calculates Server Computing Finally, super client computing 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: 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, which is specifically implemented by 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 gradient update after aggregation, 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, including:
[0046] one or more processors;
[0047] A storage device is used to store one or more programs, which, when executed by the one or more processors, enable the one or more processors to 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 not only provides strong privacy protection for gradient updates but also defends against membership inference attacks.
[0050] (2) This paper integrates differential privacy into secure multi-party computation by designing gradient sharing and gradient perturbation protocols. To ensure the efficient completion of the protocol between the server and client in this paper, a super client selection method is proposed. This paper 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 illustrated below using embodiments and specific implementation methods. In addition, some drawings are used in the process of illustrating the technical solution. Those skilled in the art can also derive other drawings and the intent of the present invention based on these drawings without making any creative efforts.
[0052] Figure 1 is a schematic diagram of a method flow in 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 this field to understand and implement the present invention, the present invention is further described in detail below with reference to the accompanying drawings and examples. 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 applied in various fields, such as cybersecurity, smart healthcare, and smart manufacturing. A common problem with federated learning is that gradient updates can leak sensitive data privacy. While integrating secure multi-party computation techniques into federated learning can address this privacy issue, the trained models are still vulnerable to member inference attacks. Differential privacy can help defend against such attacks. However, the accuracy loss introduced by differential privacy makes striking a balance between privacy and accuracy extremely challenging.
[0056] Secret sharing is a cryptographic primitive that splits a secret value into shares, each managed by a different party. A single party cannot recover the secret value; only a combination of parties can do so. Furthermore, if a single party within a certain range experiences a failure, the secret value can still be recovered through the collaboration of the remaining parties.
[0057] Differential privacy is a provable mathematical framework that uses carefully designed noise to add to samples. It ensures that any individual modification to a dataset has no significant effect on the output. Therefore, an attacker cannot infer the presence of individual data points in the dataset by analyzing the output.
[0058] This paper provides a potential solution for deploying federated learning based on secret sharing and differential privacy in real-world scenarios. Differential privacy is integrated into secure multi-party computation by designing gradient sharing and gradient perturbation protocols. A super-client selection method is then designed to ensure efficient protocol completion between the server and client. Finally, a dynamic gradient compression method is designed to reduce communication overhead while maintaining 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 the number of rounds R s , offline decision threshold number of rounds H≤R s , the maximum waiting time of each server in each round 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 round r, 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 demonstrate outstanding 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 perform dot product calculations on the convolution kernel and the input matrix of the layer. The 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. This is 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-wise product-sum operation is performed between the convolution kernel and the input image to project the information in the receptive field into 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 overlapping or parallel manner. All elements in a feature map are calculated by using a convolution kernel, that is, a feature map shares the same weights and bias terms.
[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, of which maximum pooling is the most common. It divides the input image into several rectangular regions and outputs the maximum value for each sub-region. The pooling layer continuously reduces the spatial size of the data, so the number of parameters and the amount of computation also decrease. Through the pooling layer, we can reduce the sensitivity of the convolutional layer to edges. The pooling layer calculates the output on a pooling window at a time and then moves the pooling window according to the stride. The pooling layer used has a stride of 2 and a 2×2 two-dimensional maximum pooling layer for the pooling window. Then, the maximum value of the four numbers in each block is taken, 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 convolution and maximum pooling layers, the prediction part of the neural network model is completed by 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 has a local private dataset D i After training the local model, we get the gradient update for round r
[0075] Step 2.2: Client i based on compression function Perform local compression to obtain in It 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 , and define sgn(0)=1; random variable 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 rounds r Adaptive adjustment based on the L2 norm of the gradient update The specific adjustment formula is: Where α 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, which are denoted as
[0080] In one embodiment, 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 with 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 shares received, 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 denoted as
[0088] In one embodiment, the specific implementation of step 4 includes the following sub-steps:
[0089] Step 4.1: Super Client Computes Locally Server computes locally Then, we decompose the super client and server into bits and 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, 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 into bits and get <b0> c ,…, k-1 > c and <b0> s ,…, k-1 > s , where k represents the number of bits; then, the super client calculates Server Computing Finally, super client computing 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 embodiment, the specific implementation of step 5 includes the following sub-steps:
[0096] Step 5.1: 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 gradient descent algorithm learning rate η; then the server calculates where w r are the current global model parameters, is the gradient update after aggregation, 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, which, when executed by the one or more processors, enable the one or more processors to implement the secure and efficient federated learning method based on secret sharing and differential privacy.
[0103] The present invention is further illustrated below through specific experiments. Table 1 shows the experimental results of the test accuracy (%) of this embodiment and other solutions. Table 2 shows the experimental results of the training time (s) and communication overhead (MB) of this embodiment and other solutions.
[0104] Table 1
[0105]
[0106] Table 2
[0107]
[0108] This experiment compares this implementation with other solutions in terms of test accuracy, training time, and communication overhead. Five datasets (MNIST, CIFAR-10, Tiny-ImageNet, SpeechCommands, SST2) were selected for the experiment. Table 1 shows the test accuracy of different solutions. It is observed that compared with the differential privacy-based solutions (i.e., DP-SCAFFOLD, FedProx, and PRIVATEFL), this implementation has the highest test accuracy, with a maximum improvement of 11.16%; compared with the secret sharing-based solutions (i.e., SecAgg, SecAgg+, and TurboAgg), this implementation 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 solutions. It was found that this implementation reduced the training time by 1.05 to 3.36 times (1.75 times on average) and reduced the communication overhead by 1.20 to 4.88 times (2.75 times on average). The above experiments show that this implementation improves the accuracy of the model, accelerates the training of the model, and reduces the communication overhead.
[0109] This paper 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. A super-client selection method is then proposed to ensure efficient protocol completion between the server and client. Finally, a dynamic gradient compression method is designed to reduce communication overhead while maintaining global model accuracy. Compared to previous schemes, this paper provides greater security for federated learning, accelerates model training, and reduces communication overhead. This provides a possible solution for deploying federated learning based on secret sharing and differential privacy in real-world scenarios.
[0110] It should be understood that the embodiments described above are only some of the embodiments of the present invention, rather than all of the embodiments. In addition, the technical features of the various embodiments or individual embodiments provided by the present invention may be arbitrarily combined with each other to form a feasible technical solution. Such combination is not restricted by the order of steps and / or structural composition mode, but must be based on the ability of ordinary technicians in this field to implement it. When the combination of technical solutions is mutually inconsistent or cannot be implemented, it should be deemed that such combination of technical solutions does not exist and is not within the scope of protection claimed 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 protection of the patent of the present invention. Under the guidance 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 by 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 in that it includes the following steps: Step 1: The server determines a super client; 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 the number of rounds R s , offline decision threshold number of rounds H≤R s , the maximum waiting time of each round of servers 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 ; 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 The specific implementation of step 2 includes the following sub-steps: Step 2.1: Client i has a local private dataset D i After training the local model, we get the gradient update for round r Step 2.2: Client i based on compression function Perform local compression to obtain in It is a hyperparameter used to control the degree of compression, and its value range is uniformly distributed between 0 and 1; Among them, for the gradient update Its jth component is compressed as: in express The sign of , and define sgn(0)=1; random variable The definition is as follows: Where f is an integer that satisfies and therefore, yes Compression interval; 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; 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, which are 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 denoted 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 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 with the server, and Share with super clients; Step 3.3: The super client locally aggregates the received shares, i.e. The server aggregates the shares received, i.e.
3. The secure and efficient federated learning method based on secret sharing and differential privacy according to claim 2, 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; The mapping function γ(x) is defined to map negative integers to values modulo p:
4. The secure and efficient federated learning method based on secret sharing and differential privacy according to claim 2, characterized in that: The specific implementation of step 4 includes the following sub-steps: Step 4.1: Super Client Computes Locally Server computes locally Then, we decompose the super client and server into bits and 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 into bits and get <b0> c ,…, k-1 > c and <b0> s ,…, k-1 > s , where k represents the number of bits; then, the super client calculates Server Computing Finally, super client computing 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.
5. The secure and efficient federated learning method based on secret sharing and differential privacy according to claim 4, characterized in that: The specific implementation of step 5 includes the following sub-steps: Step 5.1: Super Client will Upload to the server, the server calculates Step 5.2: Server completes global model update Among them, η is the learning rate of the gradient descent algorithm; w r are the current global model parameters, is the gradient update after aggregation, w r +1 are the updated global model parameters; 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.
6. The secure and efficient federated learning method based on secret sharing and differential privacy according to claim 5, 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 gradient update after aggregation, w r+1 are the updated global model parameters.
7. A secure and efficient federated learning system based on secret sharing and differential privacy, characterized by: 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 6.