Joint learning system and method with diverse feedback

Abstract

The present invention discloses a federated learning network including a server and a plurality of client devices. The server receives a parameter set of a local machine learning model from each client device in a subset of the plurality of client devices. The parameter sets from each client device in the subset are combined to generate an integrated parameter set. The server then calculates the parameter difference between the integrated parameter set and the parameter set of each client device in the subset. The server sends feedback to each client device in the subset. The feedback is applied during back propagation of the client. If the local parameters of a client are determined to be invalid multiple times, the client will be set as an outlier.

Description

Technical Field

[0001] The present invention generally relates to federated learning. Background Art

[0002] Machine learning has gradually found its way into many everyday applications. Due to the widespread use of machine learning techniques, deployed machine learning models are often extensively trained. Training allows machine learning systems to provide accurate results on large input sets. In particular, large training datasets are required to obtain accurate and general models for machine learning systems.

[0003] Machine learning algorithms often rely on direct and centrally accessible training data. Therefore, every training sample is accessible to the entity that effectively operates the model training. As a result, most machine learning as a service applications benefit from the user's own data (to enrich the training dataset) and explicitly require the user to disclose / make their data public. This creates an inherent tension between functionality and privacy.

[0004] Systems that attempt to federate the machine learning process by allowing the training process to be performed in a distributed manner without the need to centralize private data suffer from the amount of time required for data convergence, since data from different clients is often distributed in different places. Summary of the invention

[0005] According to one aspect of the present invention, a computer-implemented method for performing federated learning in a network comprising a server and multiple client devices, the computer-implemented method comprising: the server receiving a parameter set of a local machine learning model from each client device in a subset of the multiple client devices; the server combining the parameter set from each client device in the subset to generate an integrated parameter set; the server determining whether the parameter set from each client device in the subset of multiple client devices is valid based on the central limit theorem; the server calculating a parameter difference between the integrated parameter set and the parameter set of each client device in the subset of the multiple client devices; the server sending feedback to each client device in the subset of the multiple client devices, the feedback being based on a comparison of the parameter difference of each client device in the subset of the multiple devices with a first threshold.

[0006] Optionally, in any of the above aspects, the method further includes: the server deleting an invalid parameter set from the integrated parameter set, the invalid parameter set being determined to be invalid using the central limit theorem.

[0007] Optionally, in any of the above aspects, the method further includes: the server calculating the first threshold using a normal distribution based on the central limit theorem; and the server calculating the parameter difference from the first threshold.

[0008] Optionally, in any of the above aspects, the feedback includes the integrated parameter set, a normal distribution of the parameter difference, and the parameter difference when the parameter difference is less than or equal to the first threshold.

[0009] Optionally, in any of the above aspects, the feedback is proportional to the standard deviation of the normal distribution.

[0010] Optionally, in any of the above aspects, when the parameter difference is greater than the first threshold, the method further includes: the server records the number of times the parameter difference of each client device in the subset is greater than the first threshold; the server sends the parameter difference to each client device in the subset; when the number is greater than a second threshold, the server deletes the parameter set of each client device in the subset; the server recalculates the integrated parameter set to generate a recalculated integer parameter set; and recalculates the parameter difference between the recalculated integrated parameter set and the parameter set of each client device in the subset of the multiple client devices.

[0011] Optionally, in any of the above aspects, the method further includes: if the number of times is greater than the second threshold, the server sets the specific client device as an outlier; and the server deletes the outlier client device from the subset.

[0012] Optionally, in any of the above aspects, the setting includes determining the outlier based on the normal distribution and the first threshold.

[0013] Optionally, in any of the above aspects, the method also includes: storing the global machine learning model at the server; and the server iteratively updating the global machine learning model based on the parameter set received from each client device in the subset of the multiple client devices.

[0014] According to one aspect of the present invention, a server for performing federated learning in a network having multiple client devices, the server comprising: a non-transitory memory comprising instructions; one or more processors communicating with the memory, the one or more processors executing the instructions to: receive a parameter set of a local machine learning model from each client device in a subset of the multiple client devices; combine the parameter set from each client device in the subset to generate an integrated parameter set; the server determines whether the parameter set from each client device in the subset of multiple client devices is valid based on the central limit theorem; calculates a parameter difference between the integrated parameter set and the parameter set of each client device in the subset of the multiple client devices; and sends feedback to each client device in the subset of the multiple client devices, the feedback being based on a comparison of the parameter difference of each client device in the subset of the multiple devices with a first threshold.

[0015] According to one aspect of the present invention, a non-transitory computer-readable medium stores computer instructions for performing federated learning in a network including a server and multiple client devices, wherein the computer instructions, when executed by one or more processors, cause the server to perform the following steps: receiving a parameter set of a local machine learning model from each client device in a subset of the multiple client devices; combining the parameter set from each client device in the subset to generate an integrated parameter set; the server determining whether the parameter set from each client device in the subset of multiple client devices is valid based on the central limit theorem; calculating a parameter difference between the integrated parameter set and the parameter set of each client device in the subset of the multiple client devices; and sending feedback to each client device in the subset of the multiple client devices, wherein the feedback is based on a comparison of the parameter difference of each client device in the subset of the multiple devices with a first threshold.

[0016] According to one aspect of the present invention, a computer-implemented method for performing federated learning in a network including a server and multiple client devices, the computer-implemented method comprising: a client device receives feedback from the server, the feedback comprising at least one of an integrated parameter set and a parameter difference; the client device determines whether local parameters of the client device previously sent to the server are valid based on the received feedback; when it is determined that the local parameters are valid, the client device calculates a diversified parameter set based on the integrated parameter set, the parameter difference and the local parameters; when it is determined that the local parameters are valid, the client device trains a local machine learning model based on the feedback and the diversified parameter set calculated by the client device; the client device retrieves updated local parameters from the trained local machine learning model; and the client device sends the updated local parameters to the server.

[0017] Optionally, in any of the above aspects, when it is determined that the local parameter is invalid, the computer-implemented method also includes: the client device selects the integrated parameter, the local parameter of the client device previously sent to the server, or a parameter in the new parameter set based on data collected by the client device; the client device trains the local machine learning model based on the feedback from the server and the integrated parameter, the local parameter of the client device previously sent to the server, or a selected parameter in the new parameter set.

[0018] Optionally, in any of the above aspects, when it is determined that the local parameter is invalid, the computer-implemented method further comprises classifying the client device as an outlier.

[0019] Optionally, in any of the above aspects, the method further comprises calculating the diversified parameter set based on the integrated parameter set, the parameter difference and the local parameter.

[0020] Optionally, in any of the above aspects, when the difference between the integrated parameter set and the local parameters of the client device previously sent to the server is less than or equal to a first threshold, the local parameters of the client device are determined to be valid; when the difference between the integrated parameter set and the local parameters of the client device previously sent to the server is greater than the first threshold, the local parameters of the client device are determined to be invalid.

[0021] Optionally, in any of the above aspects, the method further comprises identifying the parameter difference and the number of times the local parameter is invalid from the feedback sent by the server.

[0022] Optionally, in any of the above aspects, when the number is greater than the second first threshold, it also includes setting the client device as an outlier.

[0023] Optionally, in any of the above aspects, the integrated parameter set received from the server includes a combination of local parameters from a subset of the multiple client devices; and the parameter difference is the difference between the integrated parameter set and the local parameters of the client device previously sent to the server.

[0024] Optionally, in any of the above aspects, the local parameters are collected by the client device.

