Method, apparatus, device and medium for federated learning

Abstract

According to an embodiment of the present disclosure, a method, apparatus, device and medium for federated learning are provided. The method includes: at a service node, receiving a local model and first model version information from a client, and the local model is trained at the client; determining whether the local model is to be aggregated to the global model based on a comparison of the version difference between the first model version information and the second model version information of the global model with a version difference threshold; and if it is determined that the local model cannot be aggregated to the global model, sending a training parameter adjustment value and a global model to the client. Through such a scheme, it is possible to dynamically adjust the training scheme suitable for clients with different capabilities to make full use of the computing resources on the client.

Description

Technical Field

[0001] Example embodiments of the present disclosure generally relate to the field of computers, and more particularly, to methods, devices, apparatuses, and computer-readable storage media for federated learning. Background Art

[0002] Machine learning has been widely used. The performance of machine learning models usually improves with the increase of data volume. With the increasing attention paid to data privacy protection and the continuous development of edge computing capabilities, federated learning has emerged. Federated learning can use edge computing to train machine learning models on the client side while protecting user privacy, thereby unleashing the value of data. Summary of the invention

[0003] In a first aspect of the present disclosure, a method for federated learning is provided. The method includes: receiving a local model and first model version information from a client at a service node, the local model being trained at the client; determining whether the local model is to be aggregated to the global model based on a comparison of a version difference between the first model version information and second model version information of a global model and a version difference threshold; and if it is determined that the local model cannot be aggregated to the global model, sending a training parameter adjustment value and the global model to the client.

[0004] In a second aspect of the present disclosure, a method for federated learning is provided. The method includes: at a client, sending a local model and first model version information to a service node, the local model being trained at the client; receiving a training parameter adjustment value and a global model from the service node; determining a training parameter value based on the training parameter adjustment value; and training the global model according to the training parameter value to obtain another local model.

[0005] In a third aspect of the present disclosure, a device for federated learning is provided. The device includes: a receiving module configured to receive a local model and first model version information from a client, where the local model is trained at the client; an aggregation determination module configured to determine whether the local model is to be aggregated to the global model based on a comparison of a version difference between the first model version information and the second model version information of the global model and a version difference threshold; and a sending module configured to send a training parameter adjustment value and a global model to the client if it is determined that the local model cannot be aggregated to the global model.

[0006] In a fourth aspect of the present disclosure, a device for federated learning is provided. The device includes: a sending module configured to send a local model and first model version information to a service node, wherein the local model is trained at a client; a receiving module configured to receive a training parameter adjustment value and a global model from the service node; a parameter determination module configured to determine a training parameter value based on the training parameter adjustment value; and a training module configured to train the global model according to the training parameter value to obtain another local model.

[0007] In a fifth aspect of the present disclosure, an electronic device is provided. The device includes at least one processing unit; and at least one memory, the at least one memory is coupled to the at least one processing unit and stores instructions for execution by the at least one processing unit. When the instructions are executed by the at least one processing unit, the device executes the method of the first aspect.

[0008] In a sixth aspect of the present disclosure, an electronic device is provided. The device includes at least one processing unit; and at least one memory, the at least one memory is coupled to the at least one processing unit and stores instructions for execution by the at least one processing unit. When the instructions are executed by the at least one processing unit, the device executes the method of the second aspect.

[0009] In a seventh aspect of the present disclosure, a computer-readable storage medium is provided, wherein a computer program is stored on the medium, and the computer program is executed by a processor to implement the method of the first aspect.

[0010] In an eighth aspect of the present disclosure, a computer-readable storage medium is provided, wherein a computer program is stored on the medium, and the computer program is executed by a processor to implement the method of the second aspect.

[0011] It should be understood that the contents described in the summary of the present invention are not intended to limit the key features or important features of the embodiments of the present disclosure, nor are they intended to limit the scope of the present disclosure. Other features of the present disclosure will become easily understood through the following description. BRIEF DESCRIPTION OF THE DRAWINGS

[0012] The above and other features, advantages and aspects of the embodiments of the present disclosure will become more apparent with reference to the following detailed description in conjunction with the accompanying drawings. In the accompanying drawings, the same or similar reference numerals represent the same or similar elements, wherein:

[0013] Figure 1 A schematic diagram showing an example environment in which embodiments of the present disclosure can be applied;

[0014] Figure 2 An example process of asynchronous federated learning is shown;

[0015] Figure 3A flowchart showing a signaling flow for federated learning according to some embodiments of the present disclosure is shown;

[0016] Figure 4 A schematic block diagram of a service node according to some embodiments of the present disclosure is shown;

[0017] Figure 5 A schematic block diagram of a client according to some embodiments of the present disclosure is shown;

[0018] Figure 6 A flowchart illustrating a process of federated learning at a service node according to some embodiments of the present disclosure;

[0019] Figure 7 A flowchart illustrating a process of federated learning at a client according to some embodiments of the present disclosure;

[0020] Figure 8 A block diagram of an apparatus for federated learning at a service node according to some embodiments of the present disclosure is shown;

[0021] Fig. 9 A block diagram showing an apparatus for federated learning at a client according to some embodiments of the present disclosure; and

[0022] Fig.10 A block diagram of an electronic device capable of implementing one or more embodiments of the present disclosure is shown. DETAILED DESCRIPTION

[0023] Embodiments of the present disclosure will be described in more detail below with reference to the accompanying drawings. Although certain embodiments of the present disclosure are shown in the accompanying drawings, it should be understood that the present disclosure can be implemented in various forms and should not be construed as being limited to the embodiments set forth herein. On the contrary, these embodiments are provided to provide a more thorough and complete understanding of the present disclosure. It should be understood that the drawings and embodiments of the present disclosure are only for exemplary purposes and are not intended to limit the scope of protection of the present disclosure.

[0024] In the description of the embodiments of the present disclosure, the term "including" and similar terms should be understood as open inclusion, that is, "including but not limited to". The term "based on" should be understood as "based at least in part on". The term "one embodiment" or "the embodiment" should be understood as "at least one embodiment". The term "some embodiments" should be understood as "at least some embodiments". Other explicit and implicit definitions may also be included below.

[0025] It is understandable that the data involved in this technical solution (including but not limited to the data itself, the acquisition or use of the data) shall comply with the requirements of relevant laws, regulations and relevant provisions.

