Non-independent identically distributed data asynchronous federated learning method based on improved aggregation algorithm

Abstract

The invention discloses a non-independent identically distributed data asynchronous federal learning method based on an improved aggregation algorithm. The method comprises the steps that a server initializes a global model and issues the global model to all clients; and the client performs local training on the received global model by using local data, and uploads the model and model parameters to the server after training is completed. Then, the server adjusts a model lag degree based on a client data volume proportion, calculates model difference consistency, client historical contribution stability, old degree penalty of the client model and cosine similarity of the client model and the global model based on parameters of the client model and the current global model, and generates an asynchronous federal aggregation factor accordingly; and updating the global model parameters to generate a new global model. And finally, testing the global model by the server, and judging whether the learning process is stopped or not. According to the method, fair and effective model aggregation can be realized, and the model convergence stability and the final model detection precision are improved.

Description

TECHNICAL FIELD

[0001] The present application relates to the technical field of machine learning, in particular to an improved aggregation algorithm-based asynchronous federated learning method for non-independent and identically distributed data. BACKGROUND

[0002] With the wide popularity of terminal devices such as mobile Internet and Internet of Things, the speed of data generation continues to accelerate worldwide, and the amount of data is growing explosively. How to effectively extract and utilize key features from scattered data in each terminal has become an important challenge in the field of artificial intelligence and big data analysis. To cope with the problem of data silos and privacy protection, federated learning (FL) has emerged.

[0003] Federated learning allows multiple data holders to collaboratively train machine learning models without sharing raw data, thereby achieving the goal of "data not leaving the local, model sharing and collaboration". The typical federated learning framework adopts a synchronous aggregation method, that is, all clients complete local training and upload model parameters to the center server, and the server aggregates the model update parameters after receiving all the local model parameters of the clients to form a global model. Although synchronous federated learning can effectively protect data privacy, it has many limitations in actual deployment. For example, the computing and communication capabilities of different clients differ greatly, which may cause some devices to become a system bottleneck due to delay, offline or insufficient computing resources, reducing the overall training efficiency.

[0004] In recent years, asynchronous federated learning (AFL) has gradually become a research hotspot. Asynchronous federated learning allows clients to train and upload local model parameters independently without synchronization, and the center server can receive and aggregate updates from some clients at any time without waiting for all clients to complete training. This approach significantly improves the flexibility and training efficiency of the system, reduces the dependence on client computing resources and network status, and is more suitable for complex environments such as heterogeneous terminal devices and unstable networks in actual scenarios.

[0005] Since asynchronous federated learning introduces the concept of "staleness", which measures how many generations of the global model a local model has fallen behind since the time it was downloaded for training to the time its updated results are uploaded back to the server. "Staleness" reflects the degree to which this local model "lags" behind the current latest global model. Therefore, there are currently many studies that have proposed asynchronous federated learning solutions that combine the "staleness" parameter. For example, the FedAsync algorithm introduces a staleness decay factor, giving different aggregation weights to local models of different "staleness" to slow down the adverse effects of stale updates on the global model, thereby improving the convergence speed and accuracy under asynchronous aggregation. The FedBuff method uses a buffer pool mechanism, where the server caches multiple client updates before aggregation, and then aggregates them uniformly when certain conditions are met, thereby improving system throughput while reducing the interference of extreme stale models on the training process.

[0006] The above AFL scheme improves the training efficiency of the system, but at the cost of a significant reduction in the number of client update samples available for a single aggregation, and the presence of a model "lag" effect. In the case of extreme non-identically distributed client data, asynchronous federated learning faces two key problems:

[0007] 1) Aggregation direction instability. The limited information available from client data in a single aggregation and the highly heterogeneous data distribution of each client's local data make it difficult for the global model's aggregation update direction to converge stably, ultimately compromising the overall generalization performance of the model.

[0008] 2) Client lag effect intensifies. Due to differences in local data volume and computing power among clients, the number of uploads completed within a fixed time differs. Small clients with less data consume global training rounds quickly due to short local training times and frequent updates, leading to a lag penalty for large clients with more data, as their potential is not fully evaluated under the fixed round termination mechanism. Meanwhile, small clients with limited data categories update frequently, limiting the model's ability to learn more diverse category information from large clients when their updates dominate the global training rounds, affecting detection accuracy. SUMMARY

[0009] The present application aims to provide a non-identically distributed data asynchronous federated learning method based on an improved aggregation algorithm, which solves the problem of unfair punishment of other clients caused by frequent model update uploads by small clients in asynchronous federated learning and the problem of single composition of federated aggregation weights. This method can achieve fair and effective model aggregation, improve the stability of model convergence and the detection accuracy of the final model.

[0010] In order to achieve the above-mentioned purpose, the application provides an improved federated learning method based on an improved aggregation algorithm, comprising the following steps:

[0011] S1, selecting a server and a client to cooperatively perform asynchronous federated learning, the server and the client respectively having a local data set; the server initializes a global model , and sends the model parameters of the model to each client together with a client identifier , as the initial model parameters of the local model of the client;

[0012] S2, each client respectively trains a local model using the local data set , and after the client training is completed, uploads the model parameters of the local model , the data volume of the local data set , the client identifier and the global version number to the server;

[0013] S3, after the server receives the model uploaded by the client in step S2 and the corresponding parameters, the server calculates the asynchronous federated aggregation factor of the client, aggregates to generate a new global model , and tests the accuracy of the new global model using the local data set of the server;

[0014] S4, the server adjusts the global model version number to , and sends the new global model and the corresponding version number to the client participating in the federated learning;

[0015] S5, after the client receives the new model parameters, the client continues to update the local model, and repeats steps S2-S4 until the preset global termination round is reached; the server broadcasts a termination signal and a global model to all clients, and the asynchronous federated learning is completed.

[0016] The further preferred technical solution of the application is that in step S2, the client respectively trains a local model using the local data set ; specifically:

[0017] S21, the local private data set of the client is defined as:

[0018] ;

[0019] wherein, denotes a data set ; denotes the i-th data sample in the data set ; denotes the label of the i-th data sample in the data set ; denotes the length of the data set ;