[0025] According to one aspect of the present invention, a client device for performing federated learning in a network, the client device comprising: a non-transitory memory including instructions; one or more processors communicating with the memory, the one or more processors executing the instructions to: receive feedback from a server in the network, the feedback including at least one of an integrated parameter set and a parameter difference, and determine whether local parameters of the client device previously sent to the server are valid based on the received feedback; when it is determined that the local parameters are valid, calculate a diversified parameter set based on the integrated parameter set, the parameter difference and the local parameters; when it is determined that the local parameters are valid, train a local machine learning model based on the feedback and the diversified parameter set calculated by the client device; retrieve updated local parameters from the trained local machine learning model; and send the updated local parameters to the server.

[0026] According to one aspect of the present invention, a non-transitory computer-readable medium stores computer instructions for performing federated learning in a network including a server and multiple client devices, wherein the computer instructions, when executed by one or more processors, cause the client device to perform the following steps: receiving feedback from the server, the feedback including at least one of an integrated parameter set and a parameter difference, determining whether local parameters of the client device previously sent to the server are valid based on the received feedback; when it is determined that the local parameters are valid, calculating a diversified parameter set based on the integrated parameter set, the parameter difference and the local parameters; when it is determined that the local parameters are valid, training a local machine learning model based on the feedback and the diversified parameter set calculated by the client device; retrieving updated local parameters from the trained local machine learning model; and sending the updated local parameters to the server.

[0027] This summary briefly introduces some concepts that will be further described in the detailed description. This summary is neither intended to identify key features or essential features of the claimed subject matter nor to help determine the scope of the claimed subject matter. The claimed subject matter is not limited to implementations that address any or all of the shortcomings mentioned in the background technology. BRIEF DESCRIPTION OF THE DRAWINGS

[0028] The various aspects of the present invention are illustrated by way of example and not limitation in the accompanying figures, in which like references indicate similar elements.

[0029] Figure 1 An exemplary system for training one or more machine learning models is shown.

[0030] Figure 2 An exemplary system is shown that can be used to implement the methods and systems of the present invention.

[0031] Figure 3 An exemplary flow chart of a server processing information from a client device is shown.

[0032] Figure 4A and 4B An exemplary flow chart of a client device processing information from a server is shown.

[0033] Figure 4C Shown according to Figure 3 , 4A and 4B examples of server and client device processing systems.

[0034] Figure 5 An embodiment of a network node is shown.

[0035] Figure 6 A schematic diagram showing a general network component or computer system. DETAILED DESCRIPTION

[0036] The present invention will now be described with reference to the accompanying drawings, and the present invention generally relates to data transmission in a network.

[0037] Federated learning enables machine learning models to be trained using data across many edge or client devices, rather than using a dataset for training. These client devices perform local training and provide the training results to an aggregator device, such as a server, which aggregates or combines the training results from multiple client devices to update the machine learning model. The training results (updates) can then be redistributed or fed back to the client devices for subsequent training and / or use. Such a federated learning approach has many advantages, such as bandwidth savings (training data exists at the client device) and privacy (client device training data is not distributed). Therefore, the word "federated" used in this article means that multiple devices cooperate in learning, including one or more client devices. In addition, the word federated means that multiple devices can cooperate to build one or more machine learning models, and the devices use one or more models during the learning process. Here, the federated client devices may include some or all of the multiple client devices.

[0038] In the disclosed technology, after the server receives the training results (e.g., parameters of the local machine learning model) from the client device, the server combines or aggregates the training results from the client devices into an integrated or common result set (e.g., an integrated parameter set). The differences between the training results of each client device are compared with the integrated result set, and feedback is provided to the client device without collecting any additional data from the client device. In one embodiment, client devices with training results determined to be outliers are deleted and no further training results are provided to the server. Applying these techniques, the impact of data divergence can be minimized and the number of communications or iterations can be reduced to achieve data convergence.

[0039] It should be understood that the current embodiment of the present invention can be realized in many different forms, and the scope of the claims should not be interpreted as being limited to the embodiments set forth herein. On the contrary, these embodiments are provided to make the present invention thorough and complete, and to fully convey the inventive embodiment concepts to those skilled in the art. In fact, the present invention is intended to cover substitutes, modifications and equivalents of these embodiments included in the scope and spirit of the present invention as defined by the appended claims. In addition, in the following detailed description of the current embodiment of the present invention, many specific details are set forth in order to provide a thorough understanding. However, it is clear to those of ordinary skill in the art that the current embodiment of the present invention can be performed without providing these specific details.

[0040] Figure 1An exemplary system for training one or more machine learning models is shown. System 100 includes a client device 110 and a server 112 as part of a federated learning system. Server 112 and client 110 may be part of a system-wide machine learning model. In some implementations, server 112 may become client device 110 and client device 110 may become server 112. Client device 110 includes a database storing training data 108 and a local machine learning model 109. In one embodiment, training data 108 is collected and stored locally (local data or local data set) by individual client devices 110. In some implementations, system 100 may include more than one server 112. Server 112 may be used to access data from each local machine learning model 109 of the corresponding client device 110. For example, server 112 may access data parameters of a local machine learning model 109 trained by client device 110. Local machine learning model 109 may be, for example, a linear regression model, a logistic regression model, a support vector machine model, a neural network (e.g., a convolutional neural network, a recurrent neural network, etc.), or any other type of machine learning model. In some implementations, server 112 may be operable to communicate with client computing devices 110 over one or more networks (not shown).

[0041] The client computing devices 110 may each be operable to determine one or more local updates associated with the local machine learning model 109 based at least in part on the training data 108. For example, the training data 108 may be data stored locally on the client devices 110, respectively. The training data 108 may include audio files, image files, video files, typing history, location history, and / or various other suitable data. In some implementations, the training data 108 may be any data obtained through user interaction with the client computing device 110. As will be appreciated, the training data 108 is stored in a database or memory at each client device 110. Therefore, the training data 108 at each client device 110 is collected independently at each client device. In one embodiment, the client devices 110 may form a group or network of client devices 110, sharing some or all of the training data 108 in the group or network.

[0042] In one embodiment, the client device 110 may be used to provide data to the server 112. In one embodiment, the data provided to the server 112 does not include private data. As explained in more detail below, the client device 110 may provide parameter data and updates to the server 112. Such data may include data parameters collected or obtained from the local machine learning model 108 at each client device 110. In one embodiment, the data sent to the server 112 does not include training data or other private data collected or obtained by the client device 110 in order to protect the privacy of such data. In some implementations, one or more encryption techniques and / or other security techniques may be added to the training data to ensure that the data is obfuscated and that any inferable information is removed. In another embodiment, each client device 110 uses the same machine learning model (or algorithm) to process a local data set in the machine learning model to train the model.

[0043] The server 112 may receive data from each client device 110. The data received from the client device 110 may be stored in a database, such as the database 115, for processing. In one embodiment, the received data is network parameter data (or parameters) calculated by the local machine learning model 109 based on the local training data 109 of each client device 110. In another embodiment, the network parameter data received from each client device 110 is combined or aggregated to form an integrated data set (or common parameters). The integrated parameters may be updated during each iteration of the data received from the client device 110. In some implementations, the server 112 collects network parameter data from the client devices 110. The server 112 calculates the integrated parameters and determines the average of the difference from each client device 110 to the normal distribution, as explained below, to generate a single average difference for all client devices. The information (e.g., the integrated parameters) may then be sent back to the client device 110 for further processing and back propagation by the local machine learning model 108.

[0044] In another embodiment, the server 112 includes one or more global machine learning models 113. The global machine learning model 113 may be part of a machine learning system consisting of the server 112 and the client 110 (e.g., both the server and the client may be part of a machine learning model). For example, if the server 112 and the client 10 form a convolutional neural network (CNN), the client 110 consists of layers in the lower level of the CNN, and the server 112 consists of layers in the upper level. In this case, the server 112 and the client 110 can work together to accomplish the training objectives. In one embodiment, the global machine learning model 113 can be trained using data received from the client device 110. Similar to the local machine learning model 109, the model may be a linear regression model, a logistic regression model, a support vector machine model, a neural network (e.g., a convolutional neural network, a recursive neural network, etc.), or other suitable model.

[0045] Figure 2 An exemplary system is shown that can be used to implement the methods and systems of the present invention. System 200 uses a client-server architecture including one or more servers 112 communicating with one or more client devices 110 via a network 202 .

[0046] System 200 is Figure 1 An embodiment of the system 100 in the embodiment includes a server 112, such as a web server. In one embodiment, the server 112 can be implemented using a processor 214 and a memory 216. The server 112 can also include a network interface (not shown) for communicating with one or more client devices 110 via the network 202. The network interface can include any suitable components for interfacing with one or more networks 202, including, for example, a transmitter, a receiver, a port, a controller, an antenna, or other suitable components.

[0047] The processor 214 may include any suitable processing device, such as a microprocessor, a microcontroller, an integrated circuit, a logic device, or other suitable processing device. It should be understood that more than one processor may be included in the server 112. The memory 216 may be a computer-readable medium, including but not limited to a non-transitory computer-readable medium, RAM, ROM, a hard drive, a flash drive, or other memory device. The memory 216 may store information accessible to the processor 214, including computer-readable instructions executable by the processor 214. It should be understood that more than one memory or memory device may be used in the server 112.

[0048] The instructions stored in the memory 216 may be any set of instructions that, when executed by the processor 214, cause the processor 214 to perform operations. For example, on the client side, the processor 214 may execute instructions to calculate back propagation parameters. On the server side, the processor 214 may execute instructions to calculate integrated parameters and parameter differences based on local data received from the client device 110. In one embodiment, the parameter difference may be a number, a vector, a parameter set, etc. In one embodiment, the memory 216 may also store data that the processor 214 may retrieve, manipulate, create, or store. The data may include, for example, local data and updates from the client device 110. In one embodiment, the local data and / or updates are combined or integrated and stored as combined data 218. In one example, the combined data is a local parameter set received from each client device 110. For example, the sum or combination of local updates from multiple client devices 110 for a particular round of training may be temporarily stored. When the local machine learning model 108 processes additional rounds of training at the client device 110, further local updates are received and stored in the memory 216. The received updates may be continuously updated until the processing is completed. The combined data 218 may also be processed to calculate integrated parameters 220 and determine a difference 222 between the integrated parameters and the local parameter information sent from the client device 110, as further explained below. In another embodiment, the memory 216 may also store a global machine learning model 223. The global machine learning model 223 may be used to receive local data from the client device 110, combine the data, and update the global model based on the local updates.

[0049] Although the depicted embodiment shows memory 216, it should be understood that data may also be stored in one or more databases (in the same or different locations). In one example, one or more databases may be connected to server 112 via a high bandwidth LAN or WAN, or may also be connected to server 112 via network 202.

[0050] The server 112 may exchange data with the client devices 110 via the network 202. Any number of client devices 110 may be connected to the server 112 via the network 202. In one embodiment, a subset of the client devices 110 is connected or in communication with the server 112. The subset may include one or more client devices 110, including up to all of the plurality of client devices 110. Each client device 110 may be any suitable type of computing device, such as a general purpose computer, a dedicated computer, a laptop, a desktop, a mobile device, a navigation system, a smartphone, a tablet, a wearable computing device, a gaming console, a display with one or more processors, or other suitable computing device.

[0051] Each client device 110 may include one or more processors 214 and memory 216, similar to the server 112. The processor 214 may also include, for example, one or more central processing units (CPUs), graphics processing units (GPUs) dedicated to efficiently rendering images or performing other specialized calculations, and / or other processing devices. The memory 216 may include one or more computer-readable media and may store information accessible to one or more processors 232, including instructions 236 and data 238 that may be executed by one or more processors 232.

[0052] The instructions 236 may include instructions for the processor 214 to implement to determine one or more locally updated local machine learning models 224. For example, the processor 214 may perform one or more training techniques, such as error back propagation (or back-propagation), stochastic gradient descent, or other training techniques, to retrain or otherwise update the model based on the locally stored data 226 (or training data). In one embodiment, an application may be executed by the processor 214 to perform training on the data. In another embodiment, the training technique may be included as part of the operating system client device 110.

[0053] Local data 226 may also be stored in memory 216 of client device 110. Local data may include one or more training data examples to be used to solve one or more optimization problems. In some embodiments, the training data examples for each client device 110 may be unevenly distributed among the client devices so that client device 110 does not include a representative sample of the overall distribution of training data examples.

[0054] The local data 226 may also include parameters or updated parameters to be transmitted to the server 112. For example, the client device 110 may send parameters of the local machine learning model 108 to the server 112. In some implementations, the client device 110 may receive integrated parameters for training the local machine learning model 108 from the server 112. The integrated parameters are calculated at the server 112 based on the information received from the client device 110. In other embodiments, the client device 110 also receives difference information from the server 112, which indicates the difference between the integrated parameters of the client device 110 and the local parameters.

[0055] For example, in some implementations, client device 110 may receive integrated parameters (explained below) from server 112, train local machine learning model 108 based at least in part on a local data set to generate updated local values ​​for sending back to server 112, and generate diversified parameters based on the received integrated parameters and parameter differences. In some implementations, the local updates may be represented in a vector, matrix, or other suitable format.

[0056] In one embodiment, the client device 110 may include various input / output devices for providing and receiving information from a user, such as a touch screen, a touch pad, data entry keys, a speaker, and / or a microphone suitable for speech recognition. The client device 110 may also include a network interface for communicating with the server 112 via the network 202. The network interface may include any suitable components for interfacing with one or more network interfaces, including, for example, a transmitter, a receiver, a port, a controller, an antenna, or other suitable components.

[0057] The network 202 may be any type of communication network, such as a local area network (e.g., an intranet), a wide area network (e.g., the Internet), a cellular network, or some combination thereof. The network 202 may also include a direct connection between the client device 110 and the server 112. In general, the communication between the server 112 and the client device 110 may be performed through a network interface using any type of wired and / or wireless connection, using a variety of communication protocols (e.g., TCP / IP, HTTP, SMTP, FTP), encodings or formats (e.g., HTML, XML), and / or protection schemes (e.g., VPN, secure HTTP, SSL).

[0058] Figure 3 An exemplary flow chart for a server to process information from a client device. In an embodiment, the flow chart may be a computer-implemented method performed at least in part by hardware and / or software components shown in the various figures and as described herein. In an embodiment, the disclosed process may be performed by Figure 1 and 2 In one embodiment, a software component executed by one or more processors, such as processor 214 or processor 604, performs at least a portion of the process.

[0059] Typically, during federated learning, eligible client devices, such as client device 110, check in with a remote server, such as server 112. Server 112 then processes information from client devices 110 during several rounds or iterations. In each round, server 112 may select a subset of client devices 110 to participate in training. The selected client devices 110 (a subset of multiple client devices) first download the latest global machine learning model from server 112, train a local machine learning model based on a local data set at client device 110, and report model updates to server 112 for aggregation while leaving the training data on client device 110.

[0060] In traditional federated learning techniques, assuming a synchronous update scheme with multiple rounds of communication, there may be K client devices. The kth device has n k training samples, is the total number of samples. Generally speaking, the overall training goal is to minimize the loss function, expressed as:

[0061]

[0062] In the above equation, is the objective function (or cost function), and W represents the parameters that minimize the cost function. Using this technique, at iteration t, W (t) can be calculated as a weighted average of the weights collected from each client device such that:

[0063]

[0064] After the server collects updates from all K client devices in iteration t, the server executes a federated averaging algorithm (FEDAVG) to update the global machine learning model. The results can then be back-propagated to each client device.