[0026] It is understandable that before using the technical solutions disclosed in the embodiments of the present disclosure, the types, scope of use, usage scenarios, etc. of the personal information involved in the present disclosure should be informed to the user and the user's authorization should be obtained in an appropriate manner in accordance with relevant laws and regulations.

[0027] For example, in response to receiving an active request from a user, a prompt message is sent to the user to clearly prompt the user that the operation requested to be performed will require obtaining and using the user's personal information. Thus, the user can autonomously choose whether to provide personal information to software or hardware such as an electronic device, application, server, or storage medium that performs the operation of the technical solution of the present disclosure according to the prompt message.

[0028] As an optional but non-limiting implementation, in response to receiving an active request from the user, the prompt information is sent to the user in a manner such as a pop-up window, in which the prompt information can be presented in text form. In addition, the pop-up window can also carry a selection control for the user to choose "agree" or "disagree" to provide personal information to the electronic device.

[0029] It is understandable that the above notification and the process of obtaining user authorization are merely illustrative and do not constitute a limitation on the implementation of the present disclosure. Other methods that meet relevant laws and regulations may also be applied to the implementation of the present disclosure.

[0030] As used herein, the term "model" can learn the association between the corresponding input and output from the training data, so that after the training is completed, the corresponding output can be generated for a given input. The generation of the model can be based on machine learning technology. Deep learning is a machine learning algorithm that processes inputs and provides corresponding outputs by using multiple layers of processing units. A neural network model is an example of a model based on deep learning. In this article, "model" may also be referred to as "machine learning model", "learning model", "machine learning network" or "learning network", and these terms are used interchangeably in this article.

[0031] A "neural network" is a machine learning network based on deep learning. A neural network is capable of processing inputs and providing corresponding outputs, and typically includes an input layer and an output layer and one or more hidden layers between the input layer and the output layer. Neural networks used in deep learning applications typically include many hidden layers, thereby increasing the depth of the network. The layers of a neural network are connected in sequence so that the output of the previous layer is provided as input to the next layer, where the input layer receives the input of the neural network and the output of the output layer serves as the final output of the neural network. Each layer of a neural network includes one or more nodes (also called processing nodes or neurons), each of which processes input from the previous layer.

[0032] Generally, machine learning can be roughly divided into three stages, namely the training stage, the testing stage, and the application stage (also called the inference stage). In the training stage, a given model can be trained using a large amount of training data, and the parameter values ​​are continuously updated iteratively until the model can obtain consistent inferences that meet the expected goals from the training data. Through training, the model can be considered to be able to learn the association from input to output (also called the mapping of input to output) from the training data. The parameter values ​​of the trained model are determined. In the testing stage, the test input is applied to the trained model to test whether the model can provide the correct output, thereby determining the performance of the model. In the application stage, the model can be used to process the actual input based on the parameter values ​​obtained from the training to determine the corresponding output.

[0033] Figure 1 A schematic diagram of an example environment 100 in which embodiments of the present disclosure can be implemented is shown. The environment 100 relates to a federated learning environment, which includes N clients 110-1...110-2,...110-N (where N is an integer greater than 1) and a service node 120. The clients 110-1, 110-2...110-N can respectively maintain their own local training data sets 112-1...112-k,...112-N. For ease of discussion, the clients 110-1, 110-2,...110-N may be collectively or individually referred to as clients 110, and the local training data sets 112-1, 112-2,...112-N may be collectively or individually referred to as local training data sets 112.

[0034] In some embodiments, client 110 and / or service node 120 can be implemented at terminal device or server.Terminal device can be any type of mobile terminal, fixed terminal or portable terminal, including mobile phone, desktop computer, laptop computer, notebook computer, netbook computer, tablet computer, media computer, multimedia tablet, personal communication system (PCS) equipment, personal navigation device, personal digital assistant (PDA), audio / video player, digital camera / camcorder, positioning device, television receiver, radio broadcast receiver, electronic book device, game device or any combination of the foregoing, including accessories and peripherals of these devices or any combination thereof.In some embodiments, terminal device can also support any type of interface for user (such as "wearable" circuit, etc.).Server is various types of computing system / server that can provide computing power, including but not limited to computing equipment in mainframe, edge computing node, cloud environment, etc.

[0035] Federated learning is also called horizontal federated learning. In federated learning, a client refers to a node that provides part of the training data for a machine learning model. A client is sometimes also referred to as a client, client device, worker node, terminal node, terminal device, edge device, etc. In some embodiments, a client can join a federated learning by request. In federated learning, a service node refers to a node that aggregates the training results at the client.

[0036] In the process of federated learning, the service node 120 distributes the global model 130 to the remote client 110 in each round. After receiving the global model 130, the client 110 performs local training using the local training data set 112 to obtain respective local models, such as local models 132-1, 132-2, ... 132-N (for ease of discussion, collectively or individually referred to as local models 132). The local model 132 can be considered as a local version of the global model 130 at the client 110, which is trained from the local training data set. The client 110 sends the local model 132 to the service node 120. The service node 120 aggregates the local model 132 from the client 110 into the current global model 130 to obtain a new version of the global model. The above process can be repeated until the model training converges.

[0037] In the embodiments of the present disclosure, the global model 130 may also be referred to as a global machine learning model, and the local model 132 may also be referred to as a local machine learning model. It may be constructed based on various machine learning or deep learning model architectures, and may be configured to implement various prediction tasks, such as various classification tasks, recommendation tasks, and the like. In different task scenarios, the global model 130 and the local model 132 may also be referred to as prediction models, recommendation models, classification models, and the like.

[0038] It should be understood that Figure 1 Only an example federated learning environment is shown. Depending on the federated learning algorithm and actual application needs, the environment may also be different. For example, although shown as a separate node, in some applications, the service node 120 may be used as a client to perform local training in addition to being a central node. The embodiments of the present disclosure are not limited in this respect.

[0039] The federated learning process can be divided into synchronous federated learning and asynchronous federated learning.

[0040] For synchronous federated learning, the service node collects a certain number of client local models before performing model aggregation. This may cause clients that have completed local training earlier and successfully uploaded the model to the service node to wait for clients that submitted models later due to various reasons, which results in resources being wasted on fast clients while they are waiting. In the case of large-scale deployment of federated learning systems, clients scattered across various locations often have different configurations and resources (for example, lightweight mobile devices and edge service nodes), which makes the synchronous aggregation method prone to resource waste and slow training in some deployment scenarios.

