A verifiable federated learning method and device with double decomposition and aggregation

Abstract

The application provides a verifiable federated learning method and device based on double decomposition and aggregation, and belongs to the field of privacy security protection of federated learning. Specifically, a trusted third party (TTP) performs secret key negotiation with each client to generate corresponding secret keys. The TTP generates random numbers through a random number generator and sums them to obtain TTP. The TTP sends the secret keys to each client through a symmetric encryption method. Each client sends the trained model parameters to other clients in n parts and accepts the parameters sent from other clients. Each client performs a second round of decomposition on the parameters, and the parameters are decomposed into a public part (sent to the server) and a private part (retained locally). The private part is constructed based on the uploaded local model parameters for each client to construct a verification function v i , and sends it to the server together. The server aggregates the model parameters ω i and the verification function v i sent by the client, and sends the aggregation result to the client. The client verifies whether the data is equal through the verification formula. If they are equal, subsequent update operations are performed. The received global model parameters with bias are aggregated with the private part retained locally to recover the real parameter model.

Description

TECHNICAL FIELD

[0001] The present application belongs to the field of federated learning, and relates to the privacy and security of data, and particularly to a double decomposition and aggregation verifiable federated learning method and device. BACKGROUND

[0002] Federated learning (FL) has always been one of the most promising methods in privacy-preserving machine learning (ML), which helps to efficiently process and analyze large data sets widely scattered in different locations. However, federated learning still faces a series of major challenges. For example, malicious attackers can use various strategies such as model inversion attacks (MIA), reconstruction attacks (RIA) and backdoor attacks to undermine the security and credibility of federated learning, resulting in data leakage and model failure problems. To address the problem of federated learning data leakage, researchers use secure multi-party computation (MPC) to ensure that participants' data remains encrypted during transmission and processing through complex encryption protocols. The final calculation result, whether it is a global model or any intermediate value, can be accurately decrypted, allowing local participants to fully recover the true, non-precise global model. In addition, in addition to protecting the privacy of gradient vectors, it is also important to ensure the integrity of the aggregation result. A malicious server may return a simplified but inaccurate global model, or even fake the aggregation result to gain unfair advantage. This will cause the client to receive an incorrect global model, thereby negatively affecting the training process.

[0003] Document 1: E. Sotthiwat, L. Zhen, Z. Li and C. Zhang, "Partially Encrypted Multi-Party Computation for Federated Learning," 2021 IEEE / ACM 21st International Symposium on Cluster, Cloud and Internet Computing (CCGrid), Melbourne, Australia, 2021, pp. 828-835, doi: 10.1109 / CCGrid51090.2021.00101. proposes to encrypt the key part of the model (gradient) parameters to reduce communication costs while maintaining the advantages of MPC in protecting joint model privacy without sacrificing learning accuracy. Theoretical analysis and experimental results show that the proposed method can prevent attacks on the reconstruction of the original parameters to obtain the final data of individual participants by gradient deep leakage.

[0004] Document 2: G. Xu, H. Li, S. Liu, K. Yang and X. Lin, "VerifyNet: Secure and Verifiable Federated Learning," in IEEE Transactions on Information Forensics and Security, vol. 15, pp. 911-926, 2020, doi: 10.1109 / TIFS.2019.2929409. It proposes that the server sends the aggregation result with the verification proof of each client, and uses homomorphic hash and pseudo-random generation technology to ensure that users can verify the authenticity of the data, enhance trust and transparency.

[0005] Document 3: F. Luo, S. Al-Kuwari, and Y. Ding, "SVFL: Efficient secure aggregation and verification for cross-silo federated learning," IEEE Trans. Mobile Comput., early access, Nov. 4, 2022, doi: 10.1109 / TMC.2022.3219485. It adopts a basic signature scheme to deal with the verification challenge, so that each client can independently verify an aggregation signature independent of the total number of clients. Then, each client decrypts the aggregated gradient, updates the local model parameters, and enters the next round of iteration. This method simplifies the verification process while maintaining the efficiency and security of the system. SUMMARY

[0006] To solve the above problems, the present application proposes a double decomposition and double aggregation federated learning mechanism to ensure that the server cannot directly access the real global model information, thereby completely eliminating the risk of local model reconstruction. At the same time, each client can verify the data from the server to ensure the correctness of the aggregation result. The core of this mechanism lies in the detailed division of local sharing: on the one hand, it generates a public shared part for secure transmission to the server; on the other hand, it retains a secret shared part locally so that the server only receives the local model containing the bias.