[0020] S22, the client inputs the i-th data sample in the local data set to the local model , and calculates a label prediction value , denoted as:

[0021] ;

[0022] wherein, denotes the prediction output value of the i-th data of the client , denotes an activation function, and and denote the weight and bias term in the local model of the client , respectively;

[0023] The cross-entropy function with a regular term is used as the loss function, and the regular term is the L2 norm between the current model and the initial model weight. The label prediction loss value of the i-th data of the client is calculated, denoted as:

[0024] ;

[0025] wherein, denotes the prediction loss function of the i-th data in the local data set when the local model model parameter of the client is ; denotes the number of labels, is the initial model parameter at the beginning of the current training of the client, is a regularization coefficient; the function denotes the matching relationship between the true category of the sample and the target category . If , , =1; otherwise, ; ​​​The model parameters are: Input samples under the condition Classified The probability of; For regularization terms, Represents the square of the L2 norm;

[0026] S23, Client Calculate local dataset The gradient of the predicted loss function is used to adjust the gradient parameters of the samples in the opposite direction of the gradient; Client Local model parameters The iterative update formula is:

[0027] ;

[0028] in, Indicates the learning rate. Represents a given data sample Time loss function Regarding model parameters The gradient.

[0029] Preferably, in step S3, after the server receives the data uploaded by the client in step S2, it calculates the asynchronous federated aggregation factor of the client, updates the global model parameters, and aggregates to generate a new global model. Specifically, it includes:

[0030] S31. The server calculates the amount of client data currently received. The ratio of the client's total data volume to the number of updates of the current client model with a small amount of data to the total number of updates of the model are used to dynamically adjust the client's lag level.

[0031] S32. The server calculates the consistency of model update differences between the current global aggregation round and the previous round based on the currently received client model parameters and global model parameters.

[0032] S33. The server calculates the historical contribution stability of the client, the staleness penalty of the client model, and the cosine similarity between the client model and the global model based on the update magnitude of the currently received client-uploaded model parameters.

[0033] S34. The server calculates the asynchronous federated aggregation factor of the client based on various parameters, updates the global model parameters, and generates a new global model. The accuracy of the global model was tested using a server-side test dataset.

[0034] Preferably, in step S31, the server calculates the amount of client data currently received. The ratio of the total data amount of the client to the total data amount of all clients, and the ratio of the update times of the current small data amount client model to the total update times of the model, according to which the hysteresis degree of the client is dynamically adjusted; specifically:

[0035] S311, set the current client participating in the global model update as , calculate the basic hysteresis degree of the model , which is expressed as:

[0036] ;

[0037] wherein, , respectively represent the global model version number uploaded by the client in the global aggregation round , and the version number of the model used by the client for local training;

[0038] S312, the server dynamically calculates the ratio of the local data amount of the client to the average data amount of the clients, i.e., the local data amount ratio, as:

[0039] ;

[0040] wherein, is the data amount value of the client , and is the total number of clients;

[0041] S313, the small data amount client is defined as the client whose local data amount ratio is less than the data amount ratio threshold . If the local data amount ratio of the client satisfies , it is determined that the client is a small data amount client, and the client is added to the small data amount client set ;

[0042] The server calculates the update times ratio of the small data amount client in the current global aggregation round :

[0043] ;

[0044] wherein, represents the update times of the th client up to the current global aggregation round , represents the update times of the th client up to the current global aggregation round , represents the set of small data amount clients; represents the set of all clients; When it is an empty set, ;

[0045] S314, Computing Client Model lag for:

[0046] ;

[0047] in, The degree of basic lag; The threshold representing the degree of basic lag; Indicates the lag adjustment factor;

[0048] when When it is assumed that the number of updates from clients with small amounts of data is dominant, a lag adjustment factor is used to adjust the model lag of the clients currently participating in model updates; when At that time, it was assumed that the number of client updates was not dominant for small amounts of data, and the basic lag degree of the client model was used.

[0049] Preferably, in step S32, the server calculates the consistency of model update differences between the current global aggregation round and the previous round based on the currently received client model parameters and global model parameters; specifically:

[0050] S321. The server maintains the model difference vectors of the two most recent iterations for each client. For the client currently participating in global aggregation... The model difference vectors of its two most recent two models and , is represented as:

[0051] ;

[0052] in, Indicates the client The current uploaded model and the global model's first The difference vector of layer network parameters; Indicates the client The previous uploaded model and the global model's first The difference vector of layer network parameters; Indicates the client The first time the model was uploaded Layer network parameters, Represents the first global model Layer network parameters; Indicates the client The model parameter matrix, Indicates the number of layers in the model;

[0053] S322. The server calculates the client model difference vector for the current global aggregation round. Vector of difference from history The consistency is calculated using the following formula:

[0054] ;

[0055] in, This indicates the client Consistency between the differences in the client model parameter vectors uploaded in the two most recent two times; It represents a very small positive number to prevent division by zero errors; The L2 norm of a vector;

[0056] S323, Calculate the average variance consistency of the client model. The calculation formula is:

[0057] ;

[0058] in, This represents an interval transformation function used to convert differences into consistency. from Range mapping to Interval.

[0059] Preferably, in step S33, the server calculates the historical contribution stability of the client, the staleness penalty of the client model, and the cosine similarity between the client model and the global model based on the update magnitude of the currently received client-uploaded model parameters; specifically:

[0060] S331, On the server side, for each client Maintain a separate sliding window for client contribution history. This window only retains the most recent ones. Each update record is represented as:

[0061] ;

[0062] Where M is the size of the client's contribution history sliding window; Indicates the client A sliding window showing the history of contributions; Indicates the client No. The update magnitude of the model parameters uploaded each time they participate in global aggregation is calculated as follows:

[0063] ;

[0064] in, Indicates the client No. The first time the model parameters were uploaded Layer network parameter vector, Indicates the client No. The first upload of global model parameters Layer network parameter vector; This indicates that the local model and the global model are in the same position in the network parameter vector. The L1 norm of the difference between layers;

[0065] when When, modify The value is the current client The number of times the model is uploaded, i.e. ;when Stop modifying The value is set. The value is a constant;

[0066] Computing Client Average update magnitude of model parameters and variance and coefficient of variation They are respectively:

[0067] ;

[0068] ;

[0069] ;

[0070] Computing Client Historical contribution stability for:

[0071] ;

[0072] S332, Average Difference Consistency of Server-Client Integrated Model and historical contribution stability Computing Client Model parameter adjustment factor :

[0073] ;

[0074] in, These are hyperparameters used to adjust the client settings. Model discrepancy consistency affects model parameter adjustment factors The degree of influence, with a range of values. By changing Adjust the model's bias between consistency and stability;

[0075] Computing Client Antiquity penalty factor :

[0076] ;

[0077] ;

[0078] in, This is a hyperparameter representing the minimum compensation weight that the client can obtain, with a value range of [value range missing]. ; For the client The model parameters are based on the obsolescence penalty factor; The model's aging decay rate has a range of values. ;

[0079] S333, The server calculates the clients currently participating in the global model update. Cosine similarity between the model and the global model for:

[0080] ;

[0081] in, and For clients Model parameters and global model parameters; This represents a very small positive number to prevent division by zero errors.

[0082] Preferably, in step S34, the server calculates the asynchronous federated aggregation factor of the client by integrating various parameters, updates the global model parameters, and generates a new global model. And the accuracy of the global model is tested using the server test dataset; specifically:

[0083] S341. The server calculates the clients currently participating in the global model update. Basic aggregate weight :

[0084] ;

[0085] Then use cosine similarity Convert to similarity weight :

[0086] ;

[0087] Combined with basic aggregate weights and similarity weight Calculate the asynchronous federated aggregation factor for the client of the current upload model. for:

[0088] ;

[0089] in, Indicates the asynchronous federated aggregation factor; The average difference consistency is derived from equation (11); These are hyperparameters, representing the control client. The consistency between model differences and historical differences on asynchronous federated aggregation factors The proportion of contribution; Represents the symbolic function, retaining only The symbol; For the client Historical participation is calculated as follows:

[0090] ;

[0091] in, Indicates the client Total number of uploads and updates;

[0092] The server calculates the asynchronous federated aggregation factor. Performing global model aggregation is represented as:

[0093] ;

[0094] Based on this, a new global model is derived. The server will display the global model. Distributed to clients participating in this global aggregation As a local model for its next round of global aggregation training. .

[0095] In another aspect, the present invention provides a non-transitory computer-readable storage medium having computer instructions stored thereon, the computer instructions causing a computer to perform the above-described...

[0096] In another aspect, the present invention provides an electronic device, comprising: a processor, a communication interface, a memory, and a communication bus, wherein the processor, the communication interface, and the memory communicate with each other via the communication bus, and the processor calls logical instructions stored in the memory to execute the aforementioned...

[0097] In another aspect, the present invention provides a computer program product comprising a computer program stored on a non-transitory computer-readable storage medium, wherein when the computer program is executed by a processor, the computer performs the aforementioned...

[0098] Beneficial Effects: The asynchronous federated learning method for non-independent and identically distributed data based on the improved aggregation algorithm of this invention is suitable for scenarios where asynchronous federated learning is performed when the non-independent and identically distributed data situation is relatively serious. Based on the traditional asynchronous federated learning algorithm (FedAsync), this invention first calculates the basic lag degree and data ratio of the clients. When the update frequency of clients with small data volume is dominant, the lag degree of clients with large data volume is adjusted to increase the weight of clients with large data volume in the global model update, thereby enhancing the effectiveness of model aggregation and global generalization ability. Then, the consistency of client differences and the stability of historical contributions are calculated to calculate and adjust the staleness penalty. Next, the consistency between local updates and the global model is evaluated by calculating the cosine similarity between the client model and the global model. Finally, a new global model is aggregated, and the asynchronous federated aggregation factor is calculated by dynamically balancing the weight allocation of "data volume orientation" and "similarity orientation", thereby obtaining the updated global model.

[0099] The aggregation factor considers multiple factors, taking into account the asynchronous federated learning scenario where a single client triggers the server to execute a global model update. In this scenario, the server adjusts the model lag based on the proportion of client data, calculates the model difference consistency, client historical contribution stability, client model staleness penalty, and cosine similarity between the client model and the current global model parameters, generates an asynchronous federated aggregation factor, updates the global model parameters, and generates a new global model. This can achieve a smooth transition between traditional synchronous aggregation and asynchronous aggregation mechanisms, while emphasizing the consistency of the global model update direction, improving the generalization ability of the global model, and effectively alleviating the "version bloat" problem in asynchronous federated scenarios with unbalanced training data distribution. Attached Figure Description

[0100] Figure 1 This is a flowchart of the asynchronous federated learning method for non-independent, identically distributed data based on an improved aggregation algorithm, as described in this invention.

[0101] Figure 2 This is a framework diagram of the asynchronous federated learning system constructed in Embodiment 1 of the present invention;

[0102] Figure 3 This is a diagram showing the data distribution of each client in Embodiment 1 of the present invention;

[0103] Figure 4 This is a simulation result diagram of the accuracy dimension of the MNIST dataset in Embodiment 1 of the present invention under the data distribution Dir(0.1);

[0104] Figure 5 This is a simulation result diagram of the loss function dimension using the MNIST dataset in Embodiment 1 of the present invention with a data distribution Dir(0.1);

[0105] Figure 6 This is a simulation result diagram of the accuracy dimension using the Cifar-10 dataset in Embodiment 1 of the present invention with a data distribution Dir(0.5);

[0106] Figure 7 The figure shows the simulation results of the loss function dimension using the Cifar-10 dataset in Embodiment 1 of the present invention with a data distribution Dir(0.5);

[0107] Figure 8 This is a simulation result diagram of the accuracy dimension using the Cifar-10 dataset in Embodiment 1 of the present invention with a data distribution Dir(0.1);

[0108] Figure 9 This is a simulation result diagram of the loss function dimension using the Cifar-10 dataset in Embodiment 1 of the present invention with a data distribution Dir(0.1); Detailed Implementation

[0109] 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, embodiments of this invention, and should not be construed as limiting the 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. In the description of this invention, it should be understood that the terminology used is for descriptive purposes only and should not be construed as indicating or implying relative importance.