[0041] Asynchronous federated learning changes the synchronous model aggregation method to the asynchronous model aggregation method. After receiving the local model of a client, the service node aggregates the local model into the global model without waiting for other clients to upload, obtains the new version of the global model, and sends the new version of the global model to the client for the next round of local training. In other words, the service node can maintain the global model by uploading and aggregating.

[0042] Figure 2 An example process 200 of asynchronous federated learning is shown. For the purpose of explanation, it is assumed that there are two clients, client 1 and client 2, participating in asynchronous federated learning. In the initialization phase, the service node sends the initial global model (version 0) to client 1 and client 2. Next, in step 1 of each round of learning, client 1 performs local training on the global model (version 0) to obtain a trained local model. In step 2, client 1 uploads the local model to the service node. In step 3, the service node asynchronously aggregates the local model from client 1 with the global model (version 0) to obtain a new version of the global model (version 1), and sends the version of the global model to client 1 in step 4. Client 1 continues to perform local training based on the global model (version 1), obtains a trained local model, and uploads it to the service node. The service node continues to asynchronously aggregate the local model from client 1 with the global model (version 0) to obtain a new version of the global model (version 2).

[0043] Due to various reasons (e.g., insufficient computing resources, slow network speed, etc.), the local training and / or model upload and download of client 2 is slow. After client 2 performs local training based on the initial global model (version 0), it uploads the local model to the service node. At this time, the service node maintains the global model (version 2). If the service node aggregates the local model of client 2 with the global model (version 2), it will obtain the global model (version 3).

[0044] Although asynchronous federated learning can avoid waiting and resource waste of fast client devices, if the service node passively receives local models uploaded by different clients and aggregates these local models indiscriminately, it will lead to slow convergence of the global model and even poor performance. Figure 2 In the example, since the local model uploaded by Client 2 is trained based on the initial version of the global model (version 0), the performance of the local model may be worse than the performance of the global model (version 2) currently available at the service node. Aggregating such a local model with the global model may make the performance of the next version of the global model (version 3) worse rather than better.

[0045] For the sake of convenience, Figure 2 Only two client deployments are shown in the figure. In practical applications, federated learning systems may involve large-scale client deployments, including hundreds or thousands of clients. These clients may include lightweight mobile devices and edge servers with high computing power, and thus have different processing resources, storage resources, network resources, etc. Therefore, this will lead to large differences between the versions of some local models and the versions of the global models maintained at the service nodes in some asynchronous aggregation processes. Indiscriminate aggregation will seriously reduce the learning efficiency and performance of the model.

[0046] How to take into account clients with different capabilities and make full use of the computing power on the clients for model training while ensuring the learning efficiency and performance of the model is one of the important issues in large-scale federated learning systems.

[0047] According to an embodiment of the present disclosure, an improved federated learning scheme is provided. Specifically, the service node determines whether the local model can be aggregated to the global model by the version difference between the model version information corresponding to the local model provided by the client and the model version information of the global model maintained by itself. If the local model cannot be aggregated to the global model (for example, if the version difference is large), the service node will send the training parameter adjustment value and the global model to the client. The client can adjust the training parameter value to be used according to the training parameter adjustment value provided by the service node, and use the adjusted training parameter value to perform the next round of local training.

[0048] Through such a solution, it is possible to dynamically adjust the training scheme suitable for clients with different capabilities to make full use of the computing resources on the client. This can significantly adjust the learning efficiency and performance of the global model and improve the training speed and efficiency.

[0049] Some example embodiments of the present disclosure will be described below with continued reference to the accompanying drawings.

[0050] Figure 3 FIG. 3 is a schematic block diagram of a signaling flow 300 for federated learning according to some embodiments of the present disclosure. Figure 1 The environment 100 is discussed. The signaling flow 300 involves N clients 110 and service nodes 120. These clients 110 and service nodes 120 constitute a federated learning system and participate in the training of a machine learning model.

[0051] In the following, the operations on the client side will be described from the perspective of a single client. These operations may be similar on different clients.

[0052] In the signaling flow 300, the client 110 sends 310 the local model 132 and the first model version information to the service node 120. The local model 132 is trained at the client 110.

[0053] In some embodiments, the client 110 may obtain a model to be trained from the service node 120. The model is referred to as a global model 130. The client 110 may perform (305) local training of the received model to obtain a local model 132. For example, the client 110 may use a local training data set 112 to train a local model 132. In an embodiment of the present disclosure, the model to be trained may be a model suitable for processing various tasks. The training algorithm of the local training may also be selected according to the actual application and the model configuration.

[0054] When sending the global model 130 to the client 110, the service node 120 may also provide model version information of the global model 130. After training the local model 132, the client 110 may upload the local model 132 and the model version information corresponding to the global model 130 used to train the local model 132 to the service node 120. The model version information may be represented by a version number, for example. For example, in the initial stage, the model version information of the global model 130 may be represented as version 0. As the global model 130 is updated, the model version information is also updated.

[0055] In some embodiments, in the initial stage, the service node 120 can configure the relevant parameters of the federated learning for the global model 130, such as the total number of clients N participating in the federated learning, the cluster information on the service side, etc., and start the cluster to wait for the client to join. On the client side, the client 110 can configure the client cluster information and other relevant parameters according to its own computing power, and request the service node 120 to join the federated learning. In some embodiments, the client 110 can provide the service node 120 with information related to the local training data set, such as the size D of the local training data set. cAfter receiving the request from the client 110, the service node 120 provides the global model 130 to the client 110 for initialization and starts the federated learning process. In some embodiments, the initiated federated learning includes asynchronous federated learning. Figure 4 and Figure 5 Introduces some example structures of service nodes and client nodes.

[0056] In some embodiments, in the initial stage, the service node 120 may provide the model configuration of the global model 130 and the initial model parameter values ​​of the model to the client 110. In some embodiments, as the federated learning iterates, in subsequent steps, the service node 120 informs the client 110 of the current version of the global model 130 by providing the client 110 with new model parameter values ​​of the global model 130.

[0057] The service node 120 receives (315) the local model 132 and the first model version information from the client 110. In an embodiment of the present disclosure, the service node 120 determines whether to aggregate the local model 132 uploaded by the current client 110 into the global model 130 through the model version information.