[0007] The double decomposition and aggregation verifiable federated learning method and device, comprising the following steps:

[0008] Step 1: Introduce a trusted third party (TTP), and the TTP and each user generate two key pairs locally;

[0009] The first pair: {(pk 1 ,sk1 )(pk 2 ,sk 2 )}←KenGen()

[0010] Second pair:

[0011] TTP sends its two pairs of public keys {pk 1 ,pk 2} to each client through the server, and the client sends its two pairs of public keys to the TTP through the server.

[0012] The TTP uses the public keys received from the server and its own private key sk 1 to perform key agreement to obtain

[0013]

[0014] Each client also uses key agreement to obtain

[0015] Step two, the TTP and each client use the generated agreement key as a random number seed to generate an arbitrary random number through a random number generator (PRG)

[0016]

[0017] Through the above operation, the TTP will obtain the random numbers of all clients The TTP sums all the random numbers to obtain

[0018]

[0019] Step three, the TTP transmits to each client through the server, and here the method of symmetric encryption is used to encrypt the data transmitted by the TTP;

[0020] X←AE.enc(SK,x)

[0021] AE.dec(SK,X)→x

[0022] The TTP uses the public key received from the server and its own private key sk 2 to perform key agreement to obtain

[0023]

[0024] Use the second negotiation key As a key pair for symmetric encryption Encryption yields the ciphertext ct i ;

[0025]

[0026] TTP transmits the corresponding ct via the server. i Send it to each client. The client receives the ct. i Then perform the decryption operation;

[0027]

[0028] Step 4: This step involves two decompositions.

[0029] First round of decomposition:

[0030] First, the model parameters w trained by each client are... i Divide into n independent shared secrets;

[0031]

[0032] w i After decomposition according to the above formula, client i (where i is any value between 1 and n) enters the local communication phase. In the case of a fully connected network, client i displays its model block. Send to all neighboring clients, and simultaneously receive model parameters from all other clients j (j from 1 to n).

[0033] Second round of decomposition:

[0034] Each client will receive model parameters Further decomposition processing is required;

[0035]

[0036] The second round of decomposition further refined the client data from the first round of decomposition and included parameters. Divided into two parts: one part Securely stored locally, another part Securely sent to the server for global aggregation processing.

[0037]

[0038] Here, we will generate and transmit the TTP to the client based on the one in step one. The value is used as a uniform deviation for the above decomposition.

[0039] Step five, the client aggregates the data after the second decomposition;

[0040]

[0041] ω i represents the recombined local model parameters after the second decomposition, each client uploads this parameter to the server for aggregation. In addition to uploading ω i , each client also uploads a verification function v i .

[0042]

[0043] The verification function v i is constructed based on ω i . Each client combines the random value generated by the secret key negotiated with the TTP random value sum and the uploaded public local model parameter ω i After the verification function is generated, v i is uploaded to the server together with ω i .

[0044] Step six, after the server receives v i and ω i , it uses the federated averaging method to aggregate the two parameters.

[0045]

[0046] ω represents the aggregated global model parameters.

[0047]

[0048] represents the aggregation result of the verification function, which will be returned to each client together with ω and the number of all online clients for verification.

[0049] Step seven, after the client receives the returned result, it will verify the received parameters, and the verification formula is as follows:

[0050]

[0051] is the result of the second aggregation. The client calculates the second aggregation result ω returned by the server, and n. If , the aggregation result is correct. The client will update the global model to restore the real global model parameters for the next training;

[0052]

[0053] ω t+1 represent the global model parameters of the next round of participating training; ω t the global model parameters of the previous round; represent the sum of random numbers corresponding to the negotiation key generated by the TTP in the last round, and restore the global model parameters after the client successfully verifies.

[0054] The advantages of the present application are:

[0055] 1) Safer solution: This algorithm effectively solves the information leakage problem, greatly limiting the ability of the server to view the details of the local model, and only allowing the server to access the shared model that has been specially randomized.

[0056] 2) Accurate aggregation: Local participants have the ability to fully restore the underlying true global model, and the introduction of encryption and decryption steps does not result in any reduction in model accuracy.