[0110] The following is combined with Figures 1-9 This invention describes an asynchronous federated learning method for non-independent, identically distributed data based on an improved aggregation algorithm.

[0111] Example 1: Consider an asynchronous federated learning scenario where a single client triggers the server to perform a global model update. The server adjusts the model lag based on the proportion of client data, calculates the model difference consistency, client historical contribution stability, client model staleness penalty, and cosine similarity between the client model and the current global model based on the parameters of the client model and the current global model, generates an asynchronous federated aggregation factor, updates the global model parameters, and generates a new global model.

[0112] First, define the system scenario, such as... Figure 2 As shown, this embodiment constructs a typical asynchronous federated learning system, which includes a server and There are 1 client, and each client maintains its own private dataset locally. These datasets may have different data distributions. The local data distribution of each client is as follows:Figure 3 As shown, both the client and server use the same convolutional neural network, i.e., a CNN model, which consists of four convolutional layers with a kernel size of 3 and two fully connected layers.

[0113] Based on this asynchronous federated learning system, this embodiment presents an asynchronous federated learning method for non-independent, identically distributed data based on an improved aggregation algorithm, such as... Figure 1 As shown, the specific steps include the following:

[0114] S1. Construction of asynchronous federated learning networks:

[0115] Select a server and Several clients collaborate in asynchronous federated learning, with both the server and clients possessing their own local datasets; the server initializes a global CNN model. and its model parameters Along with client identifier Distributed to each client as the client's local model Initial model parameters .

[0116] Server initializes global CNN model The specific description is as follows:

[0117] Set global rounds The server initializes an initial neural network model. This serves as the current global network model, and a unique identifier is assigned to each client. Upon receiving the identifier, the client stores it. In subsequent updates, when each client uploads their model, they also upload this identifier. The server maintains a sliding window of the client's contribution history and a client update difference matrix based on the client identifier.

[0118] S2. Client-side model training and parameter upload:

[0119] Each client uses a local dataset. Training a local model After the client-side training is complete, its local model is... Model parameters The amount of data in the local dataset Client identifier and global version number Uploaded to the server.

[0120] The clients use local datasets respectively Training a local model The specific process is as follows:

[0121] S21. Global model reception and local initialization:

[0122] Client Receive the global model sent by the server Use it as the current local model Using local private datasets Train the model and calculate the prediction loss value for the sample data labels; define the client. Local private dataset Represented as:

[0123] ;

[0124] in, Represents the dataset The Middle Data sample, Represents the dataset The Middle Labels for each data sample; Represents the dataset Length;

[0125] S22, Local Data Iterative Training and Loss Calculation:

[0126] Client Local dataset The Middle Data sample Input to local model In the process, the predicted label value is calculated. , is represented as:

[0127] ;

[0128] in, Indicates the client The The predicted output value of each data point. This represents the activation function. and They represent the client respectively. Weights and biases in the local model;

[0129] The cross-entropy function with regularization is used as the loss function, where the regularization term is the L2 norm between the weights of the current model and the initial model. The client-side loss function is calculated. No. The label prediction loss value for each data point is expressed as:

[0130] ;

[0131] in, Indicates the client The local model parameters are Local dataset The The prediction loss function for each data point; Indicates the number of tags. These are the initial model parameters for the client at the start of this training round. Regularization coefficient; function Indicates sample Real category With target category The matching relationship, if , =1; otherwise, ; The model parameters are: Input samples under the condition Classified The probability of; For regularization terms, Represents the square of the L2 norm;

[0132] S23, Gradient Calculation and Parameter Update:

[0133] Client Calculate local dataset The gradient of the predicted loss function is used to adjust the gradient parameters of the samples in the opposite direction of the gradient; Client Local model parameters The iterative update formula is:

[0134] ;

[0135] in, Indicates the learning rate. Represents a given data sample Time loss function Regarding model parameters The gradient.

[0136] S3, Server Aggregation:

[0137] After receiving the model and corresponding parameters uploaded by the client in step S2, the server calculates the asynchronous federated aggregation factor of the client and aggregates them to generate a new global model. And test the new global model using the server's local dataset; The accuracy rate.

[0138] The specific process by which the server calculates the asynchronous federated aggregation factor from the client and aggregates it to generate a new global model is as follows:

[0139] S31. The server calculates the proportion of local data on the client and dynamically adjusts the client's lag level:

[0140] After receiving model parameters and local data volume information uploaded by a client, the server updates the client data volume array and the model upload count array. The client data volume array contains each client identifier and its local data volume value; the upload count array contains each client identifier and its upload count.

[0141] S311. Let the client currently participating in the global model update be... Calculate the basic lag of its model. , is represented as:

[0142] ;

[0143] in, , They represent the client respectively. In the global aggregation round The global model version number uploaded, and the version number of the model used for local training on the client;

[0144] S312, Server Dynamic Computing Client The ratio of local data volume to the average client data volume, i.e., the local data volume percentage, is:

[0145] ;

[0146] in, For the client Data volume value, Total number of clients;

[0147] S313. Define the "small data volume client" as one whose local data volume ratio is less than the data volume ratio threshold. The client, if the client The proportion of local data meets the requirements It was determined to be a client with a small amount of data and was added to the set of clients with a small amount of data. middle;

[0148] The server calculates the current global aggregation round. Percentage of update frequency for clients with small data volumes:

[0149] ;

[0150] in, Indicates the current global aggregation round. No. The number of updates per client. Indicates the current global aggregation round. No. The number of updates per client. This represents a collection of clients with small amounts of data. Represents the set of all clients; specifies the set. When it is an empty set, ;

[0151] S314, Computing Client Model lag for:

[0152] ;

[0153] in, The degree of basic lag; The threshold representing the degree of basic lag; Indicates the lag adjustment factor;

[0154] when When it is assumed that the number of updates from clients with small amounts of data is dominant, a lag adjustment factor is used to adjust the model lag of the clients currently participating in model updates; when At that time, it was assumed that the number of client updates was not dominant for small amounts of data, and the basic lag degree of the client model was used.

[0155] S32. The server calculates the consistency of model update differences between the current global aggregation round and the previous round based on the currently received client model parameters and global model parameters:

[0156] S321. The server maintains the model difference vectors of the two most recent iterations for each client. For the client currently participating in global aggregation... The model difference vectors of its two most recent two models and , is represented as:

[0157] ;

[0158] in, Indicates the client The current uploaded model and the global model's first The difference vector of layer network parameters; Indicates the client The previous uploaded model and the global model's first The difference vector of layer network parameters; Indicates the client The first time the model was uploaded Layer network parameters, Represents the first global model Layer network parameters; Indicates the client The model parameter matrix, Indicates the number of layers in the model;

[0159] S322. The server calculates the client model difference vector for the current global aggregation round. Vector of difference from history The consistency is calculated using the following formula:

[0160] ;

[0161] in, This indicates the client Consistency between the differences in the client model parameter vectors uploaded in the two most recent two times; It represents a very small positive number to prevent division by zero errors; The L2 norm of a vector;

[0162] S323, Calculate the average variance consistency of the client model. The calculation formula is:

[0163] ;

[0164] in, This represents an interval transformation function used to convert differences into consistency. from Range mapping to Interval.

[0165] S33. The server calculates the historical contribution stability of the client, the staleness penalty of the client model, and the cosine similarity between the client model and the global model based on the update magnitude of the currently received client-uploaded model parameters:

[0166] S331, On the server side, for each client Maintain a separate sliding window for client contribution history. This window only retains the most recent ones. Each update record is represented as:

[0167] ;

[0168] Where M is the size of the client's contribution history sliding window; Indicates the client A sliding window showing the history of contributions; Indicates the client No. The update magnitude of the model parameters uploaded each time they participate in global aggregation is calculated as follows:

[0169] ;

[0170] in, Indicates the client No. The first time the model parameters were uploaded Layer network parameter vector, Indicates the client No. The first upload of global model parameters Layer network parameter vector; This indicates that the local model and the global model are in the same position in the network parameter vector. The L1 norm of the difference between layers;

[0171] when When, modify The value is the current client The number of times the model is uploaded, i.e. ;when Stop modifying The value is set. The value is a constant;

[0172] Computing Client Average update magnitude of model parameters and variance and coefficient of variation They are respectively:

[0173] ;

[0174] ;

[0175] ;

[0176] Computing Client Historical contribution stability for:

[0177] ;

[0178] S332, Average Difference Consistency of Server-Client Integrated Model and historical contribution stability Computing Client Model parameter adjustment factor :

[0179] ;

[0180] in, These are hyperparameters used to adjust the client settings. Model discrepancy consistency affects model parameter adjustment factors The degree of influence, with a range of values. By changing Adjust the model's bias between consistency and stability;

[0181] Computing Client Antiquity penalty factor :

[0182] ;

[0183] ;

[0184] in, This is a hyperparameter representing the minimum compensation weight that the client can obtain, with a value range of [value range missing]. ; For the client The model parameters are based on the obsolescence penalty factor; The model's aging decay rate has a range of values. ;

[0185] S333, The server calculates the clients currently participating in the global model update. Cosine similarity between the model and the global model for:

[0186] ;

[0187] in, and For clients Model parameters and global model parameters; This represents a very small positive number to prevent division by zero errors.

[0188] S34. The server calculates the asynchronous federated aggregation factor of the client based on various parameters, updates the global model parameters, and generates a new global model. And use the server test dataset to test the accuracy of the global model:

[0189] S341. The server calculates the clients currently participating in the global model update. Basic aggregate weight :

[0190] ;

[0191] Then use cosine similarity Convert to similarity weight :

[0192] ;

[0193] Combined with basic aggregate weights and similarity weight Calculate the asynchronous federated aggregation factor for the client of the current upload model. for:

[0194] ;

[0195] in, Indicates the asynchronous federated aggregation factor; The average difference consistency is derived from equation (11); These are hyperparameters, representing the control client. The consistency between model differences and historical differences on asynchronous federated aggregation factors The proportion of contribution; Represents the symbolic function, retaining only The symbol; For the client Historical participation is calculated as follows:

[0196] ;

[0197] in, Indicates the client Total number of uploads and updates;

[0198] The server calculates the asynchronous federated aggregation factor. Performing global model aggregation is represented as:

[0199] ;

[0200] Based on this, a new global model is derived. The server will display the global model. Distributed to clients participating in this global aggregation As a local model for its next round of global aggregation training. .

[0201] S4. Global model distribution and client-side local model update:

[0202] The server adjusts the global model version number by incrementing it by one and distributes the new global model and its version number to the clients participating in this federated learning process. Upon receiving the new model parameters, the clients continue to update their local models and repeat steps S2-S4 until the preset global termination round is reached.

[0203] After each round of global aggregation, the server uses the server test set to test the accuracy of the global model and checks whether the preset global termination round has been reached. If the termination round is reached, the server broadcasts a termination signal and the global model to all clients, and asynchronous federated learning ends. If the termination round is not reached, federated learning continues.

[0204] The following simulations using PyTorch demonstrate the proposed solution, comparing its performance with similar algorithms such as FedAsync and FedBuff. Simulations were performed on the Cifar-10 and MNIST datasets under two non-independent and identically distributed (i.i.d.) Dirichlet (0.1) and Dirichlet (0.5) datasets, focusing on accuracy and loss function. The results are shown below. Figure 4 , Figure 5 , Figure 6 , Figure 7 , Figure 8 , Figure 9 As shown.

[0205] The simulation parameters are set as follows:

[0206] Model: The network model is a four-layer convolutional neural network with 3072 inputs and 5 outputs;

[0207] Clients: Total number of clients K=10;

[0208] Training parameters: global_epochs=100, local_epochs=5, batch_size=16, learning ratelr=0.01;

[0209] Training data: Cifar-10 dataset, MNIST dataset, data distributions Dir(0.5) and Dir(0.1).

[0210] from Figure 4 , Figure 5 It can be seen that when using the MNIST dataset, the improved algorithm in this scheme converges faster than the other two algorithms, with a convergence time superior to the traditional FedAsync algorithm and the improved FedBuff algorithm. The improved algorithm's loss function descent speed and convergence speed are faster than the other two algorithms, proving that the design of the improved algorithm makes the gradient direction clearer in the early stages of the model and the data gradient direction more stable.