[0058] Specifically, the service node 120 maintains the model version information t (referred to as “second model version information”) of the global model 130. The first model version information reported by the client 110 is marked as t c . As mentioned above, the model version information uploaded by the client 110 indicates the version of the global model on which the training of the local model 132 is based. During the asynchronous federated learning process, the service node 120 updates the version of the global model after aggregating the local models from the clients into the global model. Therefore, the version difference between the model version information provided by a certain client 110 and the model version information of the current global model at the service node 120 can reflect the degree of lag in the model training and reporting of the client 110. This lag may be due to the client 110 spending too much time training the model (for example, due to low computing power or unreasonable training scheme), and / or poor network quality resulting in too much time spent on model upload and download, etc.

[0059] In an embodiment of the present disclosure, the service node 120 determines ( 320 ) whether the local model 132 is to be aggregated into the global model 130 based on a comparison of a version difference between the first model version information and the second model version information of the global model 130 and a version difference threshold.

[0060] The version difference threshold can be set to the maximum tolerable version difference, denoted as T g The version difference threshold may be represented by a model version number difference, for example. The service node 120 may determine the model version information t provided by the client 110.c The version difference between the model version information t of the maintained global model 130 And compare the version difference with the version difference threshold T g In comparison.

[0061] Depending on the aggregation judgment of the local model, the client 110 and the service node 120 perform subsequent operations. In the case where it is determined that the local model cannot be aggregated into the global model, process 302 may be performed.

[0062] In process 302 , if it is determined that the local model cannot be aggregated into the global model, the service node 120 sends ( 325 ) the training parameter adjustment values ​​and the global model to the client 110 .

[0063] In some embodiments, if the version difference exceeds a version difference threshold (e.g., greater than the version difference threshold, or greater than or equal to the version difference threshold, depending on specific settings), the service node 120 may determine that the local model 132 of this client 110 cannot be aggregated into the global model 130. In such an embodiment, the service node 120 may discard the local model 132.

[0064] As shown above, the version difference can reflect the degree of lag in the model training and reporting of the client 110. In the embodiment of the present disclosure, taking into account such version differences, it is expected that the training scheme of the client 110 can be adjusted so that the client 110 will not continue to do useless work, resulting in the trained local models failing to contribute to the global model. In a conventional scheme, if the service node decides not to aggregate the local model of the client, it may not give feedback to the client. In this way, the client may still follow the original scheme to continue training the next version of the local model. If the computing power or network resources of the client cannot be improved, the next local model may still not be aggregated.

[0065] In the embodiments of the present disclosure, not only can the model performance loss caused by the aggregation of local models with large version differences into the global model that has been updated more times be prevented, but also the local training scheme of the client can be dynamically adjusted so that the local model of the client can be truly contributed to the global model. Specifically, the service node 120 can guide the client 110 to adjust the local training scheme by sending a training parameter adjustment value to the client 110 whose local model has been discarded.

[0066] In some embodiments, considering that the version difference between the model version at the client 110 and the current global model can reflect the degree of lag in model training and reporting of the client 110, the training parameter adjustment value provided by the service node 120 to the client 110 can be used to indicate that the client 110 can speed up the training of the local model for faster reporting.

[0067] In some implementations, the training parameter adjustment value may be related to the number of training steps used at the client 110. For example, in each training round, the client 110 may generate a local model to be reported after completing a certain number of training steps. Each training step may, for example, correspond to an update of the model parameters. During the model training process, the model parameters are updated once based on a subset of training data (e.g., a batch). Each update may correspond to a training step. After multiple updates, the training goal of the local model can be achieved and a training round can be completed. In some embodiments, the training parameter adjustment value may be determined to reduce the number of training steps that the client will use to train the global model, thereby speeding up reporting.

[0068] In addition to the number of training steps, in other embodiments, the training parameter adjustment value may also be determined as other parameters that can indicate speeding up local training, such as the amount of training data used in each training round. Generally, the number of training steps and the amount of training data may be positively correlated, for example, more training steps often mean a larger amount of training data is processed. Of course, in addition to the amount of training data, the training parameter adjustment value may also indicate other training parameters so that the client 110 can adjust the local training.

[0069] In some embodiments, the training parameter adjustment value may be determined as a magnitude of a training parameter in a training scheme for adjusting the client 110. In some embodiments, for a certain client 110, the service node 120 may determine the training parameter adjustment value for the client based on the version difference between the first model version information and the second model version information reported by the client 110. In some embodiments, the version difference may be calculated. The version difference threshold T g The difference between the training parameters and the training parameters of the client 110 is used to determine the training parameter adjustment value for the client 110. The version difference threshold T g The difference can reflect the degree to which the training and reporting of the client 110 needs to be accelerated in order to achieve successful aggregation. If the difference is larger, it means that the training scheme (or a certain training parameter) of the client 110 needs to be adjusted more. In some embodiments, the training parameter adjustment value can be determined as: , where N represents the total number of clients participating in federated learning.

[0070] The above is a specific example of determining the training parameter adjustment value. In other examples, the training parameter adjustment value can also be determined by other calculation methods, and the adjustment range of the local training indicated by the determined training parameter adjustment value can be different from the version difference. , or version differences and version difference threshold T gThe difference is proportional.

[0071] In some embodiments, the training parameter adjustment value may also be set to a preset indication for instructing the client 110 to adjust the local training (e.g., speed up the local training). In some embodiments, the training parameter adjustment value may also be set to a fixed adjustment amount for a certain training parameter (e.g., the number of training steps or the amount of training data). The embodiments of the present disclosure are not limited in this respect.

[0072] The service node 120 sends the determined training parameter adjustment value and the global model to the client 110. In some embodiments, the service node 120 may also inform the client 110 of the model version information of the sent global model to facilitate the next report.

[0073] Client 110 receives (330) the training parameter adjustment value and the global model from service node 120. In some embodiments, if client 110 receives the training parameter adjustment value, service node 120 may determine that the previously reported local model was not successfully aggregated into the global model.

[0074] Although the local model cannot be aggregated in the previous round, the client 110 can adjust the training scheme of the local training through the received training parameter adjustment value to increase the probability that the local model obtained in the next training round is successfully aggregated. Specifically, the client 110 determines (335) the training parameter value based on the training parameter adjustment value. The determined training parameter value is applied in the next training round. The client 110 trains (340) the global model according to the training parameter value to obtain another local model. In the local training, according to the training parameter value determined by the client 110 and the local training data set, the client 110 can continuously update the model parameters of the global model received from the service node 120 to obtain a new model, that is, another local model.