[0057] 3) Efficient verifiable protocol: The introduction of the double aggregation method enables each participant to verify the aggregation parameters on the client side, ensuring the correctness of the aggregation result. BRIEF DESCRIPTION OF DRAWINGS

[0058] Figure 1 A double decomposition and aggregation verifiable federated learning method and device framework of the present application;

[0059] Figure 2 A comparison diagram of the accuracy of the present application and different aggregation algorithms on the MINIST dataset;

[0060] Figure 3 A comparison diagram of the accuracy of the present application and different aggregation algorithms on the CIFAR-10 dataset;

[0061] Figure 4 Images after gradient inversion of the present application and different aggregation algorithms;

[0062] Figure 5 Structural similarity map after gradient inversion of the present application and different aggregation algorithms. DETAILED DESCRIPTION

[0063] The present application will be further described in detail below with reference to the accompanying drawings and implementation examples.

[0064] The same threat model as previous research is adopted in this application. That is, the clients are honest but curious: they follow the protocol procedures, but may try to infer other clients' private data. However, the potential malicious server may access the real global model information and reconstruct it to obtain the real client data. In addition, the malicious server may send inaccurate aggregation results to reduce costs or pursue illegal goals. This invention introduces a trusted third party (TTP), which is considered a non-colluding and absolutely trustworthy entity, responsible for initializing system parameters and transmitting data such as keys and random numbers. In order to solve the above problems, this invention proposes an enhanced mechanism that uses double decomposition and double aggregation to keep the global model hidden from the server and enable the client to self-verify the transmission of data. Specifically, on the basis of traditional MPC decomposition, each decomposition share is further divided into public and private parts. This double decomposition retains the lossless encryption and decryption advantages of standard MPC and ensures that the central server obtains a non-real global model. In addition, in terms of aggregation, in addition to aggregating the global model, a further aggregation of verification parameters is added, enabling the client to verify the correctness of the aggregated parameters locally. Theoretical analysis and experimental results show that this improved scheme significantly improves the security and privacy protection of training data with minimal communication, computation, and storage overhead.

[0065] The double-decomposition and aggregation verifiable federated learning method and device, as shown in Figure 1 The steps are as follows:

[0066] Step one, introduce a trusted third party (TTP), and the TTP and each user generate two key pairs locally;

[0067] The first pair: {(pk 1 ,sk 1 )(pk 2 ,sk 2 )}←KenGen()

[0068] The second pair:

[0069] The TTP sends its two pairs of public keys {pk 1 , pk 2} to each client through the server, and the client sends its two pairs of public keys to the TTP through the server.

[0070] The TTP uses the public key pk of the first pair of key pairs received from the server and its own retained private key sk 1 of the first pair of key pairs to perform key negotiation to obtain

[0071]

[0072] Each client also uses the public key pk of the first pair of keys received from the server 1 and the private key of the first pair of keys retained locally

[0073] Step two, the TTP and each client will generate a negotiation key Generate an arbitrary random number through the random number generator (PRG) as a random number seed

[0074]

[0075] Through the above operation, the TTP will obtain the random number of all clients While each client only knows its own The TTP will sum all the random numbers to obtain

[0076]

[0077] Step three, the TTP transmits to each client through the server, and in order to prevent malicious third parties or malicious servers from stealing information, an encryption method needs to be used. We use a symmetric encryption method to encrypt the data transmitted by the TTP;

[0078] X←AE.enc(SK,x)

[0079] AE.dec(SK,X)→x

[0080] The TTP uses the public key of the second pair of keys received from the server and the private key sk of the second pair of keys retained by itself 2 , to perform key negotiation to obtain

[0081]

[0082] The second negotiation key is used as the symmetric encryption key to encrypt to obtain ciphertext ct i ;

[0083]

[0084] The TTP sends the corresponding ct i to each client through the server. After the client obtains ct i , decryption operation is performed;​

[0085]

[0086] Step four, two decompositions will be performed in this step.

[0087] First decomposition:

[0088] First, each client trains the model parameters w i into n independent secret shares;

[0089]

[0090] The subscript i represents the client participating in the decomposition, and the model of client i will be decomposed into n parts. denotes the model fragment transmitted from client i to client j. Compared with being managed by a single client, the model parameters are decomposed into multiple secret shares and managed by multiple participants, which significantly improves security. Since each part exists in isolation, it is almost impossible to discover the overall view of the model or the sensitive information embedded in it, and this distributed management method greatly reduces the risk of data leakage.