[0211] from Figure 6 , Figure 7 , Figure 8 , Figure 9 It can be seen that when using the more complex Cifar-10 dataset, the local model's low complexity due to its lightweight design leads to a decrease in its ability to recognize complex datasets. When all three algorithms use the same local model, differing only in the degree of data non-independence and identical distribution... Figure 6Under the Dir(0.5) distribution, the improved algorithm used in this scheme outperforms the FedAsync algorithm and the improved FedBuff algorithm in terms of model convergence speed and post-convergence accuracy. Figure 7 The loss function in the improved algorithm indicates that, under the same learning rate, the loss function of the improved algorithm decreases and converges faster than that of the FedAsync and FedBuff algorithms, suggesting that the model update direction of the improved algorithm is more stable. Figure 8 , Figure 9 Under the Dir(0.1) distribution, there is a severe case of data non-independent and identically distributed distribution, where the local data distribution of each client is as follows: Figure 3 As shown, in this case, all three algorithms experienced a decrease in test accuracy due to the non-independent and identically distributed data. However, the improved algorithm achieved higher test accuracy at model convergence than the FedAsync and FedBuff algorithms, and compared to... Figure 6 In the case of Dir(0.5), the improved algorithm adopted in this scheme achieves an accuracy close to that of Dir(0.5) with only one client model collected each time, which is better than the FedAsync algorithm and the FedBuff algorithm. Figure 9 The improved algorithm of this scheme has a slightly slower convergence speed than the FedBuff algorithm at the beginning because FedBuff collects data from 5 clients at the same time and then performs another aggregation. During one aggregation, it collects data from 4 more clients than the improved scheme. However, with Dir(0.1), the improved scheme can eventually converge as training progresses.

[0212] Therefore, it can be seen that the asynchronous federated learning method for non-independent and identically distributed data based on the improved aggregation algorithm proposed in this invention is suitable for asynchronous federated learning in scenarios where the non-independent and identically distributed data is severe. This scheme is built upon the traditional asynchronous federated averaging algorithm (FedAsync). First, based on the amount of local data uploaded by the client, it determines whether the number of updates from clients with small amounts of data dominates the current total updates, and then adjusts the lag for clients with large amounts of data. Next, it calculates model difference consistency, historical contribution stability, client obsolescence penalty, and the cosine similarity between the client and the global model. Finally, based on the above parameters, it calculates the asynchronous federated aggregation weights and performs asynchronous federated aggregation to obtain a new global model. This method can ensure model convergence even in scenarios with severe non-independent and identically distributed data, and effectively weakens abnormal or deviating client updates from the global update direction, preventing noise or extreme values ​​from interfering with the global model.

[0213] Example 2: This example provides a non-transitory computer-readable storage medium storing computer instructions that cause a computer to execute an asynchronous federated learning method for non-independent, identically distributed data based on an improved aggregation algorithm. The method includes the following steps:

[0214] S1. Select a server and Several clients collaborate in asynchronous federated learning, with both the server and clients possessing their own local datasets; the server initializes a global model. and its model parameters Along with client identifier Distributed to each client as the client's local model Initial model parameters ;

[0215] S2, Each client uses its own local dataset. Training a local model After the client-side training is complete, its local model is... Model parameters The amount of data in the local dataset Client identifier and global version number Uploaded to the server;

[0216] S3. After receiving the model and corresponding parameters uploaded by the client in step S2, the server calculates the asynchronous federated aggregation factor of the client and aggregates them to generate a new global model. And test the new global model using the server's local dataset; The accuracy rate;

[0217] S4. Server adjusts global model version number to... The new global model and its corresponding version number will be distributed to the clients participating in this federated learning process.

[0218] S5. After receiving the new model parameters, the client continues to update the local model and repeats steps S2-S4 until the preset global termination round is reached; the server broadcasts the termination signal and the global model to all clients, and the asynchronous federated learning ends.

[0219] Example 3: This example provides an electronic device that may include a processor, a communication interface, a memory, and a communication bus. The processor, communication interface, and memory communicate with each other via the communication bus. The processor can invoke logical instructions from the memory to execute an asynchronous federated learning method for non-independent, identically distributed data based on an improved aggregation algorithm. This method includes the following steps:

[0220] S1. Select a server and Several clients collaborate in asynchronous federated learning, with both the server and clients possessing their own local datasets; the server initializes a global model. and its model parameters Along with client identifier Distributed to each client as the client's local model Initial model parameters ;

[0221] S2, Each client uses its own local dataset. Training a local model After the client-side training is complete, its local model is... Model parameters The amount of data in the local dataset Client identifier and global version number Uploaded to the server;

[0222] S3. After receiving the model and corresponding parameters uploaded by the client in step S2, the server calculates the asynchronous federated aggregation factor of the client and aggregates them to generate a new global model. And test the new global model using the server's local dataset; The accuracy rate;

[0223] S4. Server adjusts global model version number to... The new global model and its corresponding version number will be distributed to the clients participating in this federated learning process.

[0224] S5. After receiving the new model parameters, the client continues to update the local model and repeats steps S2-S4 until the preset global termination round is reached; the server broadcasts the termination signal and the global model to all clients, and the asynchronous federated learning ends.

[0225] Furthermore, the logical instructions in the aforementioned memory can be implemented as software functional units and sold or used as independent products, and can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of the present invention, or the part that contributes to the prior art, or a part of the technical solution, can be embodied in the form of a software product. This computer software product is stored in a storage medium and includes several instructions to cause a computer device (which may be a personal computer, server, or network device, etc.) to execute all or part of the steps of the methods described in the various embodiments of the present invention. The aforementioned storage medium includes various media capable of storing program code, such as USB flash drives, portable hard drives, read-only memory (ROM), random access memory (RAM), magnetic disks, or optical disks.

[0226] Example 4: This example provides a computer program product, which includes a computer program that can be stored on a non-transitory computer-readable storage medium. When the computer program is executed by a processor, the computer can perform an asynchronous federated learning method for non-independent and identically distributed data based on an improved aggregation algorithm. The method includes the following steps:

[0227] S1. Select a server and Several clients collaborate in asynchronous federated learning, with both the server and clients possessing their own local datasets; the server initializes a global model. and its model parameters Along with client identifier Distributed to each client as the client's local model Initial model parameters ;

[0228] S2, Each client uses its own local dataset. Training a local model After the client-side training is complete, its local model is... Model parameters The amount of data in the local dataset Client identifier and global version number Uploaded to the server;

[0229] S3. After receiving the model and corresponding parameters uploaded by the client in step S2, the server calculates the asynchronous federated aggregation factor of the client and aggregates them to generate a new global model. And test the new global model using the server's local dataset; The accuracy rate;

[0230] S4. Server adjusts global model version number to... The new global model and its corresponding version number will be distributed to the clients participating in this federated learning process.

[0231] S5. After receiving the new model parameters, the client continues to update the local model and repeats steps S2-S4 until the preset global termination round is reached; the server broadcasts the termination signal and the global model to all clients, and the asynchronous federated learning ends.

[0232] The device embodiments described above are merely illustrative. The units described as separate components may or may not be physically separate. The components shown as units may or may not be physical units; that is, they may be located in one place or distributed across multiple network units. Some or all of the modules can be selected to achieve the purpose of this embodiment according to actual needs. Those skilled in the art can understand and implement this without any creative effort.

[0233] Through the above description of the embodiments, those skilled in the art can clearly understand that each embodiment can be implemented by means of software plus necessary general-purpose hardware platforms, and of course, it can also be implemented by hardware. Based on this understanding, the above technical solutions, in essence or the part that contributes to the prior art, can be embodied in the form of a software product. This computer software product can be stored in a computer-readable storage medium, such as ROM / RAM, magnetic disk, optical disk, etc., and includes several instructions to cause a computer device (which may be a personal computer, server, or network device, etc.) to execute the methods described in the various embodiments or some parts of the embodiments.

[0234] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention, and not to limit them; although the present invention has been described in detail with reference to the foregoing embodiments, 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; and 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. An asynchronous federated learning method for non-independent and identically distributed data based on an improved aggregation algorithm, characterized in that, Includes the following steps: S1. Select a server and Several clients collaborate in asynchronous federated learning, with both the server and clients possessing their own local datasets; the server initializes a global model. and its model parameters Along with client identifier Distributed to each client as the client's local model Initial model parameters ; S2, Each client uses its own local dataset. Training a local model After the client-side training is complete, its local model is... Model parameters The amount of data in the local dataset Client identifier and global version number Uploaded to the server; S3. After receiving the model and corresponding parameters uploaded by the client in step S2, the server calculates the asynchronous federated aggregation factor of the client and aggregates them to generate a new global model. ; And test the new global model using the server's local dataset. The accuracy rate; S4. Server adjusts global model version number to... The new global model and its corresponding version number will be distributed to the clients participating in this federated learning process. S5. After receiving the new model parameters, the client continues to update the local model and repeats steps S2-S4 until the preset global termination round is reached; the server broadcasts the termination signal and the global model to all clients, and the asynchronous federated learning ends.

2. The asynchronous federated learning method for non-independent and identically distributed data based on an improved aggregation algorithm according to claim 1, characterized in that, In step S2, the client uses the local dataset respectively. Training a local model ; Specifically: S21. Define the client Local private dataset Represented as: ； in, Represents the dataset The Middle Data sample, Represents the dataset The Middle Labels for each data sample; Represents the dataset Length; S22, Client Local dataset The Middle Data sample Input to local model In the process, the predicted label value is calculated. , is represented as: ； in, Indicates client The The predicted output value of each data point. This represents the activation function. and They represent the client respectively. Weights and biases in the local model; The cross-entropy function with regularization is used as the loss function, where the regularization term is the L2 norm between the weights of the current model and the initial model. The client-side loss function is calculated. No. The label prediction loss value for each data point is expressed as: ； in, Indicates client The local model parameters are Local dataset The The prediction loss function for each data point; Indicates the number of tags. These are the initial model parameters for the client at the start of this training round. Regularization coefficient; function Indicates sample Real category With target category The matching relationship, if , =1; otherwise, ; The model parameters are: Input samples under the condition Classified as The probability of; For regularization terms, Represents the square of the L2 norm; S23, Client Calculate local dataset The gradient of the predicted loss function is used to adjust the gradient parameters of the samples in the opposite direction of the gradient; Client Local model parameters The iterative update formula is: ； in, Indicates the learning rate. Represents a given data sample Time loss function Regarding model parameters The gradient.

3. The asynchronous federated learning method for non-independent and identically distributed data based on an improved aggregation algorithm according to claim 1, characterized in that, In step S3, after the server receives the data uploaded by the client in step S2, it calculates the asynchronous federated aggregation factor of the client, updates the global model parameters, and aggregates to generate a new global model. ; Specifically, it includes: S31. The server calculates the amount of client data currently received. The ratio of the client's total data volume to the number of updates of the current client model with a small amount of data to the total number of updates of the model are used to dynamically adjust the client's lag level. S32. The server calculates the consistency of model update differences between the current global aggregation round and the previous round based on the currently received client model parameters and global model parameters. S33. The server calculates the historical contribution stability of the client, the staleness penalty of the client model, and the cosine similarity between the client model and the global model based on the update magnitude of the currently received client-uploaded model parameters. S34. The server calculates the asynchronous federated aggregation factor of the client based on various parameters, updates the global model parameters, and generates a new global model. The accuracy of the global model was tested using a server-side test dataset.

4. The asynchronous federated learning method for non-independent and identically distributed data based on the improved aggregation algorithm according to claim 3, characterized in that, In step S31, the server calculates the amount of client data currently received. The ratio of the client's total data volume to the number of updates, and the ratio of the number of updates to the total number of model updates for the current client with a small amount of data, are used to dynamically adjust the client's lag level; specifically: S311. Let the client currently participating in the global model update be... Calculate the basic lag of its model. , is represented as: ； in, , They represent the client respectively. In the global aggregation round The global model version number uploaded, and the version number of the model used for local training on the client; S312, Server Dynamic Computing Client The ratio of local data volume to the average client data volume, i.e., the local data volume percentage, is: ； in, For the client Data volume value, Total number of clients; S313. Define the "small data volume client" as one whose local data volume ratio is less than the data volume ratio threshold. The client, if the client The proportion of local data meets the requirements It was determined to be a client with a small amount of data and was added to the set of clients with a small amount of data. middle; The server calculates the current global aggregation round. Percentage of update frequency for clients with small data volumes: ； in, Indicates the current global aggregation round. No. The number of updates per client. Indicates the current global aggregation round. No. The number of updates per client. This represents a collection of clients with small amounts of data. Represents the set of all clients; specifies the set. When it is an empty set, ; S314, Computing Client Model lag for: ； in, The degree of basic lag; The threshold representing the degree of basic lag; Indicates the lag adjustment factor; when When it is assumed that the number of updates from clients with small amounts of data is dominant, a lag adjustment factor is used to adjust the model lag of the clients currently participating in model updates; when At that time, it was assumed that the number of client updates was not dominant for small amounts of data, and the basic lag degree of the client model was used.

5. The asynchronous federated learning method for non-independent and identically distributed data based on the improved aggregation algorithm according to claim 4, characterized in that, Step S32 describes the server calculating the consistency of model update differences between the current global aggregation round and the previous round based on the currently received client model parameters and global model parameters; specifically: S321. The server maintains the model difference vectors of the two most recent iterations for each client. For the client currently participating in global aggregation... The difference vectors of its two most recent models and , is represented as: ； in, Indicates client The current uploaded model and the global model's first The difference vector of layer network parameters; Indicates client The previous uploaded model and the global model's first The difference vector of layer network parameters; Indicates client The first time the model was uploaded Layer network parameters, Represents the first global model Layer network parameters; Indicates client The model parameter matrix, Indicates the number of layers in the model; S322. The server calculates the client model difference vector for the current global aggregation round. Vector of difference from history The consistency is calculated using the following formula: ； in, This indicates the client Consistency between the differences in the client model parameter vectors uploaded in the two most recent two times; It represents a very small positive number to prevent division by zero errors; The L2 norm of a vector; S323, Calculate the average variance consistency of the client model. The calculation formula is: ； in, This represents an interval transformation function used to convert differences into consistency. from Range mapping to Interval.

6. The asynchronous federated learning method for non-independent and identically distributed data based on the improved aggregation algorithm according to claim 5, characterized in that, Step S33 describes the server calculating the historical contribution stability of the client, the staleness penalty of the client model, and the cosine similarity between the client model and the global model based on the update magnitude of the currently received client-uploaded model parameters; specifically: S331, On the server side, for each client Maintain a separate sliding window for client contribution history. This window only retains the most recent ones. Each update record is represented as: ； Where M is the size of the client's contribution history sliding window; Indicates client A sliding window showing the history of contributions; Indicates client No. The update magnitude of the model parameters uploaded each time they participate in global aggregation is calculated as follows: ； in, Indicates client No. The first time the model parameters were uploaded Layer network parameter vector, Indicates client No. The first upload of global model parameters Layer network parameter vector; This indicates that the local model and the global model are in the same position in the network parameter vector. The L1 norm of the difference between layers; when When, modify The value is the current client The number of times the model is uploaded, i.e. ;when Stop modifying The value is set. The value is a constant; Computing Client Average update magnitude of model parameters and variance and coefficient of variation They are respectively: ； ； ； Computing Client Historical contribution stability for: ； S332, Average Difference Consistency of Server-Client Integrated Model and historical contribution stability Computing Client Model parameter adjustment factor : ； in, These are hyperparameters used to adjust the client settings. Model discrepancy consistency affects model parameter adjustment factors The degree of influence, with a range of values. By changing Adjust the model's bias between consistency and stability; Computing Client obsolescence penalty factor : ； ； in, This is a hyperparameter representing the minimum compensation weight that the client can obtain, with a value range of [value range missing]. ; For the client The model parameters are based on the obsolescence penalty factor; The model's aging decay rate has a range of values. ; S333, The server calculates the clients currently participating in the global model update. Cosine similarity between the model and the global model for: ； in, and For clients Model parameters and global model parameters; This represents a very small positive number to prevent division by zero errors.

7. The asynchronous federated learning method for non-independent and identically distributed data based on the improved aggregation algorithm according to claim 6, characterized in that, In step S34, the server calculates the asynchronous federated aggregation factor of the client by integrating various parameters, updates the global model parameters, and generates a new global model. And the accuracy of the global model is tested using the server test dataset; specifically: S341. The server calculates the clients currently participating in the global model update. Basic aggregate weight : ； Then use cosine similarity Convert to similarity weight : ； Combined with basic aggregate weights and similarity weight Calculate the asynchronous federated aggregation factor for the client of the current upload model. for: ； in, Indicates the asynchronous federated aggregation factor; The average difference consistency is derived from equation (11); These are hyperparameters, representing the control client. The consistency between model differences and historical differences on asynchronous federated aggregation factors The proportion of contribution; Represent the symbolic function, only retaining The symbol; For the client Historical participation is calculated using the following formula: ； in, Indicates client Total number of uploads and updates; The server calculates the asynchronous federated aggregation factor. Performing global model aggregation is represented as: ； Based on this, a new global model is derived. The server will display the global model. Distributed to clients participating in this global aggregation As a local model for its next round of global aggregation training. .

8. A non-transitory computer-readable storage medium, characterized in that, It stores computer instructions that cause the computer to execute the asynchronous federated learning method for non-independent identically distributed data based on the improved aggregation algorithm as described in any one of claims 1-7.

9. An electronic device, characterized in that, include: The system includes a processor, a communication interface, a memory, and a communication bus. The processor, communication interface, and memory communicate with each other via the communication bus. The processor calls logical instructions from the memory to execute the asynchronous federated learning method for non-independent and identically distributed data based on the improved aggregation algorithm as described in any one of claims 1-7.

10. A computer program product, characterized in that, The computer program product includes a computer program stored on a non-transitory computer-readable storage medium. When the computer program is executed by a processor, the computer performs the asynchronous federated learning method for non-independent and identically distributed data based on an improved aggregation algorithm as described in any one of claims 1-7.

Images