[0075] In some embodiments, the client 110 may determine the number of training steps for training the global model based on the received training parameter adjustment value. If the number of training steps in the training round used to train the last reported local model is the first training step, then the client 110 may determine a new number of training steps based on the training parameter adjustment value, referred to as the second training step. The second training step is smaller than the first training step, so that the model training of the next training round can be completed faster. For example, the client 110 adjusts the training parameter value Δ t The new number of training steps determined is: , is the number of training steps used by the last reported local model. In this way, the number of training steps is reduced, and the client 110 can complete the training and reporting of the local model more quickly. Here is an example of determining the number of training steps. In other embodiments, the training parameter adjustment value can also be used in other ways to adjust the number of training steps, such as reducing the number of training steps.

[0076] In addition to or as an alternative to the number of training steps, the client 110 may also use the training parameter adjustment value to adjust other training parameters, such as the amount of training data used in a training round, and so on.

[0077] Based on the adjusted training data value, the client 110 can train a new local model from the received global model, and report the new local model and the model version information of the used global model to the service node 120 again. This process can be repeated until the training of the global model is completed.

[0078] According to the above scheme, on the basis of asynchronous federated aggregation, the waste of computing resources on the client during waiting can be reduced. In addition, by adjusting the training parameter values ​​used by the clients that cannot be aggregated, the clients with slower training can appropriately reduce the number of training steps to avoid the discarding of their uploaded models and waste of local computing resources, so that the local models of these clients can contribute to the training of the global model. This can significantly adjust the learning efficiency and performance of the global model and improve the training speed and efficiency.

[0079] In some embodiments, for a local model received from client 110 , if service node 120 determines that the local model can be aggregated into a global model, process 304 may be performed.

[0080] Unlike the synchronous aggregation method, which performs a weighted summation of all collected client models, the traditional asynchronous aggregation method makes it difficult to distinguish the contributions of different client models and assign reasonable aggregation weights to them when aggregating models. When the service node performs asynchronous model aggregation, since a single local model or a small number of local models are aggregated each time, it is necessary to consider the appropriate aggregation weight of the local model. In some embodiments, the local model of each client can be adaptively assigned an appropriate aggregation weight based on a small amount of client information that does not have privacy.

[0081] Specifically, in some embodiments, when reporting the local model, the client 110 may also send information related to the local training to the service node 120, such as Figure 2As shown. Local training here refers to the information involved in the training rounds for generating the reported local model 132. In some embodiments, the information may include, for example, but is not limited to, the loss value of the local model when the training of the local model is completed, the amount of training data used to train the local model in the training round, and / or the number of training steps in the training round, etc. This information can reflect the capabilities or model performance learned by the local model, etc. In process 304, the service node 120 can determine (345) the contribution of the local model of the client 110 to the global model based on the received information, and aggregate (350) the local model and the global model based on the degree of contribution.

[0082] Specifically, if it is determined that the local model is to be aggregated into the global model, the service node 120 may perform aggregation of the local model and the global model based on the contribution to obtain another global model. The model version information of the other global model is updated based on the second version information t of the global model, for example, the model version number is increased by one. In some embodiments, the service node 120 may determine an aggregation weight for the local model based on the contribution, and use the aggregation weight to weight the aggregation of the local model and the global model.

[0083] In some embodiments, the aggregation weight may be determined based on the loss value and the amount of training data provided by the client 110, for example, as follows:

[0084]

[0085] in represents the aggregate weight of the local model 132, D i represents the total size of the local training dataset of the i-th client among the N clients participating in federated learning, represents the amount of training data used by the client 110 to train the local model 132 in one training round, represents the number of training steps adopted by the client 110 in a training round, k is a preset hyperparameter, and its value range can be 0<k<1.

[0086] The above is an example calculation method of the aggregation weight of the local model. In some embodiments, the contribution of the local model can be measured based on information such as loss value, number of training steps, and / or amount of training data, and the aggregation weight of the local model can be determined in other ways.

[0087] In some embodiments, combined with the dynamic adjustment of the client's training scheme described above, the client's local model can adapt to the federated learning process and successfully aggregate to the global model. Moreover, by adaptively adjusting the aggregation weight during asynchronous aggregation according to the contribution of the local model, the importance of high-quality models is highlighted, while reducing the impact of low-quality models on the quality of the global model. This can significantly adjust the learning efficiency and performance of the global model and improve training speed and efficiency.

[0088] The service node 120 weights and aggregates the local model and the global model based on the aggregation weight. The aggregation can be expressed as follows:

[0089]

[0090] where θ t represents the global model after aggregation, θ t-1 represents the current global model to be aggregated, Indicates the local model provided by the client 110 .

[0091] Figure 4 A schematic block diagram of a service node 120 according to some embodiments of the present disclosure is shown. As shown, the service node 120 is configured as a cluster 410 to support various functions of the service node 120. In the initial stage, the service node 120 configures the cluster 410 according to the configuration information 412 to support the federated learning process to be initiated. In the service node 120, the asynchronous aggregation module 420 is configured to aggregate the local model received from the client 110 into the currently maintained global model.

[0092] The maintained global model and / or the received local model may be stored, for example, in the model storage 440. The service node 120 may also include other storage 450 for storing other relevant data / information. The service node 120 also includes a transport server 430 configured to communicate with the client 110, including uploading and downloading models and other information. The transport server 430 may communicate with the client 110 according to various appropriate communication protocols or transport protocols, and the embodiments of the present disclosure are not limited in this respect. As an example, the transport server 430 may include a gRPC server.

[0093] Figure 5A schematic block diagram of a client 110 according to some embodiments of the present disclosure is shown. As shown, the client 110 includes a control node 510 and one or more working nodes 520. The control node 510 is configured to control a local training process, and the working node 520 is configured to perform training operations. In some embodiments, the client 110 may also be configured based on a cluster 540. The cluster 540 may be configured by configuration information 542. In some embodiments, the parameter values ​​of the model may be maintained by a parameter server (PS) 550. The trained local model and the global model received from the service node 120 may be stored in a model storage 570. The client 110 may also include other storage 560 for storing other related data / information.