[0091] w i After decomposition according to the above formula, client i (where i is any value between 1 and n) enters the local communication phase. In the case of a fully connected network, client i sends its model block to all adjacent clients, while receiving model parameters

[0092] Second decomposition:

[0093] Each client will receive the model parameters further decomposition processing;

[0094]

[0095] The second round of decomposition further refines the client data after the first round of decomposition and divides the parameters into two parts: one is stored safely locally, and the other is sent safely to the server for global aggregation processing. To achieve this decomposition, the client can simply randomly select a portion from its complete model as a bias term and subtract this portion from the original model to obtain a general model block. The key is that all participating clients must reach a consensus on this random bias, that is, all clients should have the same bias.

[0096]

[0097] This ensures that when the server returns the globally aggregated public model blocks to each client, they can accurately add their respective biases, thus restoring the complete local model. This mechanism not only protects data privacy but also facilitates efficient model aggregation in a distributed environment. Here, we will use the TTP generated and transmitted to the client in step one... The value is used as a uniform deviation for the above decomposition.

[0098] Step 5: The client will aggregate the data after the secondary decomposition.

[0099]

[0100] ω i This represents the recombined local model parameters after a secondary decomposition. Each client uploads these parameters to the server for aggregation. Besides uploading ω... i Each client will also upload a verification function v. i .

[0101]

[0102] Verification function v i It is based on ω i It is constructed based on this. Each client generates a random value from the key negotiated with TTP. Sum of random values And the uploaded public local model parameter ω i After combining and verifying the function generation, v will be... i With ω i Upload them together to the server.

[0103] Step 6: The server receives v i With ω i The two parameters were then aggregated using the Federated Averaging method.

[0104]

[0105] ω represents the aggregated global model parameters. These parameters are not the actual global model parameters, but rather parameters with bias.

[0106]

[0107] Here, we make The sum of the shared keys generated by TTP is kept secret from the server. The result of the above formula is... In the results of the above proof, the value of ω exists. a deviation amount added after being passed back to the client to obtain complete global model parameters, so as to realize the lossless encryption process.

[0108]

[0109] The aggregation result of the verification function is shown as follows.

[0110]

[0111] The function will be returned to each client together with omega and the number of all online clients for verification.

[0112] Step seven, after receiving the returned result, the client will verify the received parameters, and the verification formula is as follows:

[0113]

[0114] is the result of the second aggregation. The client calculates the second aggregation result returned by the server, and n. If , the aggregation result is correct. The client will update the global model to restore the real global model parameters for the next training;

[0115]

[0116] ω t+1 indicates the global model parameter participating in the next round of training, which is the real lossless parameter; omega t the global model parameter of the previous round, which has a random bias amount; indicates the sum of random numbers corresponding to the negotiation key generated by the TTP in the last round, which is used as a bias amount and restores the global model parameter after the client successfully verifies.

[0117] The two-step decomposition mechanism of secret sharing is adopted in the application, so that the real global model is invisible to the central server, and each client can verify the global model returned by the server locally. And each client can independently verify the data from the server, prevent the malicious server from sending inaccurate aggregation results, make the client training not converge, so as to ensure the correctness of the server data transmission, realize the security protection of federated learning.

[0118] The result is shown as follows:

[0119] The present invention uses the MINIST and CIFAR-10 datasets for relevant experiments, with 100 training rounds. For the MNIST dataset, we use a deep learning model based on a three-layer fully connected network to extract and classify features from the MNIST handwritten digit dataset using two 256-dimensional hidden layers and ReLU activation functions, and output 10 classes of results. For the CIFAR-10 dataset, we use a neural network consisting of three convolutional layers and two fully connected layers to extract features, and classify them through convolution, pooling, and ReLU activation functions. We use Adam as the network optimizer with a batch size of 64, and the learning rate for both models is 0.001, with 50 clients. Gradient inversion uses the vgg-16 model, with 4 clients. The experiment is run using Python 3.8.19 on the PyTorch framework.

