Anti-collusion verifiable federated learning client selection method

Abstract

The invention provides an anti-collusion verifiable federated learning client selection method, and the method comprises the steps: generating a verifiable public random seed through the cooperation of a client based on a current training round; the client local model updating is completed, dimension reduction is performed on the client local model updating through a public random projection matrix, a model parameter commitment is generated in combination with a private random number, and the model parameter commitment is broadcasted to all participating clients and servers; calculating the selected weight of the client in the current round based on the model quality factor and the long-term fairness factor; based on a zero-knowledge proof system, the verification weight is obtained through calculation according to a preset rule based on committed model parameters; collecting all effective weights, and performing normalization processing to generate effective normalized weights; and based on the public random seed and the effective normalized weight, adopting an unbiased sampling algorithm to select a client.

Description

Technical Field

[0001] This invention relates to the fields of federated learning and privacy computing, and in particular to a collusion-resistant method for selecting federated learning clients. Background Technology

[0002] Federated learning, a key paradigm in distributed machine learning, operates by having each client train its local model on a private dataset, only uploading updates to the server for aggregation to form a global model. Model updates typically manifest as gradients or parameter differences. This model effectively mitigates data privacy risks and solves the data silo problem across industries, leading to its large-scale application in fields such as financial risk control, medical image analysis, and the Internet of Things. Client selection is a crucial step in the federated learning training process, directly impacting the convergence speed, final accuracy, and system stability of the global model. Selecting clients with high contributions accelerates model iteration and ensures training efficiency, as their local model updates closely align with the global optimization direction. Maintaining a fair selection mechanism enhances client participation and prevents system crashes due to client withdrawals.

[0003] Existing methods for selecting clients in federated learning each have their own focus. Some methods prioritize performance, using metrics such as the similarity between the local and global models and the size of the local dataset to calculate selection weights. While these methods can ensure model training quality, they tend to overlook the client's historical participation, resulting in some marginal clients remaining unselected for extended periods, thus compromising participation fairness. Other methods prioritize fairness, using round-robin or random sampling to ensure equal probability of selection for each client. While these methods achieve participation fairness, they fail to filter out low-quality clients, leading to slow global model convergence. A third category attempts to strike a balance between performance and fairness by weightedly fusing performance and fairness metrics to calculate selection weights, such as by introducing a weighted random sampling algorithm based on the client's historical participation count. However, these methods generally lack effective anti-collusion mechanisms, and the weight calculation process is unverifiable. Summary of the Invention

[0004] This invention provides a collusion-resistant federated learning client selection method, comprising: generating a verifiable public random seed through client collaboration based on the current training round; completing a local model update on the client, reducing the dimensionality of the local model update using a public random projection matrix, generating a model parameter commitment using private random numbers, and broadcasting the model parameter commitment to all participating clients and the server; calculating the weight of the client selected in this round based on a model quality factor and a long-term fairness factor; wherein the model quality factor is calculated based on the local model update after the previous round of projection and the global model after the previous round of projection, and the long-term fairness factor is dynamically updated based on the client's historical participation; verifying, based on a zero-knowledge proof system, that the weight is calculated based on the committed model parameters according to a preset rule; collecting all valid weights, performing normalization processing, and generating valid normalized weights; and selecting a client using an unbiased sampling algorithm based on the public random seed and the valid normalized weights.

[0005] The step of generating a verifiable public random seed through client collaboration includes: a trusted center assigning a pair of verifiable random function key pairs to each client; at the start of the t-th training round, each client uses its own verifiable random function private key and the current training round t to calculate the verifiable random function's random output and the corresponding validity proof; each client collects the verifiable random function's random output and the corresponding validity proof data pairs broadcast by all other clients, runs the verifiable random function verification algorithm using the corresponding client's verifiable random function public key, and verifies the authenticity of the verifiable random function's random output; all participating clients collect and aggregate all verified verifiable random function outputs, perform aggregation calculations on them using a hash function, and generate an unpredictable and verifiable public random seed for this round.

[0006] The process of updating the local model on the client side includes: the client initializing the local model based on the global model generated in the previous round of aggregation, performing model training using the local private dataset, and obtaining the local model update for this round; the local model update is the gradient update value or parameter difference of the model parameters, which is used to characterize the contribution information of local training to the optimization of the global model.

[0007] The step of reducing the dimensionality of the model update by using a common random projection matrix includes: performing linear projection processing on the local model update in this round using a preset common random projection matrix, mapping the high-dimensional local model update vector to a low-dimensional space to obtain a low-dimensional model update vector; wherein the common random projection matrix is ​​a fixed matrix agreed upon in advance by all participating clients and servers.

[0008] The step of combining private random numbers to generate model parameter commitments and broadcasting the model parameter commitments to all participating clients and servers includes: the client generating a random number as a private random number, using a preset hash function to perform hash calculation on the low-dimensional model update vector and the private random number to generate a model parameter commitment; confirming that all clients have completed commitment generation or reached a preset time threshold, and broadcasting the encrypted or masked model parameters to all participating clients and servers.

[0009] The model quality factor is calculated based on the local model update after the previous projection and the global model after the previous projection, and further includes: calculating the cosine similarity between the local model update vector after dimensionality reduction by the common random projection matrix in the previous round and the vector of the global model after dimensionality reduction by the same common random projection matrix in the previous round, and using the cosine similarity as the model quality factor.

[0010] The long-term fairness factor is dynamically updated based on the client's historical participation, further including: dynamically determining the long-term fairness factor in each training round, with an initial value set as the reciprocal of the total number of clients; updating the long-term fairness factor of the current round based on the long-term fairness factor of the previous round and the indicator function, the update process adjusting the weights of historical information based on a smoothing factor, the smoothing factor being between 0 and 1; the indicator function is set according to the following rules: if the client was selected to participate in training in the previous round, the indicator function is set to 0; if the client was not selected to participate in training in the previous round, the indicator function is set to 1; if the client did not submit a commitment to model parameters, did not submit weights, or failed the verification of the verifiable random function in the previous round, the indicator function is set to -1.

[0011] The verification of the weights based on the committed model parameters according to preset rules, using a zero-knowledge proof system, includes: constructing an arithmetic circuit using a preset zero-knowledge proof system, with the committed model parameters broadcast in the previous round, the global model projected in the previous round, the long-term fairness factor, and preset hyperparameters as public inputs, and the local model update vector projected in the previous round and the private random number as private inputs; all participants using a public verification key to run the verification algorithm of the zero-knowledge proof system with the public inputs to verify the validity of the zero-knowledge proofs submitted by the clients; if the verification result is invalid, it is determined that the weights are not generated by the committed model parameters; if the verification result is valid, it is determined that the weights are generated by the committed model parameters.

[0012] The generation of effective normalized weights includes: collecting all effective weights verified by the zero-knowledge proof system; calculating the sum of all effective weights; and performing a ratio operation between the effective weight of a single client and the sum of the weights to obtain the normalized weight of that client; wherein the effective normalized weight satisfies that the sum of the normalized weights of all clients is 1, and the normalized weight of a single client is between 0 and 1.

[0013] The step of selecting clients using an unbiased sampling algorithm includes: generating random numbers based on a verifiable public random seed, and using these random numbers as the sampling basis; constructing a cumulative probability distribution according to the effective normalized weights of the clients, wherein the cumulative probability interval for each client in the cumulative probability distribution is the sum of the effective normalized weights of all clients preceding the current client in a client list arranged in a preset order to the sum of the cumulative weights of the current client; matching the random numbers with the intervals in the cumulative probability distribution, and the client corresponding to the cumulative probability interval in which the random number falls is the selected client; repeating the above steps until a preset number of clients are selected, and each sampling process generates a new random number based on the updated public random seed.

[0014] The anti-collusion federated learning client selection method provided by this invention precisely addresses the technical pain points of existing federated learning client selection methods, such as insufficient anti-collusion capability, difficulty in balancing training quality and participation fairness, and lack of process verifiability, through a full-process collaborative design including client collaborative random seed generation, two-factor weight calculation, zero-knowledge proof verification, effective weight normalization, and unbiased sampling. This achieves a multi-dimensional technical breakthrough.

[0015] This invention achieves a qualitative improvement in anti-collusion security, fundamentally eliminating the possibility of malicious clients manipulating the selection results. It relies on VRF (Virtual Randomization) to enable clients to collaboratively generate a public random seed. Each client must generate a random output and a validity proof based on its unique key pair and the current training round. Only after cross-verification by multiple clients can the client participate in seed aggregation, completely avoiding the risk of a single client or centralized node tampering with the random numbers. When a malicious client attempts to tamper with its own random output to influence seed generation, its output will be identified as invalid by other clients through a public key verification algorithm, thus being excluded from the seed aggregation process. Since the seed is aggregated from the valid random outputs of multiple honest clients, the tampering behavior of a single or a few malicious clients cannot affect the randomness and authenticity of the seed. Simultaneously, the zero-knowledge proof system rigorously verifies the weight generation process, ensuring that the weights are calculated from the committed model parameters according to preset rules, effectively blocking collusion to forge weights. This ensures that the client's selection result is entirely based on the genuine model contribution and historical participation behavior, building a solid defense for the security of global model training. Specifically, when multiple clients collude to forge weights, they need to share their respective private random numbers to generate consistent model parameter commitments. However, these private random numbers are held only locally by the clients and are not disclosed to the outside world. Collusion cannot obtain the private random numbers of multiple parties, causing the generated commitments to fail to pass the zero-knowledge proof verification and ultimately be judged as invalid weights, thus technically eliminating the possibility of collusion forgery.

[0016] The model training quality and client participation fairness are dynamically and collaboratively optimized. This invention innovatively adopts a dual-factor weighting mechanism. The model quality factor is calculated by the cosine similarity between the local model update and the global model after projection. This accurately quantifies the immediate contribution value of each client, ensuring that high-contribution, high-quality clients receive higher selection weights, effectively accelerating the convergence speed of the global model and improving overall training efficiency. The long-term fairness factor is dynamically adjusted based on the client's historical participation. In the initial stage, all clients are given equal weights. Subsequently, an indicator function is used to increase the weights of unselected clients and suppress the weights of clients that violate regulations. This avoids marginal clients being marginalized in the long term, punishes malicious participation, continuously maintains the client's participation enthusiasm, and ensures the long-term stable operation of the federated learning system.

[0017] The construction of a fully verifiable system achieves the dual goals of privacy protection and process transparency. A public random projection matrix reduces the dimensionality of the high-dimensional local model update, preserving important features while decreasing data dimensionality. Combined with the commitment to model parameters generated by private random numbers, this effectively protects the privacy and security of the local model update while ensuring the authenticity of the model data and preventing data tampering risks in subsequent weight calculation stages. The zero-knowledge proof system can verify the validity of the weight source without disclosing client-side private data. All participants can verify the results through public input and verification keys, achieving distributed verifiability of the selection process. This eliminates reliance on centralized trusted nodes and perfectly aligns with the distributed architecture of federated learning.

[0018] The system's practicality and scenario adaptability are significantly enhanced, demonstrating broad application value. The unbiased sampling algorithm constructs a cumulative probability distribution based on effectively normalized weights, ensuring a precise match between the client's selection probability and their actual contribution. Furthermore, each sampling generates new random numbers based on an updated public random seed, further improving the unpredictability and fairness of the selection results. The entire method requires no complex hardware or special operating environments; the operational logic of each step is clear and the steps are feasible, enabling flexible adaptation to federated learning scenarios in various fields such as financial risk control, medical image analysis, and smart IoT. While ensuring data privacy and system security, it provides reliable support for high-quality global model training, possessing strong practical application value and promising prospects for widespread adoption. Attached Figure Description

[0019] To more clearly illustrate the technical solutions in this invention or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are some embodiments of this invention. For those skilled in the art, other drawings can be obtained from these drawings without creative effort.

[0020] Figure 1 This is a flowchart of the anti-collusion federated learning client selection method provided by the present invention.

[0021] Figure 2 This is a flowchart illustrating the process of generating a verifiable public random seed collaboratively by clients.

[0022] Figure 3 This is a schematic diagram of verifying weights using a zero-knowledge proof system.

[0023] Figure 4 This is a flowchart of the process of selecting clients using an unbiased sampling algorithm. Detailed Implementation

[0024] To make the objectives, technical solutions, and advantages of this invention clearer, the technical solutions of this invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some, not all, of the embodiments of this invention. All other embodiments obtained by those skilled in the art based on the embodiments of this invention without creative effort are within the scope of protection of this invention.

[0025] The following is combined Figures 1-4 This invention describes the anti-collusion federated learning client selection method. Figure 1 This is a flowchart of the anti-collusion federated learning client selection method provided by the present invention. Figure 1 As shown, the anti-collusion federated learning client selection method of the present invention includes: in step S100, based on the current training round, a verifiable public random seed is generated through client collaboration; in step S200, the client's local model update is completed, the dimensionality of the client's local model update is reduced by the public random projection matrix, model parameter commitments are generated by combining private random numbers, and the model parameter commitments are broadcast to all participating clients and servers; in step S300, the weight of the client selected in this round is calculated based on the model quality factor and the long-term fairness factor; wherein, the model quality factor is calculated based on the local model update after the previous round of projection and the global model after the previous round of projection, and the long-term fairness factor is dynamically updated based on the client's historical participation; in step S400, based on the Zero-Knowledge Proof (ZKP) system, the verification weight is calculated based on the committed model parameters according to preset rules, excluding clients that fail verification; all valid weights are collected, normalized, and valid normalized weights are generated; in step S500, based on the public random seed and valid normalized weights, an unbiased sampling algorithm is used to select clients.

[0026] Specifically, Figure 1The outputs of each step are as follows: Step S100 outputs a verifiable public random seed; Step S200 outputs a model parameter commitment; Step S300 outputs the client's selection weights for this round; Step S400 outputs valid normalized weights; and Step S500 outputs a list of selected clients. Each output serves as the input for subsequent steps, forming a closed-loop process. Step S100 aims to generate an immutable and traceable public random seed through distributed collaboration, providing a secure foundation for subsequent unbiased sampling. The Trusted Center pre-assigns a unique VRF key pair, including a public key and a private key, to each client participating in the federated learning system. The public key is publicly available to all clients and the server, while the private key is securely stored locally by the client, ensuring that only the client holding the private key can generate the corresponding random output. At the start of the current training round, each client calls its locally stored VRF private key, combines it with the current training round identifier, and runs the VRF algorithm to generate the corresponding random output value and a validity proof. This proof is used to verify the legitimacy of the random output to other participants, preventing private key abuse or random value forgery. Each client broadcasts its generated VRF random output and validity proof to all participating clients and servers, while simultaneously collecting VRF random output and validity proof data pairs broadcast by other clients. For each collected data pair, the client uses the corresponding sender's VRF public key to run the VRF verification algorithm to verify whether the random output was generated by the client's private key and in the current round. If the verification result is invalid, i.e., the proof does not match the random output or the public key verification fails, the data pair is discarded, and the corresponding client is excluded from the seed aggregation process in this round, and no further data is received from it. All clients and servers that pass cross-validation aggregate all valid VRF random outputs, and use a preset hash function to hash the aggregated random output set to generate a fixed-length hash value, which is the public random seed for this round of training. Due to the irreversibility and collision resistance of the hash function, and the fact that the random output is verified by multiple nodes, the seed is ensured to be both unpredictable and verifiable. Any participant can verify the authenticity of the seed by rehashing the valid random output set.

[0027] Step S200 implements local model training, privacy-preserving dimensionality reduction, and parameter commitment locking, balancing data privacy and subsequent verifiability. Each client obtains the global model parameters aggregated from the previous training round from the server and uses these as initial values ​​to initialize the local model. Subsequently, the client calls its local private dataset and performs local training using a preset machine learning optimization algorithm. The number of training rounds can be adaptively set according to the dataset size, ultimately obtaining the local model update for this round. This update value directly represents the contribution of local training to the global model optimization. All participants pre-determine a public random projection matrix through a consensus mechanism. This matrix is ​​a fixed-dimensional random matrix, with its dimension determined by the dimension of the high-dimensional model update vector and privacy protection requirements. The client calls this preset matrix to perform linear projection operations on the local model update vector, i.e., vector-matrix multiplication, mapping the high-dimensional, privacy-sensitive model update to a low-dimensional vector. This preserves contribution features while reducing the risk of privacy leakage, and the public nature of the projection matrix ensures that the dimensionality reduction process of all clients is consistent and comparable. The client generates a private random number using a local pseudo-random number generator. This private random number is stored locally and not disclosed to external parties. Using the same hash function as in step S100, the client performs a joint hash calculation on the low-dimensional model update vector and the private random number, generating a fixed-length hash value as a model parameter commitment. This commitment locks the current client's low-dimensional model update, protecting privacy while providing a basis for subsequent weight verification. The client continuously monitors the commitment broadcast status of other clients. After generating its model parameter commitment, the client can broadcast its own commitment value at any time. However, to prevent collusion between the server and some clients, allowing colluding clients to obtain the aggregated global model and forge their own model parameters and commitments to obtain high model quality scores, the client only uploads its encrypted or masked model parameters to the server when all clients have broadcast their commitments or when a preset time threshold is reached.

[0028] Step S300 calculates the weight of the client's selection in this round using a two-factor weighting mechanism, balancing model training quality and participation fairness. The model quality factor is calculated based on the local model update after the previous round of projection and the global model after the previous round of projection. The client retrieves its local model update vector after dimensionality reduction using the common random projection matrix from the previous round, and the vector of the global model after dimensionality reduction using the same common random projection matrix from the previous round. The similarity between the two is quantified using the cosine similarity formula, and the result is directly used as the model quality factor. A higher value indicates a more significant contribution of the client's local training in the previous round to the optimization of the global model. The long-term fairness factor is dynamically updated based on the client's historical participation. In the initial stage, all clients are assigned equal initial weights, specifically the reciprocal of the total number of clients, ensuring that each client has an equal chance of being selected in the early stages of training. In each round of training, the update of the long-term fairness factor depends on the long-term fairness factor and indicator function of the previous round. At the same time, a smoothing factor is used to adjust the weight of historical information. The smoothing factor ranges between 0 and 1, and a larger value indicates a more significant impact of historical participation on the current factor. The value of the indicator function is determined based on the client's participation status in the previous round. If the client was selected to participate in training in the previous round, the value is 0; if not, the value is 1; and if the client did not submit model parameter commitments, weights, or failed VRF validation in the previous round, the value is -1. The fusion ratio of the model quality factor and the long-term fairness factor is determined by preset hyperparameters. λ Regulation, λ The value of λ ranges between 0 and 1. When the scenario prioritizes model training quality and needs to prioritize selecting high-contribution clients, λ can approach 1; when the scenario prioritizes participation fairness and needs to guarantee participation opportunities for marginal clients, λ can approach 0; the default value is 0.5, achieving a balanced integration of model quality and participation fairness. The client calculates the weight of the selected client in this round by fusing the model quality factor and the long-term fairness factor according to a preset ratio. The fusion method can be flexibly adjusted according to the actual scenario's emphasis on quality and fairness.

[0029] Step S300 calculates the weight of the client's selection in this round using a two-factor weighting mechanism, balancing model training quality and participation fairness. The model quality factor is calculated based on the local model update after the previous round of projection and the global model after the previous round of projection. The client retrieves its local model update vector after dimensionality reduction using the common random projection matrix from the previous round, and the vector of the global model after dimensionality reduction using the same common random projection matrix from the previous round. The similarity between the two is quantified using the cosine similarity formula, and the result is directly used as the model quality factor. A higher value indicates a more significant contribution of the client's local training in the previous round to the optimization of the global model. The long-term fairness factor is dynamically updated based on the client's historical participation. In the initial stage, all clients are assigned equal initial weights, specifically the reciprocal of the total number of clients, ensuring that each client has an equal chance of being selected in the early stages of training. In each round of training, the update of the long-term fairness factor depends on the long-term fairness factor and indicator function of the previous round. At the same time, a smoothing factor is used to adjust the weight of historical information. The smoothing factor ranges between 0 and 1, and a larger value indicates a more significant impact of historical participation on the current factor. The typical range for the smoothing factor is 0.7-0.9, with a default value of 0.8. This value preserves the continuous impact of historical participation on fairness, avoiding imbalances caused by short-term fluctuations, while also responding to recent changes in client participation status through residual weights, ensuring the flexibility and rationality of factor updates. The indicator function's value is determined based on the client's participation status in the previous round: 0 if the client was selected to participate in training in the previous round, 1 if not selected, and -1 if no model parameter commitments, weights, or VRF validation were submitted in the previous round. Assuming the federated learning system has a total of N=10 clients, an initial long-term fairness factor of 1 / 10=0.1, and a smoothing factor γ=0.8, if a client was not selected for training in the previous round (indicator function I=1), then the long-term fairness factor for the current round is 0.8×0.1 + (1-0.8)×1=0.28, and the weight is increased. If a client did not commit to model parameters in the previous round (indicator function I=-1), then the factor for the current round is 0.8×0.1 + (1-0.8)×(-1)=-0.12, and the weight is suppressed. This achieves differentiated control over different participation behaviors. The client calculates the weight of being selected in the current round by fusing the model quality factor and the long-term fairness factor according to a preset ratio. The fusion method can be flexibly adjusted according to the actual scenario's emphasis on quality and fairness.

[0030] Step S400 verifies the legality of weights using ZKP, filters valid clients, and completes weight normalization, providing a reliable basis for sampling. First, an arithmetic circuit is constructed using a pre-defined ZKP system to clarify the scope of public and private inputs. Public inputs include the model parameter commitments broadcast in the previous round, the global model projected from the previous round, the long-term fairness factor for the current round, and pre-defined hyperparameters. Private inputs include the local model update vector projected from the previous round and private random numbers generated by the client. Based on its private and public inputs, the client runs the proof generation algorithm of the ZKP system to generate the corresponding ZKP and broadcasts it to all participants. All participants use the public verification key to run the verification algorithm of the ZKP system based on the public inputs to verify the validity of the ZKP submitted by the client. If the verification result is invalid, the client's weights are determined not to be generated from the committed model parameters, constituting forged weights, and the client is excluded from the selection process in this round; if the verification result is valid, the weights are deemed legal, and the client is a valid participating client. All participants aggregate the valid weights of all verified clients, calculate the sum of all valid weights, and then calculate the ratio of each valid client's weight to this sum to obtain the normalized weight for each client. This normalized weight satisfies the condition that the sum of the normalized weights of all clients is 1, and the normalized weight of a single client ranges between 0 and 1, ensuring that the weights can be directly used for probability sampling.

[0031] Step S500 uses a public random seed and effective normalized weights to select a predetermined number of clients through an unbiased sampling algorithm. The client and server, based on the public random seed generated in step S100, run a random number generation algorithm to generate a random number between 0 and 1, which is used as the basis for sampling in this round. All participants arrange the valid clients in a predetermined order, which can be pre-agreed as client ID sorting or other fixed sorting methods to ensure consistency across all participants. Following the sorted order, a cumulative probability distribution is constructed based on the effective normalized weights of each client. The cumulative probability interval for each client is the sum of the effective normalized weights of all clients preceding the current client, extending to the sum of the cumulative effective normalized weights including the current client; the interval length is exactly the same as the effective normalized weight of that client. The generated random number is matched against each interval in the cumulative probability distribution; the client corresponding to the cumulative probability interval into which the random number falls is the selected client in this round. If multiple clients need to be selected, repeat the above process. Before each sampling, a new random number is generated based on the updated public random seed. The update method can be achieved by rehashing the original public random seed to ensure the randomness and independence of each sampling until the preset number of clients have been selected.

[0032] The process seamlessly integrates model update aggregation and iteration, ensuring the continuity of the training process. Selected clients upload their complete local model updates for the current round to the server. The server aggregates all received local model updates, using a weighted average based on the effective normalized weights of each client. Clients with higher weights have a greater impact on the global model, ensuring the aggregation result fully incorporates the training contributions of high-quality clients. The server calculates new global model parameters through this weighted average, which represent the final result of this training round. These new global model parameters serve as the initial global model for the next training round and are also used as input for generating the next round's common random seed, achieving a closed-loop iterative training process and ensuring that each training round continuously optimizes based on the results of the previous round.

[0033] Figure 2 This is a flowchart illustrating the process of collaboratively generating a verifiable public random seed via client-side mechanisms. For example... Figure 2 As shown, according to an embodiment of the present invention, a verifiable public random seed is generated collaboratively by clients, including: in step S110, the trusted center allocates a pair of Verifiable Random Function (VRF) key pairs to each client; in step S120, at the start of the t-th training round, each client uses its own VRF private key and the current training round t to calculate the VRF random output and the corresponding validity proof; in step S130, each client collects the verifiable random function random outputs and corresponding validity proof data pairs broadcast by all other clients, runs the VRF verification algorithm using the corresponding client's VRF public key, and verifies the authenticity of the verifiable random function random output; in step S140, all participating clients collect and summarize all verified verifiable random function random outputs, aggregate them using a hash function, and generate an unpredictable and verifiable public random seed for this round.

[0034] Specifically, the process of generating verifiable public random seeds through client collaboration is the foundation for ensuring that the federated learning selection process is resistant to manipulation and collusion. The process is carried out in an orderly manner around four major stages: key distribution, random output and proof generation, cross-validation, and aggregation generation. Each stage is secured and verifiable through cryptographic mechanisms. Figure 2 The input and output relationships of each step are as follows: Step S110 inputs the key pair allocated by the trusted center and outputs the client-specific VRF key pair; Step S120 inputs the VRF private key and training round t and outputs the VRF random output and validity proof; Step S130 inputs the random output and validity proof of other clients and outputs the filtered set of valid random outputs; Step S140 inputs the set of valid random outputs and outputs the common random seed.

[0035] Step S110, as the initialization stage of the process, aims to lay the key foundation for the uniqueness and verifiability of random outputs. The Trusted Center, as the authoritative node in the initial phase of the federated learning system, must possess secure key generation and distribution capabilities to prevent key leakage or tampering during transmission. Each client is assigned a VRF key pair containing a public key and a private key, which have a strict mathematical correspondence; the private key cannot be derived from the public key alone, thus ensuring the absolute confidentiality of the private key. The public key is synchronized to all participating clients and servers, forming a publicly queryable keystore used for subsequent verification of the legitimacy of random outputs generated by other clients. The private key is stored by the client in a local secure environment, protected by hardware encryption modules or secure storage protocols, ensuring that only the client can use the private key to perform calculations, preventing unauthorized access or misuse. Each client's key pair remains fixed throughout the system's lifecycle; unless special circumstances such as key leakage occur, there is no need for reallocation, ensuring process stability and reducing the computational overhead of generating duplicate keys.

[0036] Step S120 focuses on generating random outputs and proofs with individual legitimacy, providing a basis for subsequent cross-validation. When the t-th round of training officially starts, the system synchronizes the current round identifier t to all clients. This identifier serves as a key component of the computational input, ensuring that the random output of each round is bound to a specific round, avoiding data confusion between different rounds. Each client calls its locally stored private key, combined with the round identifier t, to run the preset VRF algorithm, generating two results: a random output. y i and validity proof π i Their computational relationship satisfies in, SK i For the client i The private key. Random output. y i It is a random value whose generation depends entirely on the private key and round identifier. Different clients use different private keys, and even within the same round, completely different values ​​will be generated. y i Validity proof π i This contains key computational traces of the random output generation process, which can prove to other participants... y i It was indeed legitimately generated using the client's private key and the current round t, and was not forged or tampered with. (Client-generated) y i and π iThen, this data will be broadcast immediately to the entire federated learning network to ensure that all participating clients and servers receive it in a timely manner, in preparation for subsequent cross-validation.

[0037] Step S130 is a crucial verification step to ensure the authenticity of the random output. It uses distributed cross-validation to eliminate invalid data and malicious clients, ensuring that all random outputs participating in the seed aggregation originate from honest clients. After broadcasting its own random output and validity proof, each client continuously listens for broadcasts from other clients in the network, collecting all random output and validity proof data pairs sent by all other clients to form a complete dataset to be verified. Each data pair corresponds to a sending client. To clearly distinguish different sources, the client currently performing the verification operation can be referred to as... i The other clients that send data can be called... j Different j Representing different senders, the data they broadcast includes random outputs from the sending client. y j and validity proof π j .

[0038] For each set of data in the dataset, the client i They will retrieve the corresponding sending client from the public keystore. j public key PK j ,Will PK j Current round identifier t Received random output y j and validity proof π j When input into the VRF verification algorithm, the verification operation performed is as follows: .

[0039] The algorithm simulates the generation logic of random output, and uses the public key to reverse verify the consistency between the random output and the validity proof, thus determining... y j Is it a sending client? j Use its private key and the current round t The data was generated legally. If the verification algorithm returns an invalid result, it means that the random output does not match the validity proof, or the public key verification failed, thus determining that the data pair is invalid, and the corresponding sending client... j There may be malicious activities such as forging random outputs or abusing keys.

[0040] For invalid data pairs, the client i It will be discarded directly, and the corresponding message will be sent to the client.j Nodes marked as violating regulations will no longer receive any data from that client and will be prohibited from participating in subsequent seed aggregation and other processes, thus eliminating interference from malicious nodes in seed generation at the source. This cross-validation process is not performed by a single client, but rather by all clients simultaneously. Each client independently verifies all received data pairs, ensuring the objectivity and consistency of the verification results. This prevents verification errors by a single client from affecting the security of the overall process, ultimately filtering out the valid random outputs from all honest clients, providing a reliable foundation for subsequent seed aggregation.

[0041] Step S140 is the final step in generating the public random seed. Through the aggregation operation of valid random data, a random resource with global consistency, unpredictability and verifiability is formed, providing a safe and reliable random basis for subsequent unbiased sampling.

[0042] After all clients complete cross-validation, each client receives a filtered set of valid random outputs, all of which originate from verified, honest clients. Since all clients use identical validation logic and public key repositories, and the filtered sets of valid random outputs are also identical across clients, global data consistency is ensured, preventing inconsistencies in seed generation results due to data differences.

[0043] Subsequently, all participating clients and servers synchronously perform aggregation operations on this valid set of random outputs. The hash function used possesses irreversibility and collision resistance. Irreversibility means that the original valid set of random outputs cannot be deduced from the final generated hash value, while collision resistance ensures that different valid sets of random outputs cannot generate the same hash value. These two characteristics together guarantee the security of the seed. During the aggregation process, the valid random outputs are arranged in a preset fixed order to avoid affecting the final hash result due to different arrangement orders. The arranged whole is then used as input to the hash function, and after calculation, a fixed-length hash value is obtained. This hash value is the seed. t The calculation relationship of the public random seed for each round of training can be expressed as follows: in, y 1 , y 2 Until y N ' Represents all valid, random outputs that pass validation. N' The number of valid clients that have passed verification. H This represents the default hash function.

[0044] Because the public random seed is aggregated from the valid random outputs of multiple honest clients, the randomness of the seed is guaranteed as long as even one honest client exists in the system. Even if some clients engage in malicious behavior, they cannot affect the overall randomness of the seed, thus eliminating the possibility of a single node tampering with the seed at its source. Simultaneously, any participant can obtain the valid random output set, re-execute the calculation according to the same arrangement and hash function, and verify the generated seed result to ensure that the seed has not been tampered with. This achieves full-process verifiability of the seed generation process, making the randomness of the entire selection process transparently auditable.

[0045] According to an embodiment of the present invention, the local model update on the client side is completed by: the client initializing the local model based on the global model generated in the previous round of aggregation, performing model training using the local private dataset, and obtaining the local model update in this round; the local model update is the gradient update value or parameter difference of the model parameters, which is used to characterize the contribution information of local training to the optimization of the global model.

[0046] Specifically, the process of updating the local model on the client side is a key step in federated learning's distributed training. It ensures the continuity of global model iteration while strictly protecting local data privacy. The process is carried out in an orderly manner around three aspects: inheriting global results, mining the value of local data, and extracting effective contribution information. Ultimately, it forms a model update that can accurately represent the training value.

[0047] Model initialization is fundamental to ensuring that local training does not deviate from the global optimization direction. After the previous training round, the server synchronizes the aggregated global model parameters to all participating clients. These parameters incorporate the training results of all selected clients from the previous round and represent the model state that best fits the global requirements at the current stage. After receiving and parsing these global model parameters, the clients initialize all trainable components of their local models based on them, including the weights and biases of the neural networks. This operation gives all clients' local models a unified starting point, avoiding the dispersion of training directions due to differences in initial states, and creating conditions for the effective integration of subsequent local training results into the global model. The clients receive the global model parameters through secure transmission, ensuring that the parameters are not tampered with or leaked throughout the process, maintaining the integrity of the model. The initialized local model parameters are completely consistent with the global model parameters, laying the foundation for subsequent difference calculations.

[0048] The local training phase focuses on fully mining data features without disclosing private data. The client's local private dataset contains exclusive sample information and label data, which are the client's resources for participating in federated learning and will not be transmitted externally in any form throughout the process. During training, the client selects appropriate machine learning optimization algorithms based on the model type and dataset characteristics, commonly including stochastic gradient descent and adaptive moment estimation. The number of training epochs can be flexibly adjusted according to the dataset size and sample complexity. When the dataset is large, the number of epochs is appropriately increased to fully extract features, while when the dataset is small, the number of epochs is reduced to reduce computational overhead. To ensure training effectiveness, the client divides the local dataset into training and validation sets according to a preset ratio. The validation set is used to monitor model performance in real time and adjust the training strategy in a timely manner to avoid problems such as overfitting. The entire training process is completed in the client's local closed environment, and all data operations do not leave the local storage scope, eliminating the risk of data privacy leakage from the source. At the same time, through iterative optimization, the local model gradually adapts to the local data characteristics, forming a model state with unique contributions.

[0049] Model update generation is a precise extraction of local training results, forming information that can be used for global aggregation. After training, the client does not directly upload the complete local model, but instead calculates the difference between the locally trained model and the initial global model, thus forming the local model update for this round. This difference exists mainly in two forms. The first is the parameter difference, calculated by subtracting the initial global model parameters from the locally trained model parameters. Δθ=θ local -θ global in, θ local These are the model parameters trained locally on the client side. θ global The first is the global model parameters generated in the previous aggregation round. This difference directly reflects the adjustment magnitude of the model parameters during local training, clearly presenting the optimization changes brought about by local data. The second is the gradient update value, calculated through the backpropagation algorithm, i.e. in, L The preset loss function, ∇This represents gradient calculation, and the gradient value accurately indicates the optimal adjustment direction of model parameters, providing clear guidance for global model optimization. Both parameter differences and gradient update values ​​accurately characterize the contribution of local training to global model optimization; the more significant the contribution, the closer the adjustment direction and magnitude reflected in the update information are to the optimization needs of the global model. The two update forms can be flexibly selected for their applicable scenarios: gradient update values ​​are suitable for model training scenarios based on iterative optimization algorithms such as stochastic gradient descent, quickly transmitting the parameter adjustment direction; parameter differences are suitable for scenarios with smaller model parameter sizes where the magnitude of parameter changes needs to be directly reflected, balancing transmission efficiency and optimization accuracy. The generated local model updates are temporarily stored on the client's local machine, awaiting selection before being uploaded to the server, ensuring the security of the update information before transmission. This design preserves the value of local training while minimizing the risk of privacy leaks during data transmission, perfectly aligning with the federated learning philosophy of "data remains still, model moves."

[0050] According to an embodiment of the present invention, dimensionality reduction of model update through a common random projection matrix includes: performing linear projection processing on the local model update in the current round using a preset common random projection matrix, mapping the high-dimensional local model update vector to a low-dimensional space to obtain a low-dimensional model update vector; wherein, the common random projection matrix is ​​a fixed matrix pre-agreed upon by all participating clients and servers.

[0051] Specifically, the process of dimensionality reduction for model updates using a public random projection matrix is ​​a key step in balancing data privacy protection, computational efficiency improvement, and the effectiveness of subsequent features. The process is carried out in an orderly manner around three aspects: pre-consensus of the matrix, accurate execution of linear projection, and effective preservation of features after dimensionality reduction. This ensures that the dimensionality reduction operation does not leak privacy and provides reliable data support for subsequent weight calculation and verification.

[0052] Pre-agreed consensus on the matrix is ​​fundamental to ensuring consistency in the dimensionality reduction process across all participants. Before the federated learning system begins, all participating clients and servers jointly determine the dimensions and specific values ​​of the common random projection matrix through a distributed consensus mechanism. This unified standard remains unchanged throughout the entire training cycle. The distributed consensus mechanism can employ efficient algorithms suitable for federated learning scenarios, such as Raft, PBFT, or lightweight consensus protocols. The consensus process must ensure that all participants synchronously obtain the complete values ​​of the matrix. If some clients fail to synchronize due to network latency, the server can distribute a copy of the matrix as a fallback, ensuring global consistency of the consensus result. The design of the matrix dimension needs to comprehensively consider the original dimension of the high-dimensional model update vector, privacy protection requirements, and computational overhead. The dimension of the low-dimensional space is much lower than that of the original high-dimensional space, which can significantly reduce subsequent computational pressure and hide sensitive information in the original data through the characteristics of random projection. The randomness of the matrix ensures the unbiasedness of the projection process, avoiding the over-amplification or suppression of model update features of some clients due to matrix design bias. All participants use completely consistent matrices, ensuring that the dimensionality reduction operation of each client has the same rules and standards, providing a premise for the consistency of subsequent weight calculation, ZKP verification and other links, and avoiding verification conflicts or collusion vulnerabilities caused by differences in dimensionality reduction rules.

[0053] The execution process of linear projection emphasizes computational precision and local encapsulation, ensuring that the dimensionality reduction operation does not leak the privacy information of the original model update. After generating the local model update for this round, the client directly calls the locally stored public random projection matrix to perform linear projection operations on the high-dimensional local model update vector. The computation process is essentially a multiplication operation between a high-dimensional vector and a matrix. Indicates the first t Wheel client i The high-dimensional local model updates the vector. Φ Represents the common random projection matrix. Indicates the first t Wheel client i The low-dimensional model update vector, whose operational relationship can be expressed as follows: By linearly combining the row vectors of the matrix with the update vector of the high-dimensional model, the vectors in the original high-dimensional space are mapped to a preset low-dimensional space, ultimately resulting in a low-dimensional model update vector with significantly reduced dimensionality. The entire operation is completed independently on the client side, without requiring data interaction with other clients or servers. The original high-dimensional model update vector remains in a local, closed environment, ensuring no details are leaked due to the dimensionality reduction operation, perfectly meeting the data privacy protection requirements of federated learning. Simultaneously, the linear projection operation has low computational complexity, minimizing the additional computational burden on the client, thus balancing dimensionality reduction effectiveness with execution efficiency.

[0054] The dimensionality-reduced low-dimensional model update vector accurately preserves the key features of the original model update, providing a reliable data foundation for subsequent steps. The inherent characteristics of random projection techniques ensure that, despite the significant reduction in vector dimensionality, the relative structural relationships between the original high-dimensional vectors are effectively preserved, especially the angular information crucial for calculating the model quality factor. This means that the low-dimensional model update vector and the original high-dimensional vector exhibit a high degree of consistency in representing the direction of model optimization contributions. The cosine similarity calculated subsequently based on the low-dimensional vectors can accurately reflect the fit between the original model update and the global model optimization direction, preventing distortion in contribution evaluation due to dimensionality reduction. Furthermore, the generation of low-dimensional vectors creates favorable conditions for the efficient execution of ZKP. The lower dimensionality significantly reduces the size of the ZKP circuit, lowers the computational overhead of proof generation and verification, and improves the overall efficiency of the federated learning system, while still rigorously ensuring the authenticity and verifiability of subsequent weight calculations.

[0055] According to an embodiment of the present invention, a model parameter commitment is generated by combining a private random number and broadcast to all participating clients and servers, including: the client generates a random number as a private random number, performs a hash calculation on the low-dimensional model update vector and the private random number using a preset hash function to generate a model parameter commitment; confirms that all clients have completed commitment generation or reached a preset time threshold, and broadcasts the model parameter commitment to all participating clients and servers.

[0056] Specifically, combining the commitment of private random number generation model parameters with the broadcast process is a key step in locking in local training results, ensuring data authenticity, and protecting privacy. The process is carried out in an orderly manner around three aspects: secure generation of private random numbers, accurate execution of hash operations, and reasonable control of broadcast timing. Each step achieves a balance between verifiability and privacy through technical design.

[0057] The generation of private random numbers emphasizes both randomness and confidentiality, laying the foundation for the uniqueness and anti-forgery properties of the commitment. After completing the dimensionality reduction processing for local model updates, the client generates a unique random number using a locally secure pseudo-random number generator. This private random number is held solely by the client and used exclusively for... It means that among them i Represents the client identifier. tThis represents the current training epoch. The generation of private random numbers is completed entirely within the client's local, closed environment, without any data interaction with any external nodes, ensuring that they cannot be prematurely leaked or tampered with. Its function is to add a layer of random perturbation to the low-dimensional model update vector. Even if two clients have identical low-dimensional model update vectors, the difference in the private random numbers will generate drastically different model parameter commitments, effectively preventing malicious clients from forging commitments by imitating others' model parameters. The generated private random numbers will be securely stored by the client and used only for the calculation of the current model parameter commitment; they will not participate in any other calculations, further ensuring their confidentiality.

[0058] The hash operation focuses on merging the low-dimensional model update vector with private random numbers into an immutable commitment value, without revealing the original data information throughout the process. The client calls the preset Poseidon hash function, which is irreversible and collision-resistant, capable of converting inputs of arbitrary length into fixed-length hash values. This ensures that the original input cannot be deduced from the hash value, and that different inputs are unlikely to generate the same hash value. During the operation, the client will... t The low-dimensional model update vector of the wheel itself With private random numbers The data is concatenated byte by byte in a preset order to form complete input data. This data is then passed to the Poseidon hash function for calculation. The resulting fixed-length hash value is the model parameter commitment. This indicates that their operational relationship can be expressed as follows: Here, || represents a byte concatenation operation. This process achieves both locking the low-dimensional model update vector, ensuring that if the client modifies the model parameters after the commitment is generated, the recalculated commitment will be inconsistent with the previously generated commitment, which can be quickly identified; and strictly protecting the privacy of model parameters, as no information about the low-dimensional model update vector or private random numbers can be reconstructed from the commitment value alone, perfectly balancing the needs of verifiability and privacy protection.

[0059] The precise timing and execution of broadcasts ensured the fairness and completeness of commitments received by all participants. The client generates model parameters for commitments. Afterwards, each client can broadcast its commitment value at any time. However, to prevent collusion between the server and some clients, which could allow colluding clients to obtain the aggregated global model and forge their own model parameters and commitments to obtain high model quality scores, the server will not immediately broadcast its encrypted or masked model parameters. Instead, it will enter a waiting state, continuously monitoring the commitment generation status of other clients in the network. Only when all clients have broadcast commitments or a preset time threshold has been reached will the server upload its encrypted or masked model parameters. This design prevents malicious clients from taking advantage of premature commitment broadcasting by some clients, allowing them to analyze the broadcast commitments and adjust their own model parameters or commitment values, thus undermining the fairness of the selection process. The preset time threshold needs to be adapted to the federated learning network environment and the number of clients. A combination of a basic threshold and dynamic compensation can be used: the basic threshold is set as the average time taken for 95% of clients to complete commitment generation, and the dynamic compensation part is adjusted according to the client online rate in the current round. When the online rate is below 80%, the threshold is appropriately extended to ensure that most clients have sufficient time to complete commitment generation. Once the client confirms that all participating clients have completed the commitment generation, or the system's preset time threshold has been reached, it will immediately commit the model parameters it generated. The broadcast is sent to all participating clients and servers. The broadcast process is executed through a secure transmission protocol to ensure that the commitment value is not tampered with or stolen during transmission, and to ensure that each participant can obtain complete and authentic model parameter commitments from all clients, providing unified and reliable basic data support for subsequent ZKP verification, weight calculation, and other processes.

[0060] According to an embodiment of the present invention, the model quality factor is calculated based on the local model update after the previous round of projection and the global model after the previous round of projection, and further includes: calculating the cosine similarity between the local model update vector after the previous round of dimensionality reduction by the common random projection matrix and the vector of the global model after the previous round of dimensionality reduction by the same common random projection matrix, and using the cosine similarity as the model quality factor.

[0061] Specifically, the calculation of the model quality factor is a key step in accurately quantifying the client's local training contribution and ensuring the effectiveness of the selection mechanism. The process is carried out in an orderly manner around three aspects: consistency of data sources, rationality of similarity calculation, and directness of result application. Ultimately, the cosine similarity objectively reflects the degree to which the client's model update fits the global optimization, providing a quantitative basis for weight calculation.

[0062] The data preparation phase emphasizes the consistency and reliability of data sources to lay the foundation for the accuracy of subsequent calculations. The client needs to retrieve two sets of key low-dimensional vectors: one set is the local model update vector from the previous round, after dimensionality reduction using a common random projection matrix, and the other set is used for... It means that among themi Represents the client identifier. t-1 The first group represents the previous training epoch; the second group represents the vectors of the previous global model after dimensionality reduction using the same common random projection matrix. It means that among them Φ For the common random projection matrix, These are the parameters of the global model from the previous round. Both sets of vectors use the same dimensionality reduction rules to ensure identical dimensions and unified feature representation logic, avoiding distortion in similarity calculations due to differences in dimensionality reduction methods. The local low-dimensional model update vectors from the previous round have been locked through a previous commitment mechanism and cannot be tampered with. The global low-dimensional model vectors are broadcast by the server to all clients, ensuring that all participants receive completely identical global vectors, guaranteeing the fairness and objectivity of the computational foundation. The clients securely store these two sets of vectors locally. The entire computation process requires no additional external data acquisition and does not transmit any information, balancing computational efficiency and privacy protection.

[0063] The calculation of cosine similarity focuses on accurately reflecting the alignment of vector directions, aligning with the evaluation requirements of model update contributions. The logic of cosine similarity is to measure the consistency of direction between two vectors by calculating the cosine of the angle between them, rather than focusing on the magnitude of the vector magnitudes. This highly matches the evaluation requirements of model update contributions; the value of the client lies in providing adjustments consistent with the global optimization direction, rather than the magnitude of the adjustment. During calculation, the client first performs a dot product operation on the two sets of low-dimensional vectors. The result reflects the degree of positive correlation between the vectors; the larger the dot product value, the closer the directions of the two sets of vectors are. Subsequently, the magnitudes of the two sets of vectors are calculated separately. The magnitudes are used for normalization to eliminate the interference of vector magnitude differences on direction determination. Finally, the calculation is completed using a specific formula: dividing the dot product result by the product of the two magnitudes. The operational relationship can be expressed as follows: This computation process is executed entirely on the client side, with low computational complexity, which does not impose too much computational burden on the client. At the same time, it avoids the leakage of the original model parameters, perfectly aligning with the privacy protection concept of federated learning.

[0064] The calculation results are directly used as a model quality factor, achieving seamless integration between contribution evaluation and subsequent weight calculation. The cosine similarity value ranges between -1 and 1. In federated learning model update scenarios, since client-side local training aims to optimize the global model, similarity values ​​are typically between 0 and 1. A value closer to 1 indicates a greater alignment between the client's previous local model update direction and the global model's optimization direction, resulting in a more significant training contribution; a value closer to 0 indicates a lower degree of alignment between the update direction and the global optimization requirements, leading to a relatively limited contribution. Using this cosine similarity directly as a model quality factor eliminates the need for additional conversion or adjustment, simplifying the process and ensuring the intuitiveness of the evaluation results. When calculating client selection weights, this factor is combined with a long-term fairness factor, granting higher selection weights to clients with outstanding contributions. This incentivizes clients to provide high-quality model updates, accelerating the convergence of the global model.

[0065] According to an embodiment of the present invention, the long-term fairness factor is dynamically updated based on the client's historical participation, further comprising: dynamically determining the long-term fairness factor in each round of training, with the initial value set as the reciprocal of the total number of clients; updating the long-term fairness factor of the current round based on the long-term fairness factor of the previous round and the indicator function, wherein the update process adjusts the weight of historical information based on a smoothing factor, the smoothing factor being between 0 and 1; the indicator function is set according to the following rules: if a client is confirmed to have been selected to participate in training in the previous round, the indicator function is set to 0; if a client is confirmed not to have been selected to participate in training in the previous round, the indicator function is set to 1; if a client is confirmed not to have submitted model parameter commitments, not submitted weights, or failed the verification of the verifiable random function in the previous round, the indicator function is set to -1.

[0066] Specifically, the dynamic updating process of the long-term fairness factor is a design to ensure the fairness of client participation and punish violations. It is carried out in an orderly manner around three levels: initializing the fairness benchmark, recursive updating mechanism, and precise control of the indicator function. By smoothing the factor to balance historical participation and current status, it ensures that the factor not only reflects long-term fairness but also flexibly responds to changes in client behavior.

[0067] The initialization phase lays the foundation for equal participation from all clients, ensuring unbiased training in the early stages. In the first round of training after the federated learning system starts, the long-term fairness factor for each client is set to a uniform initial value, which is equal to the reciprocal of the total number of clients. Assuming there are N clients in the system, the initial long-term fairness factor for each client is... in, iThe superscript 1 represents the client identifier, indicating the first round of training. This setting ensures that all clients have completely equal initial selection weights at the beginning of training, preventing some clients from being at a disadvantage from the start due to initial differences. This fully guarantees fairness at the starting point of participation and lays a fair foundation for subsequent dynamic adjustments.

[0068] The update mechanism achieves dynamic iteration of factors through recursive operations, and the introduction of a smoothing factor ensures a reasonable balance between historical participation and the current state. The long-term fairness factor for each training round is calculated based on the factor results of the previous round, the indicator function value, and the smoothing factor; their operational relationship can be expressed as follows: in, For the first t Wheel client i Long-term equity factors For the first t-1 The client's long-term fairness factor, As a smoothing factor, For the first t-1 The value of the indicator function corresponding to this client is then determined. The smoothing factor ranges from 0 to 1, and its function is to adjust the weighting of historical information: when... When the value is close to 1, the influence of the previous round's factor is greater, meaning that the client's long-term participation has a more significant impact on the current weight, ensuring the continuity of fairness; when... When the value is close to 0, the influence of the indicator function becomes more prominent, and factor updates focus more on the client's specific performance in the previous round, enabling rapid response to changes in the client's participation status. This design ensures that the long-term fairness factor does not fluctuate drastically due to short-term behavior, while also reflecting the client's participation attitude and compliance status in a timely manner, achieving dynamic balance in fairness regulation.

[0069] The indicator function, acting as the state feedback kernel, directly influences the direction of factor updates through precise value selection, enabling differentiated control over different participation behaviors. The value of the indicator function is entirely determined by the client's participation status in the previous round, and falls into three categories: If the client was selected to participate in training in the previous round, it means it has already obtained a participation opportunity, and no additional weight increase is needed; the indicator function... When the value is 0, the factor update only retains the values ​​from the previous round of factors. The current level of fairness is maintained by a factor of 1; if a client was not selected to participate in training in the previous round, it indicates that they have insufficient opportunities to participate. To ensure long-term fairness, the indicator function is adjusted accordingly. The value is 1, through The item increases the current factor, increasing its probability of being selected in the future; if the client has violated the rules in the previous round, such as failing to submit model parameter commitments, failing to submit weights, or failing VRF validation, it indicates that they have not complied with the participation rules. To punish such behavior and maintain system order, the indicator function... The value is -1, through The option to lower the current factor reduces the chance of it being selected in the future. The three possible values ​​correspond to maintaining, increasing, and decreasing the adjustment direction, making the long-term fairness factor an effective tool to guide clients to participate in compliance and ensure a balanced participation opportunity. This avoids marginalizing marginal clients in the long term and effectively constrains violations, ensuring the long-term stable operation of the federated learning system.

[0070] Figure 3 This is a schematic diagram of verifying weights using a zero-knowledge proof system. According to an embodiment of the present invention, based on a zero-knowledge proof system, the verification weights are calculated according to preset rules based on committed model parameters, including: constructing an arithmetic circuit using a preset zero-knowledge proof system, with the previously broadcast model parameter commitments, the previously projected global model, the long-term fairness factor, and preset hyperparameters as public inputs, and the previously projected local model update vector and private random numbers as private inputs; all participants use a public verification key to run the verification algorithm of the zero-knowledge proof system with the public inputs to verify the validity of the zero-knowledge proof submitted by the client; if the verification result is invalid, the weights are determined not to be generated from the committed model parameters; if the verification result is valid, the weights are determined to be generated from the committed model parameters.

[0071] Specifically, such as Figure 3 As shown, the ZKP system's weight verification process is a key technical step in ensuring the legitimacy of weights and preventing collusive forgery. The process revolves around the orderly advancement of arithmetic circuit construction, precise division of public and private inputs, proof generation and distributed verification, and closed-loop result determination. Without disclosing the client's private data, the entire process of weight source verification is achieved, thus building a solid security barrier for subsequent sampling stages. Figure 3The system comprises three main modules: a public input module, which stores the previous round's model parameter commitments, the projected global model, the long-term fairness factor, and preset hyperparameters; a private input module, which stores the projected local model update vector and private random numbers; and a circuit operation and verification module, which performs arithmetic circuit operations and outputs verification results. These three modules achieve a synergy between privacy protection and legitimacy verification through the ZKP algorithm. The pre-built ZKP system can utilize efficient algorithms such as Groth16, and the adaptation logic must meet three requirements: first, the arithmetic circuit construction must be simple, adapting to the basic operational logic of weight generation and commitment verification; second, proof generation and verification must be time-efficient, matching the computational capacity limit of distributed clients; and third, the verification results must be unforgeable, ensuring that malicious clients cannot bypass weight legitimacy verification by forging proofs, ultimately achieving a balance between privacy protection and verification efficiency.

[0072] The construction of the arithmetic circuit is the foundation for implementing the verification logic. Essentially, it transforms the complete logic of weight generation into a mathematical operation circuit that can be executed by the ZKP system. The system pre-constructs a fixed-structure arithmetic circuit based on the weight calculation rules (i.e., the fusion logic of the model quality factor and the long-term fairness factor) and the generation rules of the model parameter commitment (i.e., the Poseidon hash operation logic). This circuit clearly defines the mapping relationship between input and output. The output is the weight submitted by the client for this round, while the input is divided into public and private inputs. The circuit's operation logic is completely consistent with the weight generation logic of all clients, ensuring a unified verification standard for all participants and avoiding verification result conflicts due to logical differences. This provides a unified operational benchmark for distributed verification.

[0073] Precise input segmentation ensures both privacy and security while providing sufficient public evidence for verification. Public input consists of common data accessible to all participating clients and servers, requiring no confidentiality and allowing for cross-verification. Specifically, it includes four categories: commitments to model parameters already broadcast in the previous round. This commitment refers to the content generated and broadcast by the client in the previous round based on the low-dimensional model update vector and private random numbers. Its purpose is to correlate weights with historical valid model updates; the global model after the previous round of projection. This vector represents the global model parameters after dimensionality reduction using the common random projection matrix, and is a key basis for calculating the model quality factor; the long-term fairness factor in the current round. This metric is dynamically updated based on historical client participation data, and the updates have been completed through publicly available logic and are verifiable; preset hyperparameters λ This parameter, used to adjust the fusion ratio of the quality factor and the fairness factor, is determined in advance by a consensus among all participants. Private input is privacy data held only by the client and not disclosed to external parties throughout the process. It includes two types of content: the local model update vector after the previous projection. This vector, associated with features of the client's local private dataset, directly reflects the training contribution; the private random numbers used in the previous round of model parameter generation commitment... This random number is a dedicated perturbation factor, designed to ensure the uniqueness of the commitment. The division into two types of inputs ensures that the publicly available evidence required for verification is sufficient and verifiable, while also strictly protecting client privacy, perfectly aligning with the dual requirements of zero-knowledge and verifiability in ZKP.

[0074] The proof generation and distributed verification process achieves legitimacy verification while protecting privacy, and is completed collaboratively by the client and all participants. The client, as the proof generator, will share its private input... and , and public input, i.e. , , and λ Substitute them into the preset arithmetic circuit, run the proof generation algorithm of the ZKP system, and after confirming the legality of its own weight generation logic through circuit operations, generate the corresponding ZKP proof. The generation process is executed entirely locally on the client side; private inputs are always stored locally and will not be leaked to any external nodes. Subsequently, the client will display the generated ZKP proof. The broadcast is sent to all participating clients and servers, allowing all participants to perform verification. All participants, acting as verifiers, do not need to obtain the client's private input; they only need to access the public verification key. The public input set and the ZKP proofs submitted by the client will be made public. The public verification key is input into the ZKP system's verification algorithm to perform a Verify operation, which takes the public verification key as a parameter. Commitment of model parameters already broadcast in the previous round The global model after the previous projection Long-term equity factors in the current round The preset hyperparameter λ and the ZKP proof submitted by the client. The verification algorithm's logic is to check whether the proof is consistent with the preset logic of the arithmetic circuit and the actual value of the public input. In other words, it determines whether there exists a valid private input that, when combined with the public input, can deduce the weights submitted by the client. Simultaneously, it ensures that the private input aligns with the broadcast model parameters. Exact match.

[0075] The closed-loop judgment process directly filters out legitimate clients, providing valid data for subsequent weight normalization and sampling. If the verification algorithm returns an invalid result, it indicates that the ZKP submitted by the client does not match the logic of the public input and arithmetic circuit. This suggests that the client's weights were not legitimately generated from the broadcast promised model parameters, and the client may be engaging in malicious behavior such as forging weights or tampering with model updates. Such clients will be marked as invalid nodes and excluded from this round of selection, and their submitted weights will be discarded. If the verification algorithm returns a valid result, it indicates that the client's weight generation logic is legitimate, and the weights are indeed derived from the legitimate model parameters of the previous round. The corresponding client will be recognized as a valid participating node, and its submitted weights will be confirmed as valid weights. This judgment process is executed independently by all participants, ensuring global consistency in the verification results. This avoids the impact of a single node's verification error on the overall process, technically preventing malicious clients from manipulating the selection results by forging weights and colluding, ensuring that all weights participating in subsequent sampling have legitimate sources and true value.

[0076] According to an embodiment of the present invention, generating effective normalized weights includes: collecting all effective weights verified by a zero-knowledge proof system; calculating the sum of all effective weights; and performing a ratio operation between the effective weight of a single client and the sum of weights to obtain the normalized weight of that client; the effective normalized weight satisfies that the sum of the normalized weights of all clients is 1, and the normalized weight of a single client is between 0 and 1.

[0077] Specifically, generating effective normalized weights involves converting legitimate effective weights into values ​​that conform to probability distribution rules, providing a standardized probability basis for subsequent weight-based client sampling, and ensuring the fairness and rationality of the selection process.

[0078] The first step is the collection of valid weights. The system aggregates all valid weights submitted by clients that have passed ZKP verification. These weights have all been determined to be generated based on legitimate model parameters and are free from forgery or tampering. During the collection process, all participants simultaneously confirm the attribution of valid weights, ensuring that each weight corresponds to a client that has been marked as a valid participating node, avoiding the mixing of invalid data, and laying a reliable foundation for subsequent calculations.

[0079] The system then proceeds to calculate the total weights. It sums all collected valid weights to obtain the total weights of all legitimate clients in this round. This sum converts individual weights into relative proportions, and its value is directly related to the relative magnitude of each client's normalized weight, ensuring that subsequent ratio calculations accurately reflect each client's relative priority in this round's selection.

[0080] Next, the normalized weights for individual clients are generated. For each verified client, the system divides its own effective weight by the sum of the weights calculated above; the result is the normalized weight for that client. If using... Indicates the first t Wheel client i If the effective weights are such that the sum of all effective weights can be expressed as: Where S represents the set of all valid clients verified by ZKP. This sum is the benchmark for converting individual weights into relative proportions. Its value is directly related to the relative size of the normalized weight of each client, ensuring that subsequent ratio calculations can accurately reflect the relative priority of each client in this round of selection.

[0081] Next, the normalized weights for individual clients are generated. For each verified client, the system divides its own effective weight by the sum of the weights calculated above. The result is the normalized weight for that client. Its mathematical expression is: in, Representing the t Wheel client i Normalized weights.

[0082] Assume there are three valid clients verified by ZKP, denoted as Client A, Client B, and Client C, with effective weights of 0.4, 0.3, and 0.3 respectively. First, calculate the sum of all effective weights: 0.4 + 0.3 + 0.3 = 1.0. Then, calculate the normalized weights for each client: Client A: 0.4 ÷ 1.0 = 0.4, Client B: 0.3 ÷ 1.0 = 0.3, and Client C: 0.3 ÷ 1.0 = 0.3. Finally, the sum of the normalized weights for the three clients is 0.4 + 0.3 + 0.3 = 1, and all are between 0 and 1, perfectly meeting the preset characteristics and can be directly used to construct the subsequent cumulative probability distribution.

[0083] The resulting effective normalized weights naturally satisfy two key characteristics: first, the sum of the normalized weights of all clients is 1, i.e. This characteristic allows these weights to directly correspond to probability distributions, and subsequent sampling can be based on these values ​​to allocate selection probabilities; secondly, the normalized weights for a single client range from 0 to 1, i.e., 0 < 1. The range <1 ensures that the probability of each client's selection will not be negative or exceed 1, thus avoiding invalid probability values ​​and ensuring that each legitimate client has the corresponding selection opportunity, further guaranteeing the scientific nature and fairness of the sampling process.

[0084] Figure 4 This is a flowchart illustrating the selection of clients using an unbiased sampling algorithm. For example... Figure 4 As shown, according to an embodiment of the present invention, an unbiased sampling algorithm is used to select clients, including: in step S510, generating random numbers based on a verifiable public random seed, and using the random numbers as the sampling basis; in step S520, constructing a cumulative probability distribution according to the effective normalized weights of the clients, wherein the cumulative probability interval corresponding to each client in the cumulative probability distribution is the sum of the effective normalized weights of all clients before the current client in the client list arranged in a preset order to the sum of the cumulative weights of the current client; in step S530, matching the random numbers with the intervals in the cumulative probability distribution, and the client corresponding to the cumulative probability interval in which the random number falls is the selected client; in step S540, repeating the above steps until a preset number of clients are selected, and each sampling process generates a new random number based on the updated public random seed.

[0085] Specifically, as shown in Figure 4, the process of selecting clients using an unbiased sampling algorithm relies on verifiable public random seeds and effective normalized weights. It achieves fair screening that matches the contribution level through four consecutive steps. The operational logic of each step is clear and fits the overall design goal, ensuring the unbiasedness and verifiability of the sampling results. Figure 4 The example annotation logic of the cumulative probability distribution is as follows: Assuming that the normalized weights of the three valid clients are 0.4, 0.3 and 0.3 respectively, the corresponding cumulative probability intervals are [0, 0.4), [0.4, 0.7) and [0.7, 1.0] respectively. When a random number falls into a certain interval, it corresponds to the client selected in that interval, which intuitively presents the mapping relationship between weight and sampling probability.

[0086] Step S510 involves generating a uniform and unbiased sampling criterion, and the operation revolves around a common random seed. The common random seed is generated collaboratively by multiple clients, and its calculation formula is as follows: in, Representing the t Public random seed for each round of training. H A pre-defined hash function for consensus among all participants. It is a set of VRF random outputs that has passed cross-validation by multiple clients. This represents the number of valid clients that have passed verification. This formula ensures that the seed is aggregated from valid data from multiple parties, possessing the characteristics of being tamper-proof and unpredictable. Based on this public random seed, all participants run a preset random number generation algorithm to generate random numbers between 0 and 1 as the sampling basis, which is quantitatively expressed as: in, For the first t Random numbers from round sampling, A pre-defined random number generation algorithm is used. Since all participants use the same algorithm and seed, the generated random numbers are completely consistent, thus avoiding bias in the sampling criteria from the source and ensuring global fairness in the sampling.

[0087] Step S520 focuses on constructing the cumulative probability distribution, realizing the transformation of effective normalized weights into matching intervals. The calculation of effective normalized weights follows specific rules, and the formula is: in, For the first t Wheel client i Effective normalized weights, For the first t Wheel client i Effective weights verified by ZKP Represents the set of all valid clients. This is the sum of the effective weights for all valid clients. This formula ensures that the sum of all effective normalized weights is 1, i.e. =1 Furthermore, the individual weights range from 0 to 1, providing a standardized basis for constructing the probability distribution. Subsequently, all participants are arranged in a preset order for valid clients, and a cumulative probability distribution is constructed based on the aforementioned normalized weights. For the sorted... k For each client, the formula for the cumulative probability interval is: The starting point of the interval is the previous one. k-1 The sum of the effective normalized weights of each client, ending at the sum of the cumulative effective normalized weights including the current client, with an interval length exactly equal to the length of the first client. k The effective normalized weights for each client achieve a precise mapping between weights and sampling probabilities.

[0088] Step S530 determines the selected client in a single sampling by objectively matching the random number with the cumulative probability interval. The matching logic is based on the inclusion relationship between the random number and the cumulative probability interval, and the quantification formula is as follows: If the first t Round-generated random numbers If the above conditions are met, then the sorted number is... kOne client is selected. Since the cumulative probability intervals of all clients completely cover the range from 0 to 1, and the intervals do not overlap, the random number will uniquely fall into a certain interval. The entire matching process requires no human intervention and is entirely determined by mathematical relationships, ensuring the unbiasedness and objectivity of the selection results. Based on the cumulative probability intervals [0, 0.4), [0.4, 0.7), and [0.7, 1.0] constructed using the above normalized weights, if the generated random number = 0.56 falls into the second interval, then the client with the corresponding normalized weight of 0.3 is selected, achieving a precise match between weight and sampling probability.

[0089] Step S540 completes the selection of a preset number of clients through iterative sampling, while maintaining the independence and randomness of each round of sampling. Before each repeated sampling, the original public random seed needs to be updated using the following formula: in, For the first m Seeds used in the second sampling. For the preset hash algorithm, The updated seed is used as the basis for generating new random numbers. This ensures that the random sources for each sample are independent, avoiding bias caused by correlations between multiple samples. This process is repeated until a preset number of clients are selected. This ensures the selection results match the client's contribution and further enhances the unpredictability and fairness of the results through independent sampling. During repeated sampling, deduplication rules can be flexibly configured to adapt to different scenarios: First, a rule prohibiting duplicate selection removes selected clients from the effective client set after each sampling. The sum of weights and cumulative probability distribution are recalculated based on the effective normalized weights of the remaining clients, ensuring that each client is selected only once in this round, adapting to scenarios requiring multiple clients to participate. Second, a rule allowing duplicate participation does not remove selected clients; the next sampling is conducted directly based on the original effective normalized weights and the updated common random seed, adapting to scenarios requiring multiple contributions from the same client to high-quality model updates. Both rules strictly adhere to the logic of unbiased sampling, achieving scenario adaptation only through adjustments to the effective client set.

[0090] This invention presents an anti-collusion federated learning client selection method. Through a closed-loop design encompassing public random seed generation, two-factor weight calculation, ZKP verification, effective weight normalization, and unbiased sampling, it constructs a secure, anti-collusion, quality- and fairness-balanced, and verifiable client selection system. From the distributed collaboration of seed generation to the dynamic adaptation of weight calculation and the unbiased controllability of the sampling process, each step is designed around the distributed characteristics and privacy protection requirements of federated learning. This eliminates the risks of malicious collusion and data tampering, ensures the contribution value of high-quality clients and the fair participation of marginal clients, and lowers the implementation threshold for different scenarios through standardized formulas and configurable rules. The entire method does not rely on special hardware or complex environments and can flexibly adapt to the federated learning training needs of multiple fields such as finance, healthcare, and the Internet of Things, providing reliable support for efficient iteration of the global model and long-term stable operation of the system.

[0091] The above embodiments are only used to illustrate the technical solutions of the present invention, and are not intended to limit them. Those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some of the technical features. These modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the spirit and scope of the technical solutions of the embodiments of the present invention.

Claims

1. A collusion-resistant and verifiable federated learning client selection method, characterized in that, include: Based on the current training round, a verifiable public random seed is generated collaboratively by the client. Complete the local model update on the client, reduce the dimensionality of the local model update on the client through a public random projection matrix, generate model parameter commitments by combining private random numbers, and broadcast the model parameter commitments to all participating clients and servers; The weight of a client's selection in this round is calculated based on the model quality factor and the long-term fairness factor; wherein, the model quality factor is calculated based on the local model update after the previous round of projection and the global model after the previous round of projection, and the long-term fairness factor is dynamically updated based on the client's historical participation. Based on a zero-knowledge proof system, the weights are verified to be calculated according to preset rules based on the committed model parameters; all valid weights are collected, normalized, and valid normalized weights are generated. Based on the public random seed and the effective normalized weight, an unbiased sampling algorithm is used to select clients.

2. The method according to claim 1, characterized in that, The method of generating a verifiable public random seed collaboratively via the client includes: The Trusted Center assigns a verifiable random function key pair to each client; At the start of the t-th training round, each client uses its own verifiable random function private key and the current training round t to calculate the verifiable random function's random output and the corresponding proof of validity. Each client collects the verifiable random function output and the corresponding validity proof data pair broadcast by all other clients, and runs the verifiable random function verification algorithm using the verifiable random function public key of the corresponding client to verify the authenticity of the verifiable random function output; All participating clients collect and aggregate all verified and verifiable random function outputs, and perform aggregation calculations on them using a hash function to generate a public random seed that is unpredictable and verifiable for this round.

3. The method according to claim 1, characterized in that, The process of completing the local model update on the client includes: The client initializes the local model based on the global model generated in the previous round of aggregation, performs model training using the local private dataset, and obtains the local model update for this round. The local model update is the gradient update value or parameter difference of the model parameters, which is used to characterize the contribution of local training to the global model optimization.

4. The method according to claim 1, characterized in that, The dimensionality reduction of the model update using a common random projection matrix includes: A preset public random projection matrix is ​​used to perform linear projection processing on the local model update in this round, mapping the high-dimensional local model update vector to a low-dimensional space to obtain the low-dimensional model update vector; The public random projection matrix is ​​a fixed matrix that is pre-agreed upon by all participating clients and servers.

5. The method according to claim 1, characterized in that, The process of combining private random numbers to generate model parameter commitments and broadcasting these commitments to all participating clients and servers includes: The client generates a random number as a private random number, and uses a preset hash function to perform hash calculation on the low-dimensional model update vector and the private random number to generate model parameter commitments; Once all clients have completed the commitment generation or reached the preset time threshold, the encrypted or masked model parameters are broadcast to all participating clients and servers.

6. The method according to claim 1, characterized in that, The model quality factor is calculated based on the local model update after the previous projection and the global model after the previous projection, and further includes: Calculate the cosine similarity between the local model update vector after dimensionality reduction by the common random projection matrix in the previous round and the vector of the global model after dimensionality reduction by the same common random projection matrix in the previous round, and use the cosine similarity as the model quality factor.

7. The method according to claim 1, characterized in that, The long-term fairness factor is dynamically updated based on the client's historical participation, and further includes: The long-term fairness factor is dynamically determined in each training round, and its initial value is set to the reciprocal of the total number of clients. The long-term fairness factor of the current round is updated based on the long-term fairness factor of the previous round and the indicator function. The update process adjusts the weight of historical information based on a smoothing factor, and the value of the smoothing factor is between 0 and 1. The indicator function takes the following values: if the client was selected to participate in training in the previous round, the indicator function takes the value of 0; if the client was not selected to participate in training in the previous round, the indicator function takes the value of 1; if the client did not submit a commitment to model parameters, did not submit weights, or failed the verification of the verifiable random function in the previous round, the indicator function takes the value of -1.

8. The method according to claim 1, characterized in that, The zero-knowledge proof-based system verifies that the weights are calculated based on committed model parameters according to preset rules, including: An arithmetic circuit is constructed using a pre-defined zero-knowledge proof system. The model parameter commitments broadcast in the previous round, the global model projected in the previous round, the long-term fairness factor, and the pre-defined hyperparameters are used as public inputs, while the local model update vector projected in the previous round and the private random number are used as private inputs. All participants use the public verification key to run the verification algorithm of the zero-knowledge proof system with the public input to verify the validity of the zero-knowledge proof submitted by the client; If the verification result is confirmed to be invalid, it is determined that the weights are not generated from the promised model parameters; If the verification result is confirmed to be valid, it is determined that the weights are generated from the committed model parameters.

9. The method according to claim 1, characterized in that, The generation of effective normalized weights includes: Collect all valid weights verified by the zero-knowledge proof system; calculate the sum of all valid weights; and perform a ratio operation between the valid weight of a single client and the sum of weights to obtain the normalized weight of that client. The effective normalized weights satisfy the condition that the sum of the normalized weights of all clients is 1, and the normalized weight of a single client is between 0 and 1.

10. The method according to claim 1, characterized in that, The method of selecting clients using an unbiased sampling algorithm includes: Random numbers are generated based on a verifiable public random seed, and these random numbers are used as the basis for sampling. A cumulative probability distribution is constructed based on the effective normalized weights of the clients. The cumulative probability interval for each client in the cumulative probability distribution is the sum of the effective normalized weights of all clients before the current client in the client list arranged in a preset order, up to the sum of the cumulative weights of the current client. The random number is matched with an interval in the cumulative probability distribution, and the client corresponding to the cumulative probability interval into which the random number falls is the selected client. Repeat the above steps until the preset number of clients are selected, and each sampling process generates a new random number based on the updated public random seed.

Images