[0094] exist Figure 5 In the embodiment of the present invention, by separating the mechanism of training control and execution (i.e., control node and working node), more efficient local training can be achieved. In the control node 510, the transmission client 512 is configured to communicate with the transmission server 430 in the service node 120, including uploading and downloading models and other information. The transmission client 512 can communicate with the client 110 according to various appropriate communication protocols or transmission protocols, and the embodiments of the present disclosure are not limited in this respect. As an example, the transmission client 512 may include a gRPC client. In some embodiments, the control node 510 also includes a training step number dynamic adjustment module 530, which is configured to adjust the training step number based on the training parameter adjustment value received from the service node 120. The control node 510 may also include a data module 532, which is configured to control data interaction in local training. For example, during the process of uploading the local model and downloading the global model between the client 110 and the service node 120, the data module 532 can control the working node 520 to suspend the training operation, and then carry out the next round of local training after obtaining the model parameters of the global model. This can avoid useless model parameter updates. The training process control module 534 in the control node 510 is configured to control the model training process of the working node 520, including configuring training parameter values, etc.

[0095] The transport server 522 in the control node 510 is configured to communicate with the transport client 522 in the working node 520 to transmit a training control signal for controlling the training operation of the model training module 524 in the working node 520. As an example, the transport server 522 may include a gRPC server, and the transport client 522 may include a gRPC client.

[0096] Figure 4 and Figure 5Only some example implementations of the service node 120 and the client 110 are provided. It should be understood that, according to actual application requirements, the service node and the client may also adopt other implementations. The embodiments of the present disclosure are not limited in this respect.

[0097] Figure 6 A flow chart showing a process 600 for federated learning at a client according to some embodiments of the present disclosure is shown. The process 600 may be implemented at a service node 120.

[0098] In block 610, the service node 120 receives a local model and first model version information from a client, the local model being trained at the client. In block 620, the service node 120 determines whether the local model is to be aggregated to the global model based on a comparison of a version difference between the first model version information and the second model version information of the global model with a version difference threshold. If it is determined that the local model cannot be aggregated to the global model, in block 630, the service node 120 sends the training parameter adjustment value and the global model to the client.

[0099] In some embodiments, process 600 further includes: determining a training parameter adjustment value for the client based on a version difference between the first model version information and the second model version information.

[0100] In some embodiments, determining the training parameter adjustment value for the client based on the version difference includes: determining the training parameter adjustment value for the client based on a difference between the version difference and a version difference threshold.

[0101] In some embodiments, the training parameter adjustment value is determined to reduce the number of training steps taken by the client.

[0102] In some embodiments, determining whether the local model is to be aggregated into the global model includes determining that the local model cannot be aggregated into the global model if the version difference exceeds a version difference threshold.

[0103] In some embodiments, process 600 further includes: receiving information related to local training in a training round for generating a local model from a client; and determining a contribution of the local model to the global model based on the received information. In some embodiments, the information includes at least one of the following: a loss value of the local model when training of the local model is completed, an amount of training data used to train the local model in the training round, and a number of training steps in the training round.

[0104] In some embodiments, process 600 further includes: if it is determined that the local model is to be aggregated into the global model, performing aggregation of the local model and the global model based on the contribution to obtain another global model.

[0105] In some embodiments, performing aggregation of the local model with the global model based on the contribution includes: determining an aggregation weight for the local model based on the contribution; and weighting the aggregation of the local model and the global model using the aggregation weight.

[0106] Figure 7 A flow chart showing a process 700 for federated learning at a service node according to some embodiments of the present disclosure is shown. The process 700 may be implemented at the client 110 .

[0107] In block 710, the client 110 sends a local model and first model version information to the service node, and the local model is trained at the client. In block 720, the client 110 receives a training parameter adjustment value and a global model from the service node. In block 730, the client 110 determines a training parameter value based on the training parameter adjustment value. In block 740, the client 110 trains the global model according to the training parameter value to obtain another local model.

[0108] In some embodiments, the training parameter adjustment value is determined based on a version difference between the first model version information and the second model version information of the global model.

[0109] In some embodiments, process 700 also includes determining, based on receiving the training parameter adjustment value, that the local model is not aggregated to the global model.

[0110] In some embodiments, determining the training parameter value based on the training parameter adjustment value includes: determining the number of training steps for training the global model based on the training parameter adjustment value.

[0111] In some embodiments, determining the number of training steps includes: updating a first number of training steps used to train the local model to a second number of training steps based on a training parameter adjustment value, wherein the second number of training steps is smaller than the first number of training steps.

[0112] In some embodiments, process 700 further includes: sending information related to local training in a training round for generating a local model to the service node. In some embodiments, the information includes at least one of the following: a loss value of the local model when the training of the local model is completed, an amount of training data used to train the local model in the training round, and a number of training steps in the training round.

[0113] Figure 8 A block diagram of an apparatus 800 for federated learning at a client according to some embodiments of the present disclosure is shown. The apparatus 800 may be implemented as or included in a service node 120. Each module / component in the apparatus 800 may be implemented by hardware, software, firmware, or any combination thereof.

[0114] As shown in the figure, the device 800 includes a receiving module 810, which is configured to receive a local model and a first model version information from a client, and the local model is trained at the client. The device 800 also includes an aggregation determination module 820, which is configured to determine whether the local model is to be aggregated into the global model based on a comparison of the version difference between the first model version information and the second model version information of the global model with a version difference threshold. The device 800 also includes a sending module 830, which is configured to send the training parameter adjustment value and the global model to the client if it is determined that the local model cannot be aggregated into the global model.

[0115] In some embodiments, the apparatus 800 further includes: an adjustment determination module configured to determine a training parameter adjustment value for the client based on a version difference between the first model version information and the second model version information.

[0116] In some embodiments, the adjustment determination module includes: a threshold comparison-based adjustment determination module configured to determine a training parameter adjustment value for the client based on a difference between the version difference and a version difference threshold.

[0117] In some embodiments, the training parameter adjustment value is determined to reduce the number of training steps taken by the client.

[0118] In some embodiments, the aggregation determination module 820 is configured to determine that the local model cannot be aggregated into the global model if the version difference exceeds a version difference threshold.