[0120] Figure 2 and Figure 3 The training and testing performance of different algorithms on two datasets is shown. The results show that the MPC-based algorithm curve almost overlaps with the unencrypted federated learning curve, indicating that these additional MPC encryption and decryption steps do not affect the final performance. At the same time, our method (MPC_VAL) also shows similar effects, which is consistent with the theoretical analysis, and MPC_VAL successfully inherits the lossless characteristics of MPC.

[0121] Figure 4 The final image obtained after 4000 iterations is shown and compared with the real situation on the ground. Using unprotected FedAvg and traditional MPC algorithms, when the batch size is 16, the server can accurately recover almost all images. In contrast, the MPC_VAL algorithm allows the server to only receive biased models or gradients by introducing two rounds of decomposition. After 4000 local iterations, the server can only get some random noise, thus providing stronger defense for the gradient inversion method.

[0122] Figure 5 It is shown that the server or malicious attacker can start from random noise and gradually adjust the gradient to match the real gradient, ultimately recovering the underlying image. For all algorithms except MPC_VAL, the structure similarity (SSIM) of the inverted image to the real image continues to increase, while MPC_VAL maintains a low SSIM value, showing its advantage in privacy protection.

[0123] The present invention is compared with two well-known secure aggregation protocols. These two protocols are widely used as benchmarks in the literature. All complexity calculations given below assume a single server and N users, each with a model parameter vector of size V.

[0124] [1] H. Fereidooni et al., "SAFELearn: Secure Aggregation for private FEderated Learning," 2021 IEEE Security and Privacy Workshops (SPW), San Francisco, CA, USA, 2021, pp. 56-62, doi: 10.1109 / SPW53761.2021.00017.

[0125] [2] G. Xu, H. Li, S. Liu, K. Yang, and X. Lin, "VerifyNet: Secure and Verifiable Federated Learning," in IEEE Transactions on Information Forensics and Security, vol. 15, pp. 911-926, 2020, doi: 10.1109 / TIFS.2019.2929409.

[0126] The cost calculation of the user end mainly includes the calculation cost, communication cost and storage cost. In terms of calculation, each client needs to perform self-decomposition, send the decomposed parameters to other clients, and perform parameter recombination. The calculation complexity of this process is O(V). In addition, the client also needs to generate a random number with a calculation complexity of O(N), as well as a data vector for calculating v i and verifying the gradient with a calculation complexity of O(V), resulting in a calculation complexity of O(N+V). In terms of communication, the client needs to send and receive decomposed parameters to other clients, and send reconstructed parameters and verification parameters to the server. The overall communication complexity is also O(NV). In terms of storage overhead, in addition to storing its own key generation data, the client also needs to save the keys corresponding to the trusted third party with a complexity of O(N), as well as the data vector of the model parameters v i , and with a complexity of O(V), so the total storage overhead is O(N+V).

[0127] The cost calculation of the server also includes calculation cost, communication cost and storage cost. In terms of calculation, the server needs to aggregate the local gradients of all clients, which involves subtracting the biased local model parameters, with a calculation complexity of O(NV), and the complexity of calculating the aggregated gradient The computation complexity is O(N), and the communication complexity is O(NV). In terms of communication, the server acts as an interface between the users and the trusted third party, responsible for collecting and broadcasting the keys, forwarding the encrypted ciphertext, receiving the parameter vector and v i vector from the clients, and broadcasting the aggregated parameter vector and v i vector to each client. The communication complexity is O(N). Each client uploads the parameters twice, a total of 2N times, each time O(V), so the total upload communication is 2N*O(V)=O(NV). The server needs to distribute each client's parameters to the other N-1 clients, i.e. each parameter is broadcasted N-1 times, so the total download communication is N*(N-1)*O(V)≈O(N 2 V). The overall communication complexity is O(N 2 V). In terms of storage cost, the server needs to store the public keys of the users, the online client list, the aggregated parameter vector and the aggregated verification vector, and the storage complexity is O(N+V).

[0128]

[0129] According to the above table, since it is improved based on the secret sharing method, the client transmits the decomposed model parameters through the server, resulting in a slightly larger communication overhead of the client and the server of the present application than the above two methods. However, since it has been decomposed twice and the verification function is only a simple random number, the present application is superior to the above two methods in terms of computation overhead and storage overhead.

Claims