[0065] However, existing federated learning methods do not address the challenges brought by heterogeneous local datasets. Since different users have different device usage patterns, the dataset samples and labels collected and stored on individual client devices may be distributed in different places. In this case, the performance of federated learning, especially FEDAVG, can greatly reduce the number of communications required for model accuracy and training convergence. More specifically, FEDAVG averages all model weights of client devices to update the global model at the remote server. Client devices have local datasets that may not reflect the true data distribution in the global view, which inevitably introduces noise and bias to the global model update. In addition, models trained locally on local datasets may differ significantly from each other. Aggregating these divergent models slows down convergence and significantly reduces model accuracy.

[0066] An embodiment of the federated learning system 200 provides a mechanism for processing different amounts of local data (e.g., training data) collected at individual client devices 110 while maintaining the privacy of the data. Through this mechanism, the impact of data divergence can be minimized, and the number of communications or iterations can be reduced to achieve data convergence (faster convergence). In general, in order to prevent training bias from occurring, the training data for the same target should be diversified. In this case, the target can be any type of object that the machine learning model is designed to detect, such as human eyes. For example, if the machine learning model is designed to detect eyes on a human face, the training data should include different types of faces. However, in the context of the present invention, different data (or diversified data) refers to data that is different from the training target of the model. Using the example above, the data may have a cat face or a dog face, which becomes noise to the model and affects convergence.

[0067] In one embodiment, the parameters of the local machine learning model collected at each client device 110 (also referred to herein as a parameter set) are sent to the server 112. The collected parameters are then integrated or combined (or aggregated) into an integrated parameter set (or a common parameter set). Based on the integrated parameter set, feedback can be sent to the client devices 110. In another embodiment, the server 112 can determine whether a particular client device 110 is an outlier and remove them from further processing. In yet another embodiment, the feedback provides compensation to the client devices 110 to reduce the diversity of the data.

[0068] As shown in the depicted embodiment, the server 112 processes information received from the client device 110 (or a subset of the client devices) and sends feedback to the client device 110 after processing the information. The processing of the information by the server 112 is divided into two stages, data processing at block 303 and processing for the client (e.g., agent k at block 301). For the purposes of the present invention, the terms "agent" and "client" (or client device) are synonymous.

[0069] In one embodiment, the data processing at block 303 includes the server 112 collecting parameters output by each client device 110, calculating the integrated parameter set 220 from the collected parameters, calculating the parameter difference 222, placing the average parameter difference from each client device 110 in a normal distribution, and determining a target value or threshold. In the context of the present invention, a normal distribution refers to a Gaussian distribution with a mean and a variance, where the mean may be non-zero. In another embodiment, the server 112 processes the data in the "Processing of Agent k" block 301. That is, the server 112 processes data for each client device 110 (i.e., agent k) based on the information processed in the data processing block 303. The processing of each client device 110 generally includes collecting the parameter differences of the specific client device 110 calculated in the data processing at block 303, deleting the parameters of the client device 110 when the target value or threshold is not met (i.e., the parameters are not within the expected range), and deleting the parameters of the client device 110 when the parameters are outside the expected range. After the processing at blocks 301 and 303 is completed, feedback is sent to the client device 110 at block 302. The processing at blocks 301, 302, and 303 at the server 112 will be explained in more detail as follows.

[0070] At step 304, the server 112 collects data output from the client devices 110 (e.g., local parameter data 226). In one embodiment, the client devices 110 are a subset of all client devices 110 in the system 200. In one embodiment, the subset of client devices 110 may be randomly selected. The data output by the client devices 110 and collected by the server 112 includes parameters determined as a result of training the local machine learning model 109. For example, the local machine learning model 109 may be trained using local training data collected by each client device 110 and stored at each client device. Figure 4A and 4B Data collection at the client device 110 and training of the local machine learning model 109 are discussed in more detail.

[0071] When the local parameter data 226 is collected and received at the server 112, the local parameter data 226 of each client device 110 is combined or aggregated into an integrated parameter set (or common parameters) at step 306. In one embodiment, the integrated parameter set is an aggregation of all local parameter data received by the server 112. Thus, the integrated parameter set includes different data sets collected from various different client devices 110. The integrated parameter set collected from the client devices 110 at iteration t may be generated by W (t) indicates that Where W is the integration function. In other words, if n1 = n2 = ... = n k , then W at iteration t is defined as The integrated parameter set provides a grouping (or combination or aggregation) of parameter data local to the client device 110 .

[0072] At step 308, the server 112 calculates the parameter difference 222 as the difference between the integrated parameter set 220 calculated at step 306 and the parameter set for each individual client device 110 (agent k) collected at step 304. That is, for each client device 110 in the subset of network client devices, the parameter difference 222 is calculated by the server 112. In one embodiment, the parameter difference 222 between the integrated parameter set 220 and the parameters of each client device 110 (agent k) is defined as in is the parameter difference 222, W (t) is the integrated parameter set 220. According to this definition, “||||” is the element-wise mean (average) of the differences. The variance between the integrated parameter set and the parameter is defined as

[0073] Then, at step 310, the mean of the parameter difference 222 calculated by the server 112 for each client device 110 is placed in a normal distribution based on the central limit theorem (CLT). The CLT states that when you have a population with a mean and a standard deviation, and you take a sufficiently large random sample from the population with replacement, the distribution of the sample means will approximate a normal distribution. In this case, assuming a sufficient number of clients, the parameter difference 222 follows The normal distribution of Then, at step 310, based on the DV (t) Determine the target value or threshold.

[0074] At block 301, where the server 112 processes data for each client device 110, the calculated parameter differences 222 corresponding to each client device 110 are collected. Then, at step 312, the collected parameter differences 222 will be used for continued processing. After collecting the parameter differences 222 for each client device 110, the parameter differences 222 for each client device 110 are compared to a threshold (or target value) at step 314. In statistics, the probability of a value exceeding |6σ| in a Gaussian distribution is low. Therefore, the |6σ| rule has been used to find outliers. The threshold is calculated using a normal distribution based on the CLT, where the threshold 'σ' is determined as If the difference is within |6σ|, or The parameters of the client device 110 will then be considered valid.

[0075] In one embodiment, the server 112 compares the parameter difference 222 with a threshold. When the comparison results in the parameter difference 222 being greater than the threshold (for a particular client device 110) at step 314, the server 112 deletes the parameter set collected from the client device 110 from further calculations at step 318 (during the current iteration t). In another embodiment, after deleting the parameter set for the current iteration t, the integrated parameter set calculated at step 306 is returned to the data processing block 303 of the server 112 for another round of parameter processing. In another embodiment, the number of times the parameter is invalid is counted at step 319. In one embodiment, when the parameter difference is invalid, the local parameter is also invalid. In yet another embodiment, after deleting the parameter set for the current iteration t, feedback is sent back from the server 112 to the client device 110 at step 320. The feedback includes at least the parameter difference 222 calculated at step 308 and the threshold 310. As discussed further below, the feedback provided to the client device 110 from block 302 may then be used to update (back propagate) the local data 226 (e.g., local parameters) of the local machine learning model 109 of the client device 110.

[0076] In another embodiment, at step 314, the server 112 compares the parameter difference 222 to a threshold value resulting in the parameter difference 222 being less than or equal to the threshold value (for a particular client device 110). In this case, the feedback sent back from the server 112 to the client device 110 includes the integrated parameter set 220 (W calculated at step 306). (t) ), parameter difference 222 Normal distribution (i.e., a differentiator) and the parameter difference 222 determined at step 310. Similar to the above, the feedback provided to the client device 110 from block 302 can then be used to update (back propagate) the local data 226 (e.g., local parameters) of the local machine learning model 109 of the client device 110.

[0077] Figure 4A and 4B An exemplary flow chart of a client device processing information from a server is shown. In an embodiment, the flow chart may be a computer-implemented method performed at least in part by hardware and / or software components shown in the various figures and as described herein. In an embodiment, the disclosed process may be performed by Figure 1 and 2 In one embodiment, a software component executed by one or more processors, such as processor 214 or processor 604, performs at least a portion of the process.

[0078] exist Figure 4A In step 402, feedback sent from the server 112 from block 302 is received at the client device 110. In one embodiment, the feedback includes the integrated parameter set 220 (W calculated at step 306). (t) ), parameter difference 222 Normal distribution (ie, a differentiator) and the parameter difference 222 output by the server 112 at block 302 .

[0079] At step 404, the client device 110 determines whether the local parameters 226 (sent to the server 112 in the previous iteration) are valid or invalid based on the feedback received from the server 112. When the received feedback includes the parameter difference 222 without the integrated parameter 220, the local parameters 226 are invalid, as in step 320 ( Figure 3 That is, when the server 112 compares the parameter difference 222 with the threshold value and the parameter difference 222 is greater than step 314 ( Figure 3 ), the local parameter 226 is invalid and the process proceeds to step 416 (hereinafter referred to as Figure 4B In one embodiment, the number of times the parameter difference 22 is greater than a threshold is counted. This number can then be used during processing to determine whether the local parameter, and therefore the client device 110, is an outlier, as discussed below.

[0080] In another embodiment, the local parameters are valid when the feedback received from the server 112 includes at least the integrated parameter 220 and the parameter difference 222. That is, when the server 112 compares the parameter difference 222 with the threshold value and the parameter difference 222 is less than or equal to step 314 ( Figure 3 ), the local parameters are valid and the process continues to step 406.

[0081] At step 406, client device 110 uses the feedback received from server 112 to calculate an updated set of parameters (also referred to herein as "diversified parameters"). In one embodiment, the diversified parameters are calculated as an integrated parameter set and a parameter difference. Specifically, the calculation is based on integrated parameter set 220 (W) sent as part of the feedback from server 112. (t) ) and parameter difference 222 In one embodiment, the diversity parameters (which will be used for backpropagation) will be calculated as the normal (Gaussian) distribution for the integrated parameter set (W (t) ). In this case, the diversification parameter can be calculated according to the equation Where α is a parameter of a positive integer. This normal distribution is proportional to the difference between the integrated parameters 222 and the local parameters 226 of the client device 110 in terms of mean and variation. In this case, the larger α is, the closer the diversified parameters are to the local parameters of the client device 110. The diversified parameters can then be used to calculate the updated parameters of the local machine learning model 109 of the client device 110 during backpropagation in the next iteration.

[0082] At step 408, the local machine learning model 109 is trained by back propagation using the feedback received from the server 112 and the diversified parameters calculated in step 406. In one embodiment, the local machine learning model 109 from block 417 ( Figure 4B ) can be used to train the local machine learning model 109, as discussed below.

[0083] Backpropagation uses an algorithm for changing the parameters (or weights) of a machine learning model. More specifically, backpropagation includes using stochastic gradient descent (SGD) to minimize or otherwise reduce a predetermined cost function. Through forward propagation, the learning model obtains a result based on the current parameters, which is compared with the target result. The difference or error between the result in the current iteration and the target result is sent back to the learning model through backpropagation so that the parameters can be adjusted. Then, at step 410, updated local parameters are obtained for the local machine learning model 109. If the error does not improve after a predetermined number of iterations, the learning iteration can be stopped. If the error improves, the iteration can continue until the error stabilizes.

[0084] In block 411, before sending the updated local parameters back to the server 112, the updated local parameter information is checked to determine whether the privacy of the information contained therein has been preserved at step 412. The updated local parameters may then be sent to the server 112 for continued processing.

[0085] refer to Figure 4B , when the server 112 at step 404 ( Figure 4A ) When the parameter difference 222 is compared with the threshold value and the parameter difference 222 is greater than the threshold value, the local parameter is invalid. The process continues to step 416 to determine whether the number of times the parameter difference 222 is invalid is greater than the empirical threshold value (n thr The server 112 counts the number of times the parameter difference 222 is invalid during processing ( Figure 3 When the number is greater than the threshold, the client device 110 is determined to be an outlier and the client device 110 is deleted from the subset of client devices 110 in the network. At block 411, this determination is reported to the server 112.

[0086] In another embodiment, when the number is less than or equal to the threshold, processing at the client device 110 continues to block 417. At block 417, parameters for the next iteration of training (back propagation) are selected and reported to the server 112. In one embodiment, the client device 110 selects the integrated parameters 220 at step 418 for back propagation at step 408. In another embodiment, the client device 110 selects a local parameter set (e.g., local parameter data 226) at step 420 for back propagation at step 408. In yet another embodiment, the client device 110 selects a new local parameter set at step 422 for back propagation at step 408. At step 424, the selected parameters are also reported back to the server 112.

[0087] Figure 4C Shown according to Figure 3 , 4A 4B and an exemplary embodiment of a server and client device processing system. Generally, the processing system shows a plurality of client devices 110 being processed by a server 112, wherein each client device 110 can be processed in parallel at the server 112, as shown in block 301. As shown, the processing system includes a server 112, which processes agents 1 to k after processing data from the client device 110 at block 303 (block 301). Figure 3 The processing of agents 1 to k at block 301 and the data processing at block 303 are described. It should also be understood that more than one server 112 may be used to implement the processing system and the present invention is not limited to the single server described. Figure 4A and 4B The description works.

[0088] Figure 5An embodiment of a network node that can implement a router is shown. Node (e.g., client device or server) 500 can be, for example, client device 110, server 112, or any other network component in system 100 or 200 as described above. Node 500 may include: multiple input / output ports 510 / 530 and / or receivers (Rx) 512 and transmitters (Tx) 532 for receiving and transmitting data from other nodes; processor 520 for processing data and determining which node to send the data to; and memory. Node 500 can also generate and distribute data in the form of data packets in the communication system.

[0089] Although processor 520 is shown as a single processor, processor 520 is not limited thereto and may include multiple processors. Processor 520 may be implemented as one or more central processing unit (CPU) chips, cores (e.g., multi-core processors), field-programmable gate arrays (FPGAs), application specific integrated circuits (ASICs), and / or digital signal processors (DSPs), and / or may be part of one or more ASICs. In addition, processor 520 may be implemented using hardware, software, or both. Memory 522 may be used to store routing tables, forwarding tables, or other tables or information disclosed herein.

[0090] The memory 522 may also store instructions 523, wherein the processor 520 executes the instructions 523 to implement any operation disclosed herein, including a federated learning operation. Alternatively, in other embodiments, the instructions 523 may be stored in an onboard memory (not shown) of the processor 520. Although the memory 522 is shown as a single memory, the memory 522 may be implemented as a combination of a read-only memory (ROM), a random access memory (RAM), or an auxiliary memory (e.g., one or more disk drives or tape drives for non-volatile storage of data). The techniques described above may be implemented on any general-purpose network component, such as a computer or network component having sufficient processing power, memory resources, and network throughput capabilities to handle the necessary workload imposed on it.

[0091] Figure 6An exemplary embodiment of a computing system for implementing an embodiment of the present invention is shown. Computer system 600 includes a processor 604 and a memory 608, which communicate with each other and with other components via a bus 612. Bus 612 may include any of several types of bus structures, including but not limited to a memory bus, a memory controller, a peripheral bus, a local bus, and any combination thereof using any of a variety of bus architectures.

[0092] The memory 608 may include various components (e.g., machine-readable media), including, but not limited to, random access memory components, read-only components, and any combination thereof. In one example, a basic input / output system 616 (BIOS) may be stored in the memory 608, including, for example, basic routines that help transfer information between elements within the computer system 600 during startup. The memory 608 may also include instructions (e.g., software) 820 (e.g., stored on one or more machine-readable media) that embody any one or more aspects and / or methods of the present invention. In another example, the memory 608 may also include any number of program modules, including, but not limited to, an operating system, one or more application programs, other program modules, program data, and any combination thereof.

[0093] The computer system 600 may also include a storage device 624. Examples of storage devices (e.g., storage device 624) include, but are not limited to, hard disk drives, disk drives, optical disk drives combined with optical media, solid-state memory devices, and any combination thereof. The storage device 624 may be connected to the bus 612 via a suitable interface (not shown). Exemplary interfaces include, but are not limited to, SCSI, advanced technology attachment (ATA), serial ATA, universal serial bus (USB), IEEE 1394 (Firewire), and any combination thereof. In one example, the storage device 624 (or one or more of its components) may be removably interfaced with the computer system 600 (e.g., via an external port connector (not shown)). Specifically, the storage device 624 and the associated machine-readable medium 628 may provide non-volatile and / or volatile storage of machine-readable instructions, data structures, program modules, and / or other data for the computer system 600. In one example, the software or instructions 620 may reside in whole or in part in the machine-readable medium 628. In another example, the instructions 620 may reside completely or partially within the processor 604 and / or within the memory 608. It should be understood that the instructions 620 may reside with the processor 604 and / or the memory 608. Figure 5 The same as instruction 523.

[0094] The computer system 600 may also include an input device 632. In one example, a user of the computer system 600 may input commands and / or other information into the computer system 600 via the input device 632. Examples of the input device 632 include, but are not limited to, an alphanumeric input device (e.g., a keyboard), a pointing device, a joystick, a game pad, an audio input device (e.g., a microphone, a voice response system, etc.), a cursor control device (e.g., a mouse), a touch pad, an optical scanner, a video capture device (e.g., a still camera, a video camera), a touch screen, and any combination thereof. The input device 632 may interface with the bus 612 via any of a variety of interfaces (not shown), including, but not limited to, a serial interface, a parallel interface, a game port, a USB interface, a FireWire interface, a direct interface to the bus 612, and any combination thereof. The input device 632 may include a touch screen interface, which may be part of the display 636 or separate from the display, as will be discussed further below. The input device 632 may be used as a user selection device to select one or more graphical representations in the graphical interface as described above.

[0095] The user may also input commands and / or other information to the computer system 600 through a storage device 624 (e.g., a removable disk drive, a flash drive, etc.) and / or a network interface device 640. Network interface devices such as the network interface device 640 may be used to connect the computer system 600 to one or more networks (e.g., network 644) of various networks and one or more remote devices 648 connected thereto. Examples of network interface devices include, but are not limited to, network interface cards (e.g., mobile network interface cards, LAN cards), modems, and any combination thereof. Examples of networks include, but are not limited to, wide area networks (e.g., the Internet, enterprise networks), local area networks (e.g., networks associated with offices, buildings, campuses, or other relatively small geographic spaces), telephone networks, data networks associated with telephone / voice providers (e.g., mobile communications provider data and / or voice networks), direct connections between two computing devices, and any combination thereof. Networks such as the network 644 may employ wired and / or wireless communication modes. In general, any network topology may be used. Information (e.g., data, instructions 620, etc.) may be transmitted to and / or from the computer system 600 through the network interface device 640.

[0096] Computer system 600 may also include a video display adapter 652 for transmitting displayable images to a display device, such as display device 636. Examples of display devices include, but are not limited to, liquid crystal displays (LCD), cathode ray tubes (CRT), plasma displays, light emitting diodes (LED) displays, and any combination thereof. Display adapter 652 and display device 636 may be used in conjunction with processor 604 to provide graphical representations of various aspects of the present invention. In addition to the display device, computer system 600 may also include one or more other peripheral output devices, including but not limited to audio speakers, printers, and any combination thereof. Such peripheral output devices may be connected to bus 612 via peripheral interface 656. Examples of peripheral interfaces include, but are not limited to, serial ports, USB connections, FireWire connections, parallel connections, and any combination thereof.

[0097] It should be understood that the subject matter of the present invention can be embodied in many different ways and should not be construed as being limited to the embodiments set forth herein. On the contrary, these embodiments are provided to make this subject matter thorough and complete, and to fully convey the present invention to those skilled in the art. In fact, this subject matter is intended to cover substitutes, modifications and equivalents of these embodiments within the scope and spirit of this subject matter as defined by the appended claims. In addition, in the following detailed description of this subject matter, many specific details are set forth in order to provide a thorough understanding of this subject matter. However, it is clear to those of ordinary skill in the art that this subject matter can be performed without providing these specific details.

[0098] Various aspects of the present invention are described herein with reference to the flowcharts and / or block diagrams of the methods, devices (systems) and computer program products according to embodiments of the present invention. It should be understood that each square frame of the flowchart and / or block diagram and the combination of square frames in the flowchart and / or block diagram can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, a special-purpose computer or other programmable data processing device to generate a machine so that the instructions executed by the processor of the computer or other programmable instruction execution device generate a mechanism for implementing the function / action specified in the flowchart and / or block diagram square frame.

[0099] Computer-readable non-transitory media include various types of computer-readable media, including magnetic storage media, optical storage media, and solid-state storage media, and specifically do not include signals. It should be understood that the software can be installed in the device and sold with the device. Alternatively, the software can be obtained and loaded into the device, including through optical disk media or from any network or distribution system, including, for example, from a server owned by the creator of the software or from a server that the creator of the software does not own but uses. For example, the software can be stored on a server for distribution over the Internet.

[0100] Computer-readable storage media do not include propagation signals themselves, can be accessed by computers and / or processors, and include removable and / or non-removable volatile and non-volatile internal and / or external media. For computers, various types of storage media hold stored data in any suitable digital format. Those skilled in the art will appreciate that other types of computer-readable media, such as compression drives, solid-state hard drives, magnetic tapes, flash cards, flash drives, boxes, etc., can be used to store computer-executable instructions for performing the novel methods (actions) of the disclosed architecture.

[0101] The terms used herein are for the purpose of describing specific aspects only and are not intended to limit the present invention. Unless the context clearly indicates otherwise, the singular forms "a", "an" and "the" used herein are intended to include plural meanings. It should also be understood that the terms "comprises" and / or "comprising" used in this specification specify the presence of stated features, integers, steps, operations, elements and / or parts, but do not exclude the presence or addition of one or more other features, integers, steps, operations, elements, parts and / or combinations thereof.

[0102] The description of the present invention has been presented for the purpose of illustration and description and is not intended to be exhaustive or to limit the present invention in any disclosed manner. Various modifications and variations will be apparent to those of ordinary skill in the art without departing from the scope and spirit of the present invention. Various aspects of the present invention herein are selected and described in order to best explain the principles and practical application of the present invention and to enable those of ordinary skill in the art to understand the present invention through various modifications suitable for the specific purpose contemplated.

[0103] For the purposes of this document, each process associated with the disclosed technology can be performed continuously and by one or more computing devices. Each step in the process can be performed by the same or different computing devices used in other steps, and each step is not necessarily performed by a single computing device.

[0104] Although the subject matter has been described in language specific to structural features and / or method actions, it should be understood that the subject matter defined in the appended claims is not necessarily limited to the specific features or actions described above. Instead, the specific features and actions described above are disclosed as exemplary ways to implement the claims.

Claims

1. A computer-implemented method for performing federated learning in a network comprising a server and a plurality of client devices, characterized in that The computer-implemented method comprises: The server receives a set of parameters of a local machine learning model from each client device in a subset of the plurality of client devices; the server combining the parameter sets from the each client device in the subset to generate an integrated parameter set; The server calculates a parameter difference between the integrated parameter set and the parameter set for each client device in the subset of the plurality of client devices; The server determines whether the parameter set of each client device from the subset of multiple client devices is valid according to the central limit theorem; The server sends feedback to each client device in the subset of multiple client devices, and the feedback is based on the comparison of the parameter difference of each client device in the subset of the multiple devices with a first threshold; the comparison of the parameter difference with the first threshold is used to indicate whether the parameter set of each client device is valid.

2. The computer-implemented method of claim 1, wherein: Also includes: The server deletes invalid parameter sets from the integrated parameter set, the invalid parameter sets being determined to be invalid using the central limit theorem.

3. The computer-implemented method of claim 1 , wherein: Also includes: The server places the average value of the parameter difference calculated by the client device into a normal distribution based on the central limit theorem, and uses the normal distribution to calculate the first threshold; The server calculates the parameter difference of each client device in the subset and the first threshold.

4. The computer-implemented method according to any one of claims 1 to 3, characterized in that: The feedback includes the integrated parameter set, a normal distribution of the parameter difference, and the parameter difference when the parameter difference is less than or equal to the first threshold.

5. The computer-implemented method of claim 4, wherein: The feedback is proportional to the standard deviation of the normal distribution.

6. The computer-implemented method of claim 3, wherein: When the parameter difference is greater than the first threshold, the computer-implemented method further comprises: The server records the number of times that the parameter difference of each client device in the subset is greater than the first threshold; The server sends the parameter difference to each client device in the subset; When the number of times is greater than a second threshold, the server deletes the parameter set of each client device in the subset; The server recalculates the integrated parameter set to generate a recalculated integrated parameter set; The server recalculates the parameter differences between the recalculated integrated parameter set and the parameter set for each client device in the subset of the plurality of client devices.

7. The computer-implemented method of claim 6, wherein: Also includes: If the number is greater than the second threshold, the server sets the specific client device as an outlier; The server removes stray client devices from the subset.

8. The computer-implemented method of claim 7, wherein: The setting includes determining the outlier based on the normal distribution and the first threshold.

9. The computer-implemented method of claim 1, wherein: Also includes: storing a global machine learning model at the server; The server iteratively updates the global machine learning model based on the set of parameters received from each client device in the subset of the plurality of client devices.

10. A server for performing federated learning in a network having multiple client devices, characterized in that The server comprises: A non-transitory memory including instructions; one or more processors in communication with the memory, the one or more processors executing the instructions to: receiving a set of parameters for a local machine learning model from each client device in a subset of the plurality of client devices; combining said parameter sets from said each client device in said subset to generate an integrated parameter set; calculating a parameter difference between the integrated parameter set and the parameter set for each client device in the subset of the plurality of client devices; The server determines whether the parameter set of each client device from the subset of multiple client devices is valid according to the central limit theorem; Feedback is sent to each client device in the subset of the plurality of client devices, the feedback being based on a comparison of the parameter difference of each client device in the subset of the plurality of devices with a first threshold; the comparison of the parameter difference with the first threshold being used to indicate whether the parameter set of each client device is valid.

11. The server according to claim 10, characterized in that: The one or more processors also execute the instructions to: Invalid parameter sets are deleted from the integrated parameter set, the invalid parameter sets being determined to be invalid using the central limit theorem.

12. The server according to claim 10, characterized in that: The one or more processors also execute the instructions to: placing the average value of the parameter difference calculated by the client device into a normal distribution based on the central limit theorem, and using the normal distribution to calculate the first threshold; The parameter difference between each client device in the subset and the first threshold is calculated.

13. The server according to any one of claims 10 to 12, characterized in that: The feedback includes the integrated parameter set, a normal distribution of the parameter difference, and the parameter difference when the parameter difference is less than or equal to the first threshold.

14. The server according to claim 13, characterized in that: The feedback is proportional to the standard deviation of the normal distribution.

15. The server according to claim 12, characterized in that: When the parameter difference is greater than the first threshold, the one or more processors further execute the instructions to: Recording the number of times the parameter difference of each client device in the subset is greater than the first threshold; sending the parameter difference to each of the client devices in the subset; When the number of times is greater than a second threshold, deleting the parameter set of each client device in the subset, recalculating the integrated parameter set to generate a recalculated integrated parameter set; The parameter differences between the recomputed integrated parameter set and the parameter set for each client device in the subset of the plurality of client devices are recomputed.

16. The server according to claim 15, characterized in that For each client device in the subset for which the number of times is greater than the second threshold, the one or more processors further execute the instructions to: If the number is greater than the second threshold, setting the specific client device as an outlier; The stray client device is removed from the subset.

17. The server according to claim 16, characterized in that: The one or more processors also execute the instructions to determine the outlier based on the normal distribution and the first threshold.

18. The server according to claim 10, characterized in that: The one or more processors also execute the instructions to: Store global machine learning models; The global machine learning model is iteratively updated based on the set of parameters received from each client device in the subset of the plurality of client devices.

19. A non-transitory computer readable medium, characterized in that storing computer instructions for performing federated learning in a network including a server and a plurality of client devices, the computer instructions, when executed by one or more processors, causing the server to perform the following steps: receiving a set of parameters for a local machine learning model from each client device in a subset of the plurality of client devices; combining said parameter sets from said each client device in said subset to generate an integrated parameter set; calculating a parameter difference between the integrated parameter set and the parameter set for each client device in the subset of the plurality of client devices; The server determines whether the parameter set of each client device from the subset of multiple client devices is valid according to the central limit theorem; sending feedback to each client device in the subset of a plurality of client devices, the feedback being based on a comparison of the parameter difference of each client device in the subset of the plurality of devices with a first threshold; The comparison of the parameter difference with the first threshold is used to indicate whether the parameter set of each client device is valid.

20. The non-transitory computer readable medium of claim 19, wherein: The server is also caused to perform the following steps: Invalid parameter sets are deleted from the integrated parameter set, the invalid parameter sets being determined to be invalid using the central limit theorem.

21. The non-transitory computer readable medium of claim 19, wherein: The server is also caused to perform the following steps: placing the average value of the parameter difference calculated by the client device into a normal distribution based on the central limit theorem, and using the normal distribution to calculate the first threshold; The parameter difference between each client device in the subset and the first threshold is calculated.

22. The non-transitory computer readable medium according to any one of claims 19 to 21, wherein: The feedback includes the integrated parameter set, a normal distribution of the parameter difference, and the parameter difference when the parameter difference is less than or equal to the first threshold.

23. The non-transitory computer readable medium of claim 22, wherein: The feedback is proportional to the standard deviation of the normal distribution.

24. The non-transitory computer readable medium of claim 21, wherein: When the parameter difference is greater than the first threshold, the server is further caused to perform the following steps: Recording the number of times the parameter difference of each client device in the subset is greater than the first threshold; sending the parameter difference to each of the client devices in the subset; When the number of times is greater than a second threshold, deleting the parameter set of each client device in the subset, recalculating the integrated parameter set to generate a recalculated integrated parameter set; The parameter differences between the recomputed integrated parameter set and the parameter set for each client device in the subset of the plurality of client devices are recomputed.

25. The non-transitory computer readable medium of claim 24, wherein: For each client device in the subset whose number of times is greater than the second threshold, the server is further caused to perform the following steps: If the number is greater than the second threshold, setting the specific client device as an outlier; The stray client device is removed from the subset.

26. The non-transitory computer readable medium of claim 25, wherein: The setting includes determining the outlier based on the normal distribution and the first threshold.

27. The non-transitory computer readable medium of claim 19, wherein: The server is also caused to perform the following steps: Store global machine learning models; The global machine learning model is iteratively updated based on the set of parameters received from each client device in the subset of the plurality of client devices.

28. A computer-implemented method for performing federated learning in a network comprising a server and a plurality of client devices, characterized in that The computer-implemented method comprises: The client device receives feedback from the server, the feedback comprising at least one of an integrated parameter set and a parameter difference, the feedback being based on a comparison of the parameter difference of each client device in a subset of the plurality of devices with a first threshold; the comparison of the parameter difference with the first threshold being used to indicate whether the parameter set of each client device is valid; the integrated parameter set being obtained by combining the parameter sets of each client device in the subset; the parameter difference being obtained by calculating a parameter difference between the integrated parameter set and the parameter set of each client device in the subset of the plurality of client devices; The client device determines, based on the received feedback, whether local parameters of the client device previously sent to the server are valid; When it is determined that the local parameters are valid, the client device calculates a diversified parameter set based on the integrated parameter set, the parameter difference and the local parameters; When it is determined that the local parameters are valid, the client device trains a local machine learning model based on the feedback and the diverse set of parameters calculated by the client device; The client device retrieves updated local parameters from the trained local machine learning model; The client device sends the updated local parameters to the server.

29. The computer-implemented method of claim 28, wherein: When it is determined that the local parameter is invalid, the computer-implemented method further comprises: The client device selects the integrated parameters, the local parameters of the client device previously sent to the server, or parameters in an updated parameter set based on data collected by the client device; The client device trains the local machine learning model based on the feedback from the server and the integrated parameters, the local parameters of the client device previously sent to the server, or selected parameters from the updated parameter set.

30. The computer-implemented method of claim 28, wherein: When the local parameters are determined to be invalid, the computer-implemented method further includes classifying the client device as an outlier.

31. The computer-implemented method of claim 29, wherein: determining that the local parameters of the client device are valid when a difference between the integrated parameter set and the local parameters of the client device previously sent to the server is less than or equal to a first threshold; When the difference between the integrated parameter set and the local parameters of the client device previously sent to the server is greater than a first threshold, it is determined that the local parameters of the client device are invalid.

32. The computer-implemented method of claim 31 , wherein: The method also includes identifying the parameter difference and the number of times the local parameter is invalid from the feedback sent by the server.

33. The computer-implemented method of claim 32, wherein: When the number is greater than a second threshold, the computer-implemented method further includes setting the client device as an outlier.

34. The computer-implemented method of claim 28, wherein: The integrated parameter set received from the server comprises a combination of local parameters from a subset of the plurality of client devices; The parameter difference is the difference between the integrated parameter set and the local parameters of the client device previously sent to the server.

35. The computer-implemented method of claim 28, wherein: The local parameters are collected by the client device.

36. A client device for performing joint learning in a network, characterized in that: The client device comprises: A non-transitory memory including instructions; one or more processors in communication with the memory, the one or more processors executing the instructions to: receiving feedback from a server in the network, the feedback comprising at least one of an integrated parameter set and a parameter difference, the feedback being based on a comparison of the parameter difference of each client device in a subset of the plurality of devices with a first threshold; the comparison of the parameter difference with the first threshold being used to indicate whether the parameter set of each client device is valid; the integrated parameter set being obtained by combining the parameter sets of each client device in the subset; the parameter difference being obtained by calculating a parameter difference between the integrated parameter set and the parameter set of each client device in the subset of the plurality of client devices; determining, based on the received feedback, whether local parameters of the client device previously sent to the server are valid; When it is determined that the local parameter is valid, calculating a diversified parameter set based on the integrated parameter set, the parameter difference and the local parameter; When it is determined that the local parameters are valid, training a local machine learning model based on the feedback and the diverse set of parameters calculated by the client device; Retrieve updated local parameters from the trained local machine learning model; The updated local parameters are sent to the server.

37. The client device according to claim 36, characterized in that When it is determined that the local parameter is invalid, the one or more processors further execute the instructions to: selecting the integrated parameters, the local parameters of the client device previously sent to the server, or parameters in an updated parameter set based on data collected by the client device; The local machine learning model is trained based on the feedback from the server and the integrated parameters, the local parameters of the client device previously sent to the server, or selected parameters from the updated parameter set.

38. The client device according to claim 36, characterized in that When the local parameter is determined to be invalid, the client device further comprises classifying the client device as an outlier.

39. The client device according to claim 36, characterized in that determining that the local parameters of the client device are valid when a difference between the integrated parameter set and the local parameters of the client device previously sent to the server is less than or equal to a first threshold; When the difference between the integrated parameter set and the local parameters of the client device previously sent to the server is greater than a first threshold, it is determined that the local parameters of the client device are invalid.

40. The client device according to claim 39, characterized in that The one or more processors also execute the instructions to identify the parameter difference and a number of times the local parameter is invalid from the feedback sent by the server.

41. The client device according to claim 40, characterized in that When the number is greater than a second threshold, the one or more processors further execute the instructions to set the client device as an outlier.

42. The client device according to claim 36, characterized in that The integrated parameter set received from the server includes a combination of local parameters from the client device and a subset of other plurality of client devices; The parameter difference is the difference between the integrated parameter set and the local parameters of the client device previously sent to the server.

43. The client device according to claim 36, characterized in that The one or more processors also execute the instructions to collect the local parameters.

44. A non-transitory computer readable medium, characterized in that Computer instructions are stored for performing federated learning in a network including a server and a plurality of client devices, the computer instructions, when executed by one or more processors, causing the client devices to perform the following steps: receiving feedback from the server, the feedback comprising at least one of an integrated parameter set and a parameter difference, the feedback based on a comparison of the parameter difference to a first threshold for each client device in a subset of the plurality of devices; The comparison of the parameter difference with the first threshold is used to indicate whether the parameter set of each client device is valid; the integrated parameter set is obtained by combining the parameter sets of each client device from the subset; The parameter difference is obtained by calculating a parameter difference between the integrated parameter set and the parameter set of each client device in the subset of the plurality of client devices; determining, based on the received feedback, whether local parameters of the client device previously sent to the server are valid; When it is determined that the local parameter is valid, calculating a diversified parameter set based on the integrated parameter set, the parameter difference and the local parameter; When it is determined that the local parameters are valid, training a local machine learning model based on the feedback and the diverse set of parameters calculated by the client device; Retrieve updated local parameters from the trained local machine learning model; The updated local parameters are sent to the server.

45. The non-transitory computer readable medium of claim 44, wherein: When it is determined that the local parameter is invalid, the client device is further caused to perform the following steps: selecting the integrated parameters, the local parameters of the client device previously sent to the server, or parameters in an updated parameter set based on data collected by the client device; The local machine learning model is trained based on the feedback from the server and the integrated parameters, the local parameters of the client device previously sent to the server, or selected parameters from the updated parameter set.

46. ​​The non-transitory computer readable medium of claim 45, wherein: When it is determined that the local parameter is invalid, the client device is further caused to perform a step of classifying the client device as an outlier.

47. The non-transitory computer readable medium of claim 44, wherein: determining that the local parameters of the client device are valid when a difference between the integrated parameter set and the local parameters of the client device previously sent to the server is less than or equal to a first threshold; When the difference between the integrated parameter set and the local parameters of the client device previously sent to the server is greater than a first threshold, it is determined that the local parameters of the client device are invalid.

48. The non-transitory computer readable medium of claim 47, wherein: The client device is also caused to perform the step of identifying the parameter difference and the number of times the local parameter is invalid from the feedback sent by the server.

49. The non-transitory computer readable medium of claim 48, wherein: When the number of times is greater than a second threshold, the client device is further caused to execute a step of setting the client device as an outlier.

50. The non-transitory computer readable medium of claim 44, wherein: The integrated parameter set received from the server comprises a combination of local parameters from a subset of the plurality of client devices; The parameter difference is the difference between the integrated parameter set and the local parameters of the client device previously sent to the server.

51. The non-transitory computer readable medium of claim 44, wherein: The client device is also caused to perform a step of collecting the local parameters by the client device.

Images