[0119] In some embodiments, the apparatus 800 further includes: a second receiving module configured to receive information related to local training in a training round for generating a local model from a client; and a contribution determination module configured to determine the contribution of the local model to the global model based on the received information. In some embodiments, the information includes at least one of the following: a loss value of the local model when the training of the local model is completed, an amount of training data used to train the local model in the training round, and a number of training steps in the training round.

[0120] In some embodiments, the apparatus 800 further includes: an aggregation module configured to, if it is determined that the local model is to be aggregated into the global model, aggregate the local model with the global model based on the contribution to obtain another global model.

[0121] In some embodiments, the aggregation module includes: a weight determination module configured to determine an aggregation weight for the local model based on the contribution; and a weighted aggregation module configured to weight-aggregate the local model and the global model using the aggregation weight.

[0122] Fig. 9A block diagram of an apparatus 900 for federated learning at a service node according to some embodiments of the present disclosure is shown. The apparatus 900 may be implemented as or included in a client 110. Each module / component in the apparatus 900 may be implemented by hardware, software, firmware, or any combination thereof.

[0123] As shown in the figure, the device 900 includes a sending module 910, which is configured to send a local model and first model version information to a service node, wherein the local model is trained at the client. The device 900 also includes a receiving module 920, which is configured to receive a training parameter adjustment value and a global model from the service node. The device 900 also includes a parameter determination module 930, which is configured to determine a training parameter value based on the training parameter adjustment value. The device 900 also includes a training module 940, which is configured to train the global model according to the training parameter value to obtain another local model.

[0124] In some embodiments, the training parameter adjustment value is determined based on a version difference between the first model version information and the second model version information of the global model.

[0125] In some embodiments, the apparatus 900 further includes: an aggregation determination module configured to determine that the local model is not aggregated into the global model based on the reception of the training parameter adjustment value.

[0126] In some embodiments, the parameter determination module 930 includes: a training step determination module configured to determine the number of training steps for training the global model based on the training parameter adjustment value.

[0127] In some embodiments, the training step determination module includes: a training step update module configured to update a first training step used to train a local model to a second training step based on a training parameter adjustment value, wherein the second training step is smaller than the first training step.

[0128] In some embodiments, the apparatus 900 further includes: a second sending module configured to send information related to local training in a training round for generating a local model to the service node. In some embodiments, the information includes at least one of the following: a loss value of the local model when the training of the local model is completed, an amount of training data used to train the local model in the training round, and a number of training steps in the training round.

[0129] Fig.10 1 shows a block diagram of an electronic device 1000 in which one or more embodiments of the present disclosure may be implemented. It should be understood that Fig.10 The electronic device 1000 shown is merely exemplary and should not constitute any limitation on the functionality and scope of the embodiments described herein. Fig.10The electronic device 1000 shown can be used to implement Figure 1 The client 110 or the service node 120.

[0130] like Fig.10 As shown, the electronic device 1000 is in the form of a general-purpose computing device. The components of the electronic device 1000 may include, but are not limited to, one or more processors or processing units 1010, a memory 1020, a storage device 1030, one or more communication units 1040, one or more input devices 1050, and one or more output devices 1060. The processing unit 1010 may be an actual or virtual processor and is capable of performing various processes according to a program stored in the memory 1020. In a multi-processor system, multiple processing units execute computer executable instructions in parallel to improve the parallel processing capability of the electronic device 1000.

[0131] The electronic device 1000 typically includes a plurality of computer storage media. Such media may be any available media accessible to the electronic device 1000, including but not limited to volatile and non-volatile media, removable and non-removable media. The memory 1020 may be a volatile memory (e.g., a register, a cache, a random access memory (RAM)), a non-volatile memory (e.g., a read-only memory (ROM), an electrically erasable programmable read-only memory (EEPROM), flash memory), or some combination thereof. The storage device 1030 may be a removable or non-removable medium, and may include a machine-readable medium, such as a flash drive, a disk, or any other medium, which may be capable of being used to store information and / or data (e.g., training data for training) and may be accessed within the electronic device 1000.

[0132] The electronic device 1000 may further include additional removable / non-removable, volatile / non-volatile storage media. Fig.10 As shown in , a disk drive for reading or writing from a removable, non-volatile disk (e.g., a "floppy disk") and an optical drive for reading or writing from a removable, non-volatile optical disk may be provided. In these cases, each drive may be connected to the bus (not shown) by one or more data media interfaces. Memory 1020 may include a computer program product 1025 having one or more program modules that are configured to perform various methods or actions of various embodiments of the present disclosure.

[0133] The communication unit 1040 implements communication with other computing devices through a communication medium. Additionally, the functions of the components of the electronic device 1000 can be implemented in a single computing cluster or multiple computing machines that can communicate through a communication connection. Therefore, the electronic device 1000 can operate in a networked environment using a logical connection with one or more other servers, a network personal computer (PC), or another network node.

[0134] The input device 1050 may be one or more input devices, such as a mouse, a keyboard, a tracking ball, etc. The output device 1060 may be one or more output devices, such as a display, a speaker, a printer, etc. The electronic device 1000 may also communicate with one or more external devices (not shown) through the communication unit 1040 as needed, such as a storage device, a display device, etc., communicate with one or more devices that allow a user to interact with the electronic device 1000, or communicate with any device that allows the electronic device 1000 to communicate with one or more other computing devices (e.g., a network card, a modem, etc.). Such communication may be performed via an input / output (I / O) interface (not shown).

[0135] According to an exemplary implementation of the present disclosure, a computer-readable storage medium is provided, on which computer-executable instructions or a computer program are stored, wherein the computer-executable instructions or the computer program are executed by a processor to implement the method described above.

[0136] According to an exemplary implementation of the present disclosure, a computer program product is also provided. The computer program product is tangibly stored on a non-transitory computer-readable medium and includes computer-executable instructions, and the computer-executable instructions are executed by a processor to implement the method described above.

[0137] Various aspects of the present disclosure are described herein with reference to flowcharts and / or block diagrams of methods, devices, equipment, and computer program products implemented according to the present disclosure. It should be understood that each box in the flowchart and / or block diagram and the combination of each box in the flowchart and / or block diagram can be implemented by computer-readable program instructions.