1. A verifiable federated learning method with dual decomposition and aggregation, characterized in that, The steps are as follows: Step 1: Introduce a trusted third-party TTP. The TTP and each user generate two key pairs locally. First pair: {(pk 1 ,sk 1 (pk) 2 ,sk 2 )}←KeyGen() The second pair: TTP transmits its two key pairs' public keys {pk} to the server. 1 ,pk 2 The key is sent to each client, and the client sends its own public key from its two key pairs. Send it to TTP via the server; TTP uses the public key received from the server. With the private key sk that I keep myself 1 To obtain the key through key negotiation Step 2: TTP and each client will generate the negotiation key. As a random number seed, an arbitrary random number is generated using the random number generator PRG. TTP will obtain random numbers from all clients. TTP sums all the random numbers to obtain n is the total number of clients participating in the training; Step 3: TTP transmits data through the server. The data transmitted to each client is encrypted using symmetric encryption. x←AE.enc(SK,x) AE.dec(SK,X)→x TTP uses a public key received from the server. With the private key sk that I keep myself 2 To obtain the key through key negotiation Use the second negotiation key As a key pair for symmetric encryption Encryption yields the ciphertext ct i ; TTP transmits the corresponding ct via the server. i Send it to each client, and the client receives ct. i Then perform the decryption operation; Step 4: This step involves two decompositions; First round of decomposition: First, the model parameters w trained by each client are... i Divide into n independent shared secrets; w i After decomposition, client i enters the local communication phase. In the case of a fully connected network, client i sends its model blocks... Send to all neighboring clients, and receive model parameters from all other clients j. Where i and j are any values ​​between 1 and n; Second round of decomposition: Each client will receive model parameters Further decomposition processing is required; The second round of decomposition further refined the client data from the first round of decomposition and included parameters. It is divided into two parts: one part is the privacy section. One part is securely stored locally, and the other part is a public part. Send it to the server for global aggregation processing. This is an additive operation on the model parameters; Here, we will generate and transmit the TTP to the client based on the one in step one. The value is decomposed as a uniform deviation. Step 5: The client will aggregate the data after the secondary decomposition. ω i This represents the recombined local model parameters after a secondary decomposition. Each client uploads these parameters to the server for aggregation, in addition to uploading ω. i Each client will also upload a verification function v. i ; Verification function v i Based on ω i It is constructed based on the random value generated by the key negotiated between each client and TTP. Sum of random values And the uploaded public local model parameter ω i After combining and verifying the function generation, v will be... i With ω i Upload them together to the server; Step 6: The server receives v i With ω i The two parameters were then aggregated using a federated average method. ω represents the aggregated global model parameters; This represents the aggregated result of the verification function, which will be returned to each client for verification along with ω and the total number of online clients. Step 7: After receiving the returned result, the client will verify the received parameters. The verification formula is as follows: Δ is the aggregate value calculated theoretically using the verification formula, and the client calculates the secondary aggregate result ω returned by the server. and n, if If the aggregation result is verified to be correct, the client will update the global model to restore the true global model parameters for the next training. ω t+1 ω represents the global model parameters to be used in the next round of training. t This represents the global model parameters from the previous round. This represents the sum of random numbers corresponding to the negotiation key generated by TTP in the previous round, and restores the global model parameters after successful client verification.

2. The verifiable federated learning method of dual decomposition and aggregation as described in claim 1, characterized in that, In step four, the second round of decomposition is based on the sum of random numbers generated by TTP. A portion of these random numbers is retained locally so that the server does not receive the actual model parameters. This function can also be used in later steps to construct the verification function v. i .

3. A verifiable federated learning method for dual decomposition and aggregation as described in claim 1, characterized in that, In step five, based on ω i Based on this, the random value generated by each client using the key negotiated with TTP will be used. Sum of random values Combine and construct a verification function.

4. A verifiable federated learning method for dual decomposition and aggregation as described in claim 1, characterized in that, In step six, the formula for proving the aggregation of global model parameters is as follows: Here, we make The sum of the shared keys generated by TTP is kept secret from the server, and the result of the above formula is... In the result of the proof, the value of ω exists. A deviation value is added after being transmitted back to the client to obtain the complete global model parameters, thereby enabling a lossless encryption process; The verification function aggregate proof formula is as follows: Each client can verify this independently by judging Δ and The equality check determines whether the model parameters have been tampered with and determines whether to perform subsequent parameter update operations.

Images