Federated Learning Client Selection Method Based on Multi-Factor Dynamic Evaluation

Abstract

The present invention belongs to the technical field of federated learning, and relates to a method for selecting federated learning clients based on multi-factor dynamic evaluation. The model owner calculates the positive factors of clients in the current state, and then uses a participant selection algorithm based on the knapsack problem to select clients to participate in federated learning; the clients download the global model, use the local dataset for training, and send the trained local model to the blockchain; the clients calculate the cosine similarity between their local models and those of other clients, and calculate the mutual trust degree between clients based on the cosine similarity; the model owner reads the mutual trust degree between each client and calculates the group reputation of each client; the model owner evaluates the effort value of each client in this round of training according to the local model of the client. The present invention can realize the collaborative optimization of malicious node filtering, lazy client incentive and class imbalance mitigation from the source, and significantly improve the overall efficiency and security of the federated learning system.

Description

Technical Field

[0001] The present invention belongs to the technical field of federated learning, and relates to a method for selecting federated learning clients based on multi-factor dynamic evaluation. Background Art

[0002] Through a distributed training mechanism, federated learning technology realizes the mining of multi-party data value on the premise of protecting privacy, and has become a key technology for solving the problem of data islands. However, in actual deployment, the federated learning system faces the core challenge of uneven quality of client participation: malicious nodes may upload low-quality models to interfere with global training, and resource-constrained clients may have limited contributions due to insufficient data volume or computing power. Existing client selection mechanisms mostly rely on single-dimensional indicators (such as data volume or historical contributions), making it difficult to accurately screen high-value participants, seriously restricting the effectiveness of subsequent incentive mechanisms, and affecting the robustness and convergence efficiency of the global model.

[0003] Existing research generally focuses on the design of incentive mechanisms, but lacks in-depth optimization of the client screening link, resulting in the following problems: First, the client selection criteria are single, only relying on static reputation or short-term data volume, and failing to dynamically integrate multi-dimensional features such as model update quality (such as accuracy increment), group trust, and data utility, resulting in mis-screening of high-potential clients; Second, the impact of client heterogeneity on the screening results is ignored. For example, clients with a small data volume but a high accuracy increment may be excluded due to unbalanced index weights; Third, there is a lack of a dynamic identification mechanism for "free-riding" behavior and malicious nodes, and the mixing of low-quality participants will exacerbate resource waste and threaten system security.

[0004] For example, Patent Publication No. CN114841364A discloses a federated learning method that meets the needs of personalized local differential privacy. It does not consider the free-riding and malicious user situations among users in federated learning, only regards federated learning users as mutually trusted individuals, and fails to reasonably screen client participation. 2) The client selection evaluation criteria are single, only considering one factor of privacy budget, and ignoring the long-term or diverse behaviors of clients.

[0005] Existing federated learning solutions generally do not consider the cooperative game phenomenon among federated learning clients, and only consider their individual interactions with the model owner. In reality, clients may compete for greater rewards. For example, some clients may not be able to participate in federated learning due to small data volume and poor performance, or the rewards they obtain are far less than the training costs. Most federated learning pursuits higher accuracy simulations, so the rewards will increase significantly with the improvement of accuracy. Therefore, multiple clients can form a client group and participate in federated learning through the client group, thereby obtaining the possibility of participating in federated learning and higher rewards. Summary of the Invention

[0006] In view of the above problems, the present invention proposes a method for selecting federated learning clients based on multi-factor dynamic evaluation. By constructing a three-dimensional evaluation system of "effort value - group reputation - data utility", the ratio of the increment of model accuracy to the amount of data in a single round of client training is quantified as the effort value, combined with the long-term credibility as the group reputation, and the participant selection algorithm based on the knapsack problem is used to select clients to participate in federated learning, so as to maximize the comprehensive value of the participating clients on the premise of meeting the system resource constraints. It can provide a high-quality participant pool for the subsequent incentive mechanism, realize the collaborative optimization of malicious node filtering, lazy client incentive and class imbalance mitigation from the source, significantly improve the overall efficiency and security of the federated learning system, and provide reliable technical support for its large-scale application.

[0007] The present invention is realized through the following technical solutions. The method for selecting federated learning clients based on multi-factor dynamic evaluation includes the following steps:

[0008] Step 1, the blockchain initializes all model owners and clients, and defines the parameters of model owners and clients;

[0009] Step 2, the model owner publishes a federated learning task, including the initial global model, model requirements, and the amount of training data to be participated;

[0010] Step 3, the model owner calculates the positive factor of the client in the current state, and then uses the participant selection algorithm based on the knapsack problem to select clients to participate in federated learning;

[0011] Step 4, each client downloads the global model, uses the local dataset to perform distributed local model training, and sends the trained local model to the blockchain;

[0012] Step 5, the client calculates the cosine similarity between its own local model and the local models of other clients, and calculates the mutual trust degree between clients based on the cosine similarity; the model owner will read the mutual trust degree between each client and calculate the group reputation of each client;

[0013] Step 6, the model owner evaluates the effort value of the client in this round of training according to the local model of the client, as a parameter for calculating the positive factor in the next round of calculation;

[0014] Step 7, the model owner aggregates the local model parameters to update the global model;

[0015] Step 8, loop steps 3 to 7 until the global model reaches the accuracy required by the federated learning task.

[0016] Further preferably, the calculation method of the positive factor of the i-th client in the t-th round is as follows:

[0017] ;

[0018] Among them, and are the group reputation and effort value of the i-th client in the (t - 1)-th round respectively.

[0019] Further preferably, the participant selection algorithm based on the knapsack problem is as follows:

[0020] By traversing dp[i][w] in the current state, gradually save the optimal solution of the client that can select the maximum positive factor under the data volume limit, where dp[i][w] represents the maximum positive factor when storing the first i clients with the data volume limit of w, and the update method of dp[i][w] is:

[0021] dp[i][w]=max(dp[i - 1][w],dp[i - 1][w - d[i - 1]] + Post[i - 1]);

[0022] Among them, d[i - 1] represents the local data volume of the (i - 1)-th client, and Post[i - 1] represents the positive factor of the (i - 1)-th client.

[0023] Further preferably, the calculation method of the mutual trust degree is as follows:

[0024] ;

[0025] Among them, is the mutual trust degree between the i-th client and the j-th client in the t-th round, The value range of is [0, 1], is the mutual trust degree between the i-th client and the j-th client in the (t - 1)-th round, is the freshness index, and the value range is [0, 1].

[0026] Further preferably, the group reputation of each client is defined as the sum of the mutual trust degrees of the client in the client group, which is expressed as follows:

[0027] ;

[0028] Among them, is the group reputation of the i-th client at the t-th round, and the value range is [0, n], where n is the number of clients.

[0029] Further preferably, the effort value is set as the relationship between the model increment of the client's local model and the data volume, which is expressed as follows:

[0030] ;

[0031] Among them, is the effort value of the $i$-th client in the $t$-th round, is the local model accuracy of the $i$-th client in the $t$-th round, is the accuracy of the global model in the $(t - 1)$-th round, represents the data volume of the $i$-th client.

[0032] Technical effects of the present invention:

[0033] (1) Aiming at the drawback that existing solutions in the prior art mostly adopt static reputation mechanisms and it is difficult to identify malicious nodes with periodic disguises. The present invention designs a calculation method for client credibility based on group reputation, calculates the credibility of clients through the mutual trust among clients, and thus highlights the social attribute of federated learning in practical applications. By introducing a time decay factor and behavior consistency detection, malicious clients with long-term disguises can be effectively identified and filtered.

[0034] (2) Traditional methods only consider single indicators such as data volume or participation times. A positive factor for measuring the enthusiasm of clients is designed, comprehensively considering the ratio of the increment of model accuracy and the training data volume of clients, which can more accurately identify clients with strong training capabilities. This positive factor also considers the credibility of clients over a long period of time, fairly evaluates the previous effort values of clients, quantifies the improvement effect of clients on model accuracy under a unit data volume, and thus more fairly evaluates the enthusiasm of clients.

[0035] (3) A participant selection mechanism based on multiple factors is proposed. These multiple factors include the credibility and effort value in the positive factor, and also include the local data volume of clients when performing the algorithm. Based on this algorithm, a client selection scheme with the highest total positive factor can be screened out among the client group. Existing solutions mostly adopt methods with a single optimization goal such as the greedy algorithm. The present invention innovatively proposes a selection mechanism based on multiple factors, jointly optimizes group reputation, positive factor and data volume, and realizes the optimization of participant selection on the premise of meeting resource constraints. Description of the drawings

[0036] Figure 1 is the method flow chart of the present invention.

[0037] Figure 2 is the model accuracy curve of three different selection methods trained on the MNIST dataset.

[0038] Figure 3 is the model accuracy curve of three different selection methods trained on the CIFAR dataset. Detailed implementation manners

[0039] The present invention will be further elaborated in detail below in conjunction with embodiments.

[0040] Referring to Figure 1 , a federated learning client selection method based on multi-factor dynamic evaluation includes steps 1 - 8.

[0041] Step 1, the blockchain initializes all model owners and clients, and defines the parameters of model owners and clients.

[0042] A federated learning system consisting of 1 model owner m and n clients , where is the i-th client, i = {1, 2, …, n}. Under a fixed budget, after T rounds of synchronous federated learning training, the model accuracy of the model owner reaches the accuracy required by the federated learning task. The accuracy of the locally trained model is , and at the same time, the global model in the t-th round is defined as , and the accuracy of the global model aggregated from all local models is . .

[0043] Step 2, the model owner publishes a federated learning task, including the initial global model, model requirements, and the amount of training data to participate.

[0044] The model owner will give different initial global models according to different federated learning tasks, such as convolutional neural networks applied in the biomedical environment, recurrent neural networks for natural language processing, etc.

[0045] The federated learning task will publish model requirements. The final global model of federated learning is the result of the collaboration of multiple clients, and its design and implementation need to meet various requirements, including performance, privacy protection, communication efficiency, computational efficiency, fairness, security, scalability, and interpretability, etc. These requirements together determine the practicality and reliability of the federated learning model. In practical applications, it is necessary to balance these requirements according to specific scenarios and needs to design the optimal global model.

[0046] The amount of training data to participate is not a necessary condition for federated learning, but in most federated learning, the limited federated learning rewards cannot cover the endless amount of training data. Therefore, in order to maximize the utility of the federated learning system, there will be corresponding incentive mechanisms for federated learning, and the incentive mechanism will reasonably plan the reward method for participating in federated learning and the limit of the amount of training data to participate. Assuming that there is a limit on the amount of training data to participate in the federated learning task, the limit on the amount of training data to participate in the t-th round is .

[0047] Step 3: The model owner calculates the positive factor of the client in the current state, and then uses the participant selection algorithm based on the knapsack problem to select clients to participate in federated learning.

[0048] First, define the positive factor of the client. The positive factor represents the active situation of the client in federated learning. When considering this active situation, two factors will be taken into account: 1. The reliability of the client; 2. The relative contribution of the client in federated learning.

[0049] Define the reliability of the client as the group reputation of the client, and the relative contribution in federated learning is defined as the effort value of the client. The positive factor will consider both the group reputation and the effort value to make a fair evaluation of the client. The calculation method of the positive factor of the i-th client in the t-th round is as follows:

[0050] ;

[0051] where and represent the group reputation and effort value of the client in the (t - 1)-th round.

[0052] The effort value is calculated by the model owner, and the group reputation is calculated by the clients among themselves, which also avoids the "free-rider" behavior and "Byzantine" attacks of the clients. The "free-rider" behavior refers to the phenomenon in the federated learning system where some clients minimize their local computing input (such as reducing the number of training rounds, lowering data quality, or directly forwarding the global model) to save their own resources, while still being able to obtain the benefits of the aggregated global model. This phenomenon stems from the one-sidedness of the traditional incentive mechanism in evaluating the contribution degree, which only relies on the superficial contribution of model parameter updates and ignores the actual resource input. The "free-rider" behavior not only leads to the imbalance between the effort value and the return of the participants, but also may cause the problem of class imbalance in model training - when most clients choose to prioritize training the categories with less data volume, the recognition accuracy of the global model for minority categories drops significantly. The "Byzantine" attack is a means of attack in a distributed system where malicious nodes disrupt the security of the federated learning system by sending tampered model parameters (such as gradient reversal, weight noise injection, or label pollution).

[0053] Based on the above positive factor, a participant selection algorithm based on the knapsack problem is designed to screen out the optimal client selection scheme. Specifically, this algorithm can screen out the client with the highest positive factor from the federated learning clients when the amount of data participating in the training is determined. It will be executed in each round of federated learning to ensure that the optimal client selection scheme is used in each round. Among them, the positive factor of each client is regarded as the item value, the local data volume of the client is regarded as the knapsack capacity, and the data volume limit of the federated learning task is regarded as the knapsack capacity:

[0054] The process of the participant selection algorithm based on the knapsack problem is as follows:

[0055] By traversing dp[i][w] in the current state, gradually save the optimal solution of the client that can select the maximum positive factor under the data volume limit, where dp[i][w] represents the maximum positive factor when storing the first i clients under the data volume limit of w. The update method of dp[i][w] is:

[0056] dp[i][w]=max(dp[i - 1][w], dp[i - 1][w - d[i - 1]] + Post[i - 1]);

[0057] Among them, d[i - 1] represents the local data volume of the (i - 1)-th client, and Post[i - 1] represents the positive factor of the (i - 1)-th client.

[0058] According to the participant selection algorithm based on the knapsack problem, the model owner can select the client with the highest positive factor to participate in the plan under the participation data volume limit. The higher the positive factor, the greater the probability of making positive behaviors when participating in federated learning.

[0059] Step 4: Each client downloads the global model, uses the local dataset for distributed local model training, and sends the trained local model to the blockchain.

[0060] Each client uses the local dataset for training. The loss function of the training of the i-th client can be defined as:

[0061] ;

[0062] Among them, is the local dataset of the i-th client, represents the data volume of the i-th client, is the k-th data sample, is the label of the k-th data sample, k is the data sample number, is the local model of the i-th client in the t-th round of training, represents the loss function of the i-th client using the data sample in the local model .

[0063] In different federated learning, the loss function will be defined in different forms. For example, in federated learning using linear regression, the loss function can be defined as:

[0064] ;

[0065] wherein represents the transpose of the k-th data sample.

[0066] Meanwhile, the goal of federated learning is to optimize a model parameter by minimizing the loss functions of individual clients :

[0067] ;

[0068] wherein represents the global loss function of the federated learning model, which is obtained by weighting the loss functions of individual clients, represents the total amount of data participating in federated learning.

[0069] Step 5, the client calculates the local model similarity between itself and other clients, and calculates the mutual trust degree between clients based on the local model similarity; the model owner reads the mutual trust degree between each client and calculates the group reputation of each client.

[0070] When the client sends the local model to the blockchain, due to the immutability of the blockchain, each client can read the local models of other clients, and then evaluate the credibility of the clients. The specific evaluation process is as follows:

[0071] First, the cosine similarity between two local models is calculated pairwise between clients:

[0072] ;

[0073] wherein is the cosine similarity between the i-th client and the j-th client, is the local model of the i-th client in the t-th round of training, is the local model of the j-th client in the t-th round of training, is the norm of the local model of the i-th client in the t-th round of training, is the norm of the local model of the j-th client in the t-th round of training.

[0074] The mutual trust degree between clients is set as a dynamic value that changes over time to evaluate the long-term credibility of clients. The freshness index of the mutual trust degree is introduced , and the size of the freshness index represents the importance of the recent cosine similarity in the model:

[0075] ;

[0076] wherein, is the mutual trust degree between the i-th client and the j-th client in the t-th round, ranges from [0, 1], is the mutual trust degree between the i-th client and the j-th client in the (t - 1)-th round, is the freshness index, and its value range is [0, 1]; in the 0-th round (i.e., the initial value) = 1, , , , represents the mutual trust degree between the j-th client and the i-th client in the t-th round, represents the mutual trust degree of the i-th client itself in the t-th round;

[0077] The group reputation of each client is defined as the sum of the mutual trust degrees of the client in the client group, which is expressed as follows:

[0078] ;

[0079] where, is the group reputation of the i-th client at the t-th round, and its value range is [0, n], where n is the number of clients; by calculating the group reputation, when most clients perform positive behaviors, the clients with positive behaviors will receive reputation rewards, and the clients with negative behaviors will receive reputation punishments, reducing the risk of Byzantine attacks.

[0080] Step 6, The model owner evaluates the effort value of the client in this round of training based on the local model of the client, and uses it as a parameter for calculating the positive factor in the next round of calculation.

[0081] The model owner will evaluate the contributions of each client in federated learning. For fairness, the effort value of the client is defined. The effort value represents the contribution made by the client per unit of data volume. This metric can avoid biases caused by simply relying on the data volume or training effect. A client that efficiently utilizes data can obtain a higher contribution evaluation even if its data volume is small. Even if a client has a small data volume, but if its accuracy increment is significantly higher than that of other clients, it means that it has made a greater contribution to the global model through an efficient training strategy or stronger computing power under limited resources.

[0082] The effort value is set as the relationship between the model increment of the client's local model and the data volume, which is expressed as follows:

[0083] ;

[0084] where, is the effort value of the i-th client in the t-th round, is the accuracy of the local model of the i-th client in the t-th round, is the accuracy of the global model in the (t - 1)-th round, represents the data volume of the i-th client.

[0085] Step 7: The model owner aggregates the local model parameters to update the global model.

[0086] After receiving the local models from each client and calculating their effort values, the model owner aggregates the local models of all clients participating in the training. The aggregation method adopted in this embodiment is the federated averaging algorithm. The federated averaging algorithm (FedAvg) is a distributed model training method for federated learning, aiming to achieve multi-party collaborative modeling while protecting data privacy. Specifically, it is a global model parameter update method based on weighted averaging, and uploads the local model parameters to the central server for aggregation to update the global model.

[0087] The global model will be aggregated based on the size of the local data volume of each client. The specific aggregation method is as follows:

[0088] ;

[0089] where is the global model at the t-th round, is the local model of the j-th client at the t-th round, , J is the set of clients participating in the training in this round, is the data volume limit participating in the training at the t-th round, is the local dataset of the j-th client, is the data volume of the j-th client.

[0090] Step 8: Loop through Steps 3 to 7 until the global model reaches the accuracy required for the federated learning task.

[0091] Build a federated learning experimental environment using the Pytorch 1.2.0 framework, and select two benchmark datasets, MNIST and CIFAR-10, for algorithm verification. These two datasets are widely used to evaluate and verify the performance of the proposed federated learning participant selection mechanism. MNIST consists of handwritten digit images, including 60,000 grayscale training images of 28×28 pixels and 10,000 test images, covering the 0-9 handwritten digit classification task. The images have been grayscale processed and used as a basic test benchmark for computer vision. The CIFAR-10 dataset contains 50,000 RGB training images of 32×32 pixels and 10,000 test images, divided into 10 object recognition tasks. The data is divided into a multi-client simulation scenario, and each client holds a non-overlapping data subset.

[0092] To simulate the characteristics of non-independent and identically distributed (Non-IID) data in real scenarios, the experiment made a non-uniform allocation of the training data, enabling each client to obtain local datasets with different scales and data distributions. The model training adopted the Stochastic Gradient Descent (SGD) optimization algorithm, and the parameter update followed the Federated Averaging (FedAvg) framework. Specifically, each participating client performed SGD training based on local data, and the server aggregated the model parameters submitted by the clients through weighted averaging. This experimental setting can effectively evaluate the robustness of the proposed method under non-ideal data distribution conditions and provide a reliable benchmark test environment for subsequent performance comparisons.

[0093] To verify the effectiveness of the method of the present invention, the proportion of clients performing malicious tampering attacks and free-riding attacks was set to 0.1.

[0094] The system parameters are shown in Table 1:

[0095] Table 1 Experimental setting system parameters

[0096]

[0097] A comparative analysis of the model performance under three client selection methods was carried out. These include: (1) the federated learning client selection method based on multi-factor dynamic evaluation; (2) the federated learning client selection method based on the greedy algorithm, which preferentially selects the client with the highest positive factor; (3) the federated learning client selection method based on random selection, which randomly selects clients. Figure 2 and Figure 3 Shows the change trend of the model accuracy with the global training rounds under different methods. The experimental results show that as the global training rounds increase, the model accuracies of the three methods all increase with the global iteration, but the method proposed in the present invention shows significant advantages in both the final model performance and the convergence speed.

[0098] The performance advantages are mainly reflected in the following aspects: First, compared with the greedy algorithm that only considers a single index of the positive factor, the method of the present invention realizes a better client combination selection by comprehensively evaluating multiple factors such as the positive factor and data volume limit; Second, compared with the random selection scheme, the method of the present invention can make more effective use of the computing resources of high-quality clients. This improvement stems from the coordinated handling of two key challenges in federated learning: ensuring both the reliability of the participating clients and the sufficiency of the training data, thus achieving a better balance in model accuracy and training efficiency.

[0099] Although the preferred embodiments of the present application have been described, additional changes and modifications can be made to these embodiments by those skilled in the art once they learn the basic inventive concept. Therefore, the appended claims are intended to be construed to include the preferred embodiments as well as all changes and modifications that fall within the scope of the present application.

[0100] Obviously, those skilled in the art can make various changes and modifications to the present application without departing from the spirit and scope of the present application. Thus, if these modifications and variations of the present application fall within the scope of the claims of the present application and their equivalent technologies, the present application is also intended to include these modifications and variations.

Claims

1. A method for selecting a federated learning client based on multi-factor dynamic evaluation, characterized in that It includes the following steps: Step 1: The blockchain initializes all model owners and clients, and defines the parameters of the model owners and clients; Step 2: The model owner publishes a federated learning task, including the initial global model, model requirements, and the amount of training data to participate; Step 3: The model owner calculates the positive factor of the clients in the current state. The positive factor is the product of the group reputation and the effort value. The group reputation of each client is defined as the sum of the mutual trust degrees of the client in the client group, and the effort value is set as the relationship between the model increment of the client's local model and the amount of data; Then, the participant selection algorithm based on the knapsack problem is used to select clients to participate in federated learning; Step 4: Each client downloads the global model, uses the local dataset for distributed local model training, and sends the trained local model to the blockchain; Step 5: The client calculates the cosine similarity between its local model and the local models of other clients, and calculates the mutual trust degree between clients based on the cosine similarity; the model owner will read the mutual trust degrees between each client and calculate the group reputation of each client; Step 6: The model owner evaluates the effort value of the client in this round of training according to the client's local model, and uses it as a parameter for calculating the positive factor in the next round of calculation; Step 7: The model owner aggregates the local model parameters to update the global model; Step 8: Loop from Step 3 to Step 7 until the global model reaches the accuracy required by the federated learning task.

2. The method for selecting a federated learning client based on multi-factor dynamic evaluation according to claim 1, characterized in that the The calculation method of the positive factor of the i-th client in the t-th round is as follows: ； Among them, and are the group reputation and effort value of the $i$-th client in the $(t - 1)$-th round respectively.

3. The method for selecting a federated learning client based on multi-factor dynamic evaluation according to claim 1, wherein The process of the participant selection algorithm based on the knapsack problem is as follows: By traversing dp[i][w] in the current state, gradually save the optimal solution of the client that can select the maximum positive factor under the data volume limit, where dp[i][w] represents the maximum positive factor when storing the first i clients under the data volume limit of w. The update method of dp[i][w] is: dp[i][w]=max(dp[i - 1][w], dp[i - 1][w - d[i - 1]] + Post[i - 1]); Among them, d[i - 1] represents the local data volume of the (i - 1)-th client, and Post[i - 1] represents the positive factor of the (i - 1)-th client.

4. The method for selecting a federated learning client based on multi-factor dynamic evaluation according to claim 1, wherein The calculation method of the mutual trust degree is as follows: ； Among them, is the mutual trust degree between the $i$-th client and the $j$-th client in the $t$-th round, whose value range is $[0, 1]$, is the mutual trust degree between the $i$-th client and the $j$-th client in the $(t - 1)$-th round, is the freshness index, and its value range is $[0, 1]$.

5. The method for selecting a federated learning client based on multi-factor dynamic evaluation according to claim 4, wherein The group reputation is calculated according to the following formula: ； Among them, is the group reputation of the i-th client at the t-th round, and the value range is [0, n], where n is the number of clients.

6. The method for selecting a federated learning client based on multi-factor dynamic evaluation according to claim 1, characterized in that The effort value is calculated according to the following formula: ； Among them, is the effort value of the i-th client in the t-th round, is the local model accuracy of the i-th client in the t-th round, is the accuracy of the global model in the (t - 1)-th round, represents the data volume of the i-th client.

Images