[0138] These computer-readable program instructions can be provided to a processing unit of a general-purpose computer, a special-purpose computer, or other programmable data processing device, thereby producing a machine, so that when these instructions are executed by the processing unit of the computer or other programmable data processing device, a device that implements the functions / actions specified in one or more boxes in the flowchart and / or block diagram is generated. These computer-readable program instructions can also be stored in a computer-readable storage medium, and these instructions cause the computer, programmable data processing device, and / or other equipment to work in a specific manner, so that the computer-readable medium storing the instructions includes a manufactured product, which includes instructions for implementing various aspects of the functions / actions specified in one or more boxes in the flowchart and / or block diagram.

[0139] Computer-readable program instructions can be loaded onto a computer, other programmable data processing apparatus, or other device so that a series of operational steps are performed on the computer, other programmable data processing apparatus, or other device to produce a computer-implemented process, so that the instructions executed on the computer, other programmable data processing apparatus, or other device implement the functions / actions specified in one or more boxes in the flowchart and / or block diagram.

[0140] The flow chart and block diagram in the accompanying drawings show the possible architecture, function and operation of the system, method and computer program product according to multiple implementations of the present disclosure. In this regard, each square box in the flow chart or block diagram can represent a part of a module, program segment or instruction, and a part of a module, program segment or instruction includes one or more executable instructions for realizing the logical function of the specification. In some implementations as replacements, the function marked in the square box can also occur in a sequence different from that marked in the accompanying drawings. For example, two continuous square boxes can actually be executed substantially in parallel, and they can sometimes be executed in reverse order, depending on the functions involved. It should also be noted that each square box in the block diagram and / or flow chart, and the combination of the square boxes in the block diagram and / or flow chart can be realized by a special hardware-based system that performs the function or action of the specification, or can be realized by a combination of special hardware and computer instructions.

[0141] The above descriptions of various implementations of the present disclosure are exemplary, non-exhaustive, and not limited to the disclosed implementations. Many modifications and variations will be apparent to those of ordinary skill in the art without departing from the scope and spirit of the described implementations. The selection of terms used herein is intended to best explain the principles of the implementations, practical applications, or improvements to the technology in the market, or to enable other persons of ordinary skill in the art to understand the various implementations disclosed herein.

Claims

1. A method for federated learning, comprising: At a service node, receiving a local model and first model version information from a client, wherein the local model is trained at the client; determining whether the local model is to be aggregated into the global model based on a comparison of a version difference between the first model version information and the second model version information of the global model and a version difference threshold; Determining a training parameter adjustment value for the client based on the version difference between the first model version information and the second model version information; as well as If it is determined that the local model cannot be aggregated into the global model, the training parameter adjustment value and the global model are sent to the client.

2. The method according to claim 1, wherein determining the training parameter adjustment value for the client based on the version difference comprises: The training parameter adjustment value for the client is determined based on a difference between the version difference and the version difference threshold.

3. The method according to claim 1, wherein the training parameter adjustment value is related to the number of training steps taken by the client.

4. The method of claim 1 , wherein determining whether the local model is to be aggregated into a global model comprises: If the version difference exceeds the version difference threshold, it is determined that the local model cannot be aggregated into the global model.

5. The method according to any one of claims 1 to 4, further comprising: receiving, from the client, information related to local training in a training round for generating the local model; as well as A contribution of the local model to the global model is determined based on the received information.

6. The method according to claim 5, wherein the information includes at least one of the following: the loss value of the local model when training of the local model is completed, the amount of training data used to train the local model in a training round, The number of training steps in this training epoch.

7. The method according to claim 5, further comprising: If it is determined that the local model is to be aggregated into the global model, the local model is aggregated with the global model based on the contribution to obtain another global model.

8. The method of claim 7, wherein performing aggregation of the local model with the global model based on the contribution comprises: Determining an aggregation weight for the local model based on the contribution; as well as The local model and the global model are weightedly aggregated using the aggregation weight.

9. A method for federated learning, comprising: At the client, sending a local model and first model version information to a service node, wherein the local model is trained at the client; receiving a training parameter adjustment value and a global model from the service node, wherein the training parameter adjustment value is determined based on a version difference between the first model version information and second model version information of the global model; determining a training parameter value based on the training parameter adjustment value; as well as The global model is trained according to the training parameter values ​​to obtain another local model.

10. The method according to claim 9, further comprising: A determination is made based on receipt of the training parameter adjustment value that the local model is not aggregated to the global model.

11. The method of claim 9, wherein determining the training parameter value based on the training parameter adjustment value comprises: The number of training steps for training the global model is determined based on the training parameter adjustment value.

12. The method according to claim 11, wherein determining the number of training steps comprises: Based on the training parameter adjustment value, a first training step number used to train the local model is updated to a second training step number, where the second training step number is smaller than the first training step number.

13. The method according to any one of claims 9 to 12, further comprising: Sending information related to local training in a training round for generating the local model to the service node.

14. The method according to claim 13, wherein the information comprises at least one of the following: the loss value of the local model when training of the local model is completed, the amount of training data used to train the local model in a training round, The number of training steps in this training epoch.

15. A device for federated learning, comprising: A receiving module is configured to receive a local model and first model version information from a client, wherein the local model is trained at the client; an aggregation determination module, configured to determine whether the local model is to be aggregated into the global model based on a comparison between a version difference between the first model version information and the second model version information of the global model and a version difference threshold; an adjustment determination module, configured to determine a training parameter adjustment value for the client based on the version difference between the first model version information and the second model version information; as well as A sending module is configured to send the training parameter adjustment value and the global model to the client if it is determined that the local model cannot be aggregated into a global model.

16. A device for federated learning, comprising: A sending module, configured to send a local model and first model version information to a service node, wherein the local model is trained at a client; a receiving module configured to receive a training parameter adjustment value and a global model from the service node, wherein the training parameter adjustment value is determined based on a version difference between the first model version information and the second model version information of the global model; a parameter determination module, configured to determine a training parameter value based on the training parameter adjustment value; as well as The training module is configured to train the global model according to the training parameter values ​​to obtain another local model.

17. An electronic device comprising: at least one processing unit; as well as At least one memory, the at least one memory being coupled to the at least one processing unit and storing instructions for execution by the at least one processing unit, the instructions, when executed by the at least one processing unit, causing the device to perform the method according to any one of claims 1 to 8 or the method according to any one of claims 9 to 14.

18. A computer-readable storage medium having a computer program stored thereon, the computer program being executed by a processor to implement the method according to any one of claims 1 to 8 or the method according to any one of claims 9 to 14.

Images