Federal learning with model diversity

Abstract

And federated learning with model diversity is realized. Methods and systems for federated learning in a machine learning environment are disclosed. At least a portion of the machine learning models maintained by the plurality of servers is sent from the server to the plurality of clients, thereby generating a plurality of local machine learning models. At each client, a plurality of local machine learning models are trained with locally stored data locally stored at the respective client. A respective loss for each of the plurality of local machine learning models is determined, and a respective weight for each of the plurality of local machine learning models is updated. The respective updated weights from each client are transmitted to the server without transmitting the locally stored data of the client. At the server, a plurality of server-maintained machine learning models are trained with the updated weights sent from each client.

Description

Technical Field

[0001] The present disclosure relates to methods and systems for federated learning with diversity in machine learning models. Background Art

[0002] Federated learning (also known as collaborative learning) is a machine learning technique that trains machine learning algorithms via multiple independent sessions, each using its own data set. Federated learning aims to train global machine learning algorithms (such as deep neural networks) based on multiple local data sets contained in local nodes (also known as clients) without explicitly exchanging data samples. The learning task is solved by a federation of participating devices coordinated by a central server. Each participating device (client) has a local training data set that is not uploaded to the server. Instead, each client calculates an update to the current global model maintained by the server. The client passes the update to the server instead of the training data set for updating the global model. The resulting shared model can be trained by learning from the training of the client, allowing the user to obtain the benefits of a shared model trained from the client's data without having to transmit or centrally store data from the client. This has particular practicality in situations where the exchange of sensitive or personal data (e.g., medical information, IoT devices, personal devices such as smart phones) is prohibited. Summary of the invention

[0003] According to one embodiment, a method for training a neural network using federated learning is provided. At least a portion of a machine learning model maintained by a plurality of servers is sent from the server to a plurality of clients, thereby generating a plurality of local machine learning models. At each client, the plurality of local machine learning models are trained with locally stored data stored locally at the respective client. The respective loss of each of the plurality of local machine learning models is determined, and the respective weights of each of the plurality of local machine learning models are updated. The respective updated weights from each client are transmitted to the server without transmitting the locally stored data of the client. At the server, the machine learning models maintained by the plurality of servers are trained with the updated weights sent from each client. In one embodiment, a non-transitory computer-readable storage medium tangibly embodies a computer-readable program code having computer-readable instructions, which, when executed, causes a computing system to train a neural network using federated learning by performing the same operations. BRIEF DESCRIPTION OF THE DRAWINGS

[0004] Figure 1 A system for training a neural network according to one embodiment is shown.

[0005] Figure 2 A computer-implemented method for training and utilizing a neural network is shown according to one embodiment.

[0006] Figure 3A An example diagram or layout of a federated learning system according to one embodiment is shown; Figure 3B A flowchart of a method for training a neural network via federated learning is shown.

[0007] Figure 4 A schematic diagram of a deep neural network according to one embodiment is shown, the deep neural network having an input layer, multiple hidden layers, and nodes in an output layer.

[0008] Figure 5 Depicted is a schematic diagram of the interaction between a computer controlled machine and a control system according to one embodiment.

[0009] Figure 6 Depicted is a diagram according to an embodiment Figure 5 Schematic diagram of a control system configured to control a vehicle, which can be a partially autonomous vehicle, a fully autonomous vehicle, a partially autonomous robot, or a fully autonomous robot.

[0010] Figure 7 Depicted Figure 5 Schematic diagram of a control system configured to control a manufacturing machine (such as a punch tool, a tool, or a gun drill) of a manufacturing system (such as part of a production line).

[0011] Figure 8 Depicted Figure 5 Schematic diagram of a control system configured to control a power tool (such as a power drill or driver) having at least a partially autonomous mode.

[0012] Fig. 9 Depicted Figure 5 Schematic diagram of a control system configured to control an automated personal assistant.

[0013] Fig.10 Depicted Figure 5 Schematic diagram of a control system configured to control a surveillance system (such as a controlled access system or a monitoring system).

[0014] Fig.11 Depicted Figure 5 Schematic diagram of a control system configured to control an imaging system (eg, an MRI device, an x-ray imaging device, or an ultrasound device). DETAILED DESCRIPTION

[0015] Embodiments of the present disclosure are described herein. However, it should be understood that the disclosed embodiments are merely examples, and other embodiments may take various and alternative forms. The drawings are not necessarily to scale; some features may be enlarged or minimized to show the details of a particular component. Therefore, the specific structural and functional details disclosed herein should not be interpreted as restrictive, but merely as a representative basis for teaching those skilled in the art to adopt the embodiments in various ways. As will be understood by those of ordinary skill in the art, the various features illustrated and described with reference to any of the drawings may be combined with the features illustrated in one or more of the other drawings to produce embodiments that are not explicitly illustrated or described. The combination of the illustrated features provides representative embodiments for typical applications. However, for specific applications or embodiments, various combinations and modifications of features consistent with the teachings of the present disclosure may be desirable.

[0016] As used herein, "a", "an", and "the" refer to both singular and plural references unless the context clearly dictates otherwise. For example, a "processor" programmed to perform various functions refers to one processor programmed to perform each function, or more than one processor that are collectively programmed to perform each of the various functions.

[0017] The present disclosure relates to federated learning. The "server" of a federated learning system referred to herein refers to a centralized server (or servers) that communicates with a client to exchange data with it. For example, one or more servers in the cloud or remote from an end user may constitute a server. The "client" of a federated learning system referred to herein refers to a local node or device corresponding to a specific end user. For example, a smart phone, an IoT device, etc. will constitute a client. Each of the server and the client can utilize a corresponding computer system to perform machine learning training, such as those described herein.

[0018] Federated learning (also known as collaborative learning) is a machine learning technique that trains a machine learning algorithm via multiple independent sessions, each using its own dataset. Federated learning aims to train a global machine learning algorithm (e.g., a deep neural network) based on multiple local datasets contained in local nodes (also known as clients) without explicitly exchanging data samples. The learning task is solved by a federation of participating devices coordinated by a central server. Each participating device (client) has a local training dataset that is not uploaded to the server. Instead, each client computes an update to the current global model maintained by the server. The client passes this update, rather than the training dataset, to the server for updating the global model. The resulting shared model can be trained by learning from the client's training, allowing users to gain the benefits of a shared model trained from the client's data without having to transmit or centrally store data from the client.

[0019] Federated learning has particular utility in situations where the exchange of sensitive or personal data (e.g., medical information, IoT devices, personal devices such as smartphones) is prohibited. Take smartphones as a simple everyday example. When people type emails or text messages, they may have an autocorrect or autocomplete feature that automatically corrects people's spelling errors or suggests corrections or additions to the text. Systems in this category typically rely on machine learning models that are trained based on the user's previous word usage and may vary from user to user. Due to the sensitive nature of the information used, the raw data of the words typed by the user is not sent to a central server to train the model. Instead, the user's smartphone can receive a basic model from the server and can train the model locally to perform autocorrection in a manner customized for the word usage history of that particular user. Information about how to train the model locally can be sent to the server without sending the raw data (e.g., the user's words and / or corrections) to the server.

[0020] Federated learning is a technique that enables data to remain stored locally on client devices while the server acts as an orchestrator for the learning process, aggregating the learned information and synchronizing with the clients (e.g., users, AI tasks, ...). However, due to issues like data heterogeneity, distribution shift, the system may experience reduced efficiency and robustness, and the communication may be unreliable, and even in the case of hardware failures. Additionally, various federated learning architectures have been proposed, such as a single global model and peer models with separate models, some of which include personalized versions.

[0021] FedAvg is a type of federated learning technology in which a distributed machine learning algorithm allows clients to collaboratively train a global server model while keeping their data locally stored and private. It works by sending an initial model from the server to the client, aggregating the client's updates into the global model, and repeating this process until convergence is achieved. FedAvg enables updating the global model by aggregating the knowledge and insights of multiple clients. However, typically the server only has one model stored, and may suffer from decreased accuracy and non-robustness due to distribution shift and data heterogeneity. In addition, in many applications, clients have different capabilities in terms of memory, computing resources, and other hardware attributes. In addition, having a single model may result in a waste of resources for some clients and may also cause computational overload for other clients.

[0022] In view of the above challenges and various federated learning architectures and frameworks, the present disclosure aims to address these issues by proposing a novel federated learning framework. Although others have proposed model interpolation methods for federated learning systems using global models or other client models, and others have assumed that different models can enhance robustness, the method of the present disclosure is different in several aspects. For example, the present disclosure proposes a framework in which a server acting as a federation stores learnable and different models, and the client's model is formed by combining these different models. At the same time, the client helps to train the model within the federation. In order to ensure model diversity during training, an embodiment of the present disclosure provides a framework that combines an interpolation method to adapt to distribution shifts and even connection failures from the client. In addition, the present disclosure provides a backup solution for situations where communication is unsuccessful in a federated training system. This provides a solution to the non-robustness present in hardware properties.

[0023] While existing work has proposed the idea of ​​model interpolation for federated learning systems (global models at the server, or client models), the present disclosure focuses on multi-resolution model combination with novel orthogonal constraints. In existing work, model interpolation is only used to obtain better performance of federated training, rather than to provide a backup solution when communication failure occurs. The present disclosure provides a backup solution for such failed connection situations.

[0024] In order to solve the problems of insufficient representation and computational efficiency, the present disclosure proposes an embodiment including the following method. A pool of multiple models is stored on a server or repository, and each client pulls or retrieves each learning round from the server or repository. Clients can select and pull from a list of models based on their resource constraints, and train models locally based on their own data. After local training, the client can send information back to the server or repository to aggregate and update multiple models. Adding orthogonal regularization to neural network training can improve model performance as well as robustness and diversity. Therefore, the present disclosure provides a novel client-side loss function to help drive the optimization process of the learning task, as well as a server-side loss function to ensure and achieve diversity properties. In this way, training of multiple models with different (semi-orthogonal) properties in a federation is performed.

[0025] Federated learning systems can take advantage of Figure 1-Figure 2 The machine learning training and process shown in . Figure 1 A system 100 for training a neural network (e.g., a deep neural network) is shown. The trained neural network can reside on a server or a client. In other words, both the server and the client can utilize Figure 1 The system 100 may include an input interface for accessing training data 102 of a neural network. For example, Figure 1As shown in , the input interface can be constituted by a data storage interface 104, which can access the training data 102 from a data storage device 106. For example, the data storage interface 104 can be a memory interface or a persistent storage interface, such as a hard disk or SSD interface, but can also be a private, local or wide area network interface, such as a Bluetooth, Zigbee or Wi-Fi interface or an Ethernet or fiber optic interface. The data storage device 106 can be an internal data storage device of the system 100, such as a hard disk drive or SSD, but can also be an external data storage device, for example, a network accessible data storage device.

[0026] In some embodiments, the data storage device 106 may further include a data representation 108 of an untrained version of the neural network, which the system 100 can access from the data storage device 106. However, it will be appreciated that the training data 102 and the data representation 108 of the untrained neural network can also each be accessed from different data storage devices, for example, via different subsystems of the data storage interface 104. Each subsystem can be of a type as described above for the data storage interface 104. In other embodiments, the data representation 108 of the untrained neural network can be generated internally by the system 100 based on the design parameters of the neural network, and thus may not be explicitly stored on the data storage device 106. The system 100 can further include a processor subsystem 110, which can be configured to provide an iterative function during operation of the system 100 as a replacement of a layer stack of the neural network to be trained. Here, the corresponding layers of the replaced layer stack can have mutually shared weights and can receive the output of the previous layer as input, or for the first layer of the layer stack, receive the initial activation and a portion of the input of the layer stack. The processor subsystem 110 can be further configured to iteratively train the neural network using the training data 102. Here, the training iteration of the processor subsystem 110 may include a forward propagation portion and a backward propagation portion. The processor subsystem 110 may be configured to perform the forward propagation portion by, among other operations, defining a forward propagation portion that may be performed, determining an equilibrium point of the iterative function at which the iterative function converges to a fixed point, wherein determining the equilibrium point includes using a numerical root finding algorithm to find a root solution of the iterative function minus its input; and providing the equilibrium point as a replacement for an output of a stack of layers in the neural network. The system 100 may further include an output interface for outputting a data representation 112 of the trained neural network; the data may also be referred to as trained model data 112. For example, also as Figure 1, the output interface may be comprised of a data storage interface 104, which in these embodiments is an input / output ("IO") interface, via which trained model data 112 may be stored in a data storage device 106. For example, a data representation 108 defining an "untrained" neural network may be replaced, at least in part, by a data representation 112 of a trained neural network during or after training, as the parameters of the neural network (such as the weights, hyperparameters, and other types of parameters of the neural network) may be adapted to reflect the training on the training data 102. This is particularly useful in Figure 1 106 by reference numerals 108, 112 referring to the same data records on the data storage device 106. In other embodiments, the data representation 112 may be stored separately from the data representation 108 defining the "untrained" neural network. In some embodiments, the output interface may be separate from the data storage interface 104, but may generally be of the type described above for the data storage interface 104.

[0027] The structure of system 100 is one example of a system that may be used to train models utilized by the federated learning systems described herein. Figure 2 Additional structures for operating and training these machine learning models are shown in .

[0028] Figure 2 A federated learning system 200 is depicted, which is configured to execute and train a machine learning model described herein, such as a neural network or a deep neural network. The system 200 can be implemented to perform the federated learning process described herein. The system 200 may include at least one computing system 202. The computing system 202 may be part of or executed by a client device, such as a smartphone, an IoT device, a medical device, or other device, such as described herein with reference to the following Figure 6-Figure 11The computing system 202 may be an embedded computer system, a system on a chip (SoC), a single board computer system (SBC) (such as, for example, a computer on a module (COM) or a system on a module (SOM)), a laptop computer, a personal device such as a smart phone or a tablet computer, a personal device network, or a combination of these. The computing system 202 may include at least one processor 204, which is operatively connected to the memory unit 208. The processor 204 may include one or more integrated circuits that implement the functions of a central processing unit (CPU) 206. The CPU 206 may be a commercially available processing unit that implements an instruction set such as one of the x86, ARM, Power or MIPS instruction set families. During operation, the CPU 206 may execute stored program instructions retrieved from the memory unit 208. The stored program instructions may include software that controls the operation of the CPU 206 to perform the operations described herein. In some examples, processor 204 may be a system on a chip (SoC) that integrates the functionality of CPU 206, memory unit 208, network interface, and input / output interface into a single integrated device. Computing system 202 may implement an operating system for managing various aspects of operation. Figure 2 One processor 204, one CPU 206, and one memory 208 are shown, but of course more than one of each may be utilized throughout the system.

[0029] The memory unit 208 may include volatile memory and non-volatile memory for storing instructions and data. Non-volatile memory may include solid-state memory, such as NAND flash memory, magnetic and optical storage media, or any other suitable data storage device that retains data when the computing system 202 is disabled or loses power. Volatile memory may include static and dynamic random access memory (RAM) that stores program instructions and data. For example, the memory unit 208 may store a machine learning model 210 or algorithm, a training data set 212 for the machine learning model 210, and an original source data set 216.

[0030] The computing system 202 may include a network interface device 222 configured to provide communications with external systems and devices. For example, the network interface device 222 may include a wired and / or wireless Ethernet interface as defined by the Institute of Electrical and Electronics Engineers (IEEE) 802.11 family of standards. The network interface device 222 may include a cellular communication interface for communicating with a cellular network (e.g., 3G, 4G, 5G). The network interface device 222 may further be configured to provide a communication interface to an external network 224 or cloud, so that a device (e.g., a client device) executing the computing system 202 can communicate with the server 230.

[0031] The external network 224 may be referred to as the World Wide Web or the Internet. The external network 224 may establish a standard communication protocol between computing devices. The external network 224 may allow information and data to be easily exchanged between computing devices and the network.

[0032] One or more servers 230 may communicate with external network 224. Each server may include a computing system (such as computing system 202) such that server 230 is configured to perform machine learning and train a neural network. Of course, consistent with the spirit of the present disclosure, some personal or sensitive original source data 216 originating from a particular client device may not be transmitted to server 230, and thus the original source data at the server may not exist or may be completely independent of the original source data on the computing system 202 of the client device. During operation of the federated learning system, as will be described below, the computing system 202 associated with the client device may exchange portions of the training data 212, but not the original source data 216 or any personal data, in order to protect the privacy of any sensitive personal data residing on the client device. Server 230 can then access this information via a connection to network 224 and update its stored model on the server side.

[0033] The computing system 202 may include an input / output (I / O) interface 220, which may be configured to provide digital and / or analog input and output. The I / O interface 220 is used to transfer information between an internal storage device and an external input and / or output device (e.g., an HMI device). The I / O interface 220 may include an associated circuit or bus network to transfer information to or between (one or more) processors and storage devices. For example, the I / O interface 220 may include digital I / O logic lines that can be read or set by (one or more) processors, handshake lines for supervising data transfer via I / O lines, timing and counting facilities, and other known structures for providing such functionality. Examples of input devices include keyboards, mice, cameras, sensors, etc. Examples of output devices include monitors, screens, printers, speakers, etc. The I / O interface 220 may include additional serial interfaces (e.g., universal serial bus (USB) interfaces) for communicating with external devices. The I / O interface 220 may be referred to as an input interface because it transmits data from an external input, such as a sensor, or an output interface because it transmits data to an external output, such as a display.

[0034] The computing system 202 may include a human-machine interface (HMI) device 218, which may include any device that enables the system 200 to receive control inputs. Examples of input devices may include human-machine interface inputs, such as keyboards, mice, touch screens, voice input devices (e.g., microphones), and other similar devices. The computing system 202 may include a display device 232. The computing system 202 may include hardware and software for outputting graphics and text information to the display device 232. The display device 232 may include an electronic display screen, a projector, a printer, a speaker, or other suitable devices for displaying information to a user or operator. The computing system 202 may further be configured to allow interaction with a remote HMI and a remote display device via a network interface device 222.

[0035] System 200 can be implemented using one or more computing systems. Although this example depicts a single computing system 202 that implements all of the described features, it is intended that various features and functions be separated and implemented by multiple computing units that communicate with each other. In particular, a client device can implement computing system 202, and server 230 can also include its own computing system 202. The specific system architecture selected can depend on various factors.

[0036] The federated learning system 200 may implement a machine learning algorithm 210 configured to analyze a raw source data set 216. The raw source data set 216 may include raw or unprocessed sensor data that may represent an input data set for the machine learning system. The raw source data set 216 may include video, video segments, images, text-based information, audio or human speech, time series data (e.g., pressure sensor signals over time), and raw or partially processed sensor data (e.g., radar maps of objects). The raw source data set 216 may include sensitive or personal data with high security imperatives, and therefore the raw source data set 216 may not be transmitted from the client device to the server 230. Referring to Figure 5-Figure 11 Several different examples of inputs are shown and described. In some examples, the machine learning algorithm 210 can be a neural network algorithm (e.g., a deep neural network) designed to perform a predetermined function. For example, a neural network algorithm can be configured in an automotive application to identify street signs or pedestrians in an image. The neural network algorithm can be configured to automatically correct text or speech based on the context of words from an individual.

[0037] The computing system 202 may store a training data set 212 for the machine learning algorithm 210. The training data set 212 may represent a set of previously constructed data used to train the machine learning algorithm 210. The machine learning algorithm 210 may use the training data set 212 to learn weighting factors associated with the neural network algorithm. The training data set 212 may include a set of source data having corresponding achievements or results that the machine learning algorithm 210 attempts to replicate through the learning process.

[0038] The machine learning algorithm 210 can operate in a learning mode using the training data set 212 as input. The machine learning algorithm 210 can be executed in multiple iterations using data from the training data set 212. For each iteration, the machine learning algorithm 210 can update the internal weighting factors based on the achieved results. For example, the machine learning algorithm 210 can compare the output results (e.g., the reconstructed or supplemented image in the case where the image data is the input) with those included in the training data set 212. Since the training data set 212 includes the expected results, the machine learning algorithm 210 can determine when the performance is acceptable. After the machine learning algorithm 210 reaches a predetermined performance level (e.g., 100% consistent with the results associated with the training data set 212) or converges, the machine learning algorithm 210 can be executed using data that is not in the training data set 212. It should be understood that in the present disclosure, "convergence" can mean that a set (e.g., predetermined) number of iterations have occurred, or the residual is small enough (e.g., the change in the approximation probability in the iteration changes by less than a threshold), or other convergence conditions. The trained machine learning algorithm 210 can be applied to a new data set to generate annotated data.

[0039] The machine learning algorithm 210 may be configured to identify specific features in the original source data 216. The original source data 216 may include multiple instances or input data sets for which supplementary results are desired. For example, the machine learning algorithm 210 may be configured to identify the presence of people in a video image and annotate the occurrence. The machine learning algorithm 210 may be programmed to process the original source data 216 to identify the presence of specific features. The machine learning algorithm 210 may be configured to identify the features in the original source data 216 as predetermined features (e.g., specific words in the case where text or spoken words are input). The original source data 216 may be derived from various sources. For example, the original source data 216 may be actual input data collected by the machine learning system. The original source data 216 may be generated by a machine for testing the system. As an example, the original source data 216 may include original images or videos from a camera, spoken words from a microphone, or typed or written words from a keyboard or touch screen, etc.

[0040] Figure 3AAn example diagram or layout of a federated learning system 300 according to one embodiment is illustrated. Here, the federated learning system 300 includes a server 302 and a pool 304 of multiple client devices 306. The server 302 can correspond to the server 230, and the client device 304 can correspond to the above-mentioned devices (e.g., a camera, a smart phone, etc.). The server 302 and each client device 306 can perform the machine learning process described herein via, for example, the corresponding computing system 202. The server 302 can be a storage device that stores a number L of initialized (e.g., random) (e.g., neural network-based) models (which are labeled W1, W2, ..., W L )’s centralized server. con Represents models W1, W2, ..., W L The server 302 may orchestrate and coordinate federated training, send and receive information from clients, select clients to participate in each round of training, and aggregate information received from clients.

[0041] Each client device and server can operate with a set of parameters. In one embodiment, the client pool shown at 304 includes a number N of clients 306 in the federated learning system 300. The clients classify the level of hardware resources (computation, memory, etc.). The number of models pulled incrementally by client-i is indicated as l i , where l i ∈[L]. Larger l i Indicates that there are better hardware attributes at hand (e.g., devices with more computing resources, processing power, memory, etc.). In addition, S i ={1, 2, ..., l i} may represent the set of model indexes for client-i, and Z l ={i:l∈S i}, where Z l is the index of the client that pulls model-l. For each client-i, its locally stored data is labeled (D i ,y i ). For each client, its local model is

[0042] For example, suppose the set of selected intermediate layers outputs latent features (defined by different tasks, architectures, and data-driven criteria) that can be represented as Additionally, there may be some other parameters as follows. For client-local training, the number of epochs to train between each round of communication (to the server), batch size, learning rate, optimizer type, etc. For the connected neighbor group labeled G, the client with the fault may have index b. Therefore, the neighbors of client-b may be labeled Cb ={i, G(i, b)≠0}.

[0043] A neural network trained and executed at a server 302 or a client device in a client pool 304 may be Figure 4 This is illustrated by the diagram shown in . Figure 4 An embodiment of a model subject to training by a server or client is illustrated. As discussed above, a federated learning system may include a machine learning model, such as a model based on a neural network (e.g., and in some cases, although not necessarily, a deep neural network). The model may include an input layer (with multiple input nodes) and an output layer (with multiple output nodes). In some examples, the model may include multiple hidden layers. The nodes of the input layer, output layer, and hidden layer may be coupled to nodes of subsequent or previous layers. And each node of the output layer may perform an activation function-for example, a function that helps whether the corresponding node should be activated to provide a model output. The number of nodes shown in the input layer, hidden layer, and output layer is merely exemplary, and any suitable number may be used.

[0044] Return to reference Figure 3A ,At the beginning of each round of federated training, the server 302 sends model information to each eligible (e.g., online, responsible, etc.) client device 306, e.g. This can be done via networked communication, such as reference Figure 2 After each client device 306 receives the information from the server 302, each client device 306 begins to process the data (D i ,y i ) for training. The loss of each client-i is given by L i Marking:

[0045]

[0046] where λ is a tunable hyperparameter corresponding to a regularization term that controls the relative weight between learning tasks and achieves or ensures model diversity. represents the hidden features from the selected intermediate layer, so the cascaded hidden features can be expressed as

[0047]

[0048] The regularization term R can be defined as

[0049]

[0050] The distance function of equation (3) can be expressed as or ||AB|| ∞, or σ(AB), or a weighted average thereof, where σ is the spectral norm, or angular margin contrast regularization, etc. Client-i can solve (exactly or approximately) the optimization of the loss indicated in equation (1) above, and derive for Updates.

[0051] The client device can then send the updated weights to the server to aggregate and update the model on the server side without transmitting the original source data of the individual. In the aggregation phase, the server receives information from the client and performs the aggregation. In order to aggregate information and have model diversity, the server can solve the following optimization to obtain the weights for W1, W2, ..., W L Update:

[0052]

[0053] Here, the first term can be changed to other kinds of reweighting, and the second term can be generated as other metrics. Note that W con Indicates the machine learning models W1, W2, ..., W maintained by multiple servers L The aggregation process on the server side solves the optimization problem to find the updated weights W1, W2, ..., W L , so that each W l Close to pulling model-l (or its model set S i The average of the weights collected by the clients with model-l) and also tries to satisfy the diversity constraint

[0054] The process can be repeated or looped until a stopping criterion, such as convergence, or a certain number of rounds or tolerance, is achieved. Alternatively, the process can be repeated or looped continuously for continuous learning.

[0055] In addition to the training process, if any client-b has a communication failure with the server, the disconnected client (or node) can pull the machine learning model from its neighboring clients or nodes and interpolate its model as follows:

[0056]

[0057] Among them A i It is model W i In one embodiment, The neighbor of client-b is marked as C b ={i, G(i, b)≠0}.

[0058] Remember this description. Figure 3BA flow chart of a method 350 for training a neural network via federated learning is illustrated. The method has a server side, where functions are performed at one or more of the servers (e.g., server 230), and a client side, where functions are performed at the client (e.g., client device 306). At 352, the server maintains a plurality of machine learning models, such as the models W1, W2, W3, ..., W shown in 302. L These models can be global models that can be distributed among various client devices.

[0059] The models are delivered to the various clients. The models selected for delivery may match the needs or requirements of the clients to which they are delivered. Then, at each client to which the model is delivered, the model is trained using the data stored locally on that respective client. In other words, each client device uses its own locally stored data (D i ,y i ) to train the model(s) it receives from the server.

[0060] During training, at 356, each client device can determine a loss and update the weights of the model it is training at that particular client device. As an example, the loss for each client device is shown in equation (1) above. An adjustable hyperparameter corresponding to the regularization term R controls the relative weight between learning a specific task and achieving model diversity. As an example, regularization is shown in equation (2) above.

[0061] If the client becomes disconnected from the server, or is otherwise unable to receive a model from the server, an optional backup step 357 is provided. Here, the disconnected client (e.g., client-b) or node can pull models from its neighbors. For example, a client device can connect to nearby client devices and receive models from those nearby devices. This can occur over wireless communications, such as any of the wireless communications examples described herein. In one embodiment, the disconnected client is first matched with another client of similar make, model, network setup, etc., which can ensure that the appropriate model can be transferred from the connected device to the disconnected device. In one embodiment, the disconnected device client-b can interpolate the model received from the connected client(s) according to equation (5) above. Based on the neighboring clients being within range of a particular wireless communication such as direct client-to-client communication (e.g., Wi-Fi, Bluetooth, short-range communication, dedicated short-range communication (DSRC)), etc., a neighboring client may be selected to communicate the model with the disconnected client such that once the disconnected device client-b receives the model(s) from other neighboring devices or nodes, the disconnected device client-b may perform the training of 354 and the loss determination and weight update of 356 based on the data stored locally in the disconnected device client-b.

[0062] Then, the updated weights as trained with the data stored locally at the client can be transmitted to the server. Again, it should be noted that the locally stored data is not transmitted. At 358, the server trains its multiple machine learning models with the information received from the client. In particular, the server can adjust the weights of its models based on the adjustment weight information collected from the client device. Using equation (4) as an example, this can be done in aggregation. During training at the server, the loss can also be determined on the server side.

[0063] For example, all or part of steps 352-358 may be repeated in a loop until convergence, or may be repeated continuously in continuous learning.

[0064] The machine learning model described in this article can be used in many different applications. As mentioned above, the original source data stored locally can be image data, sound data, etc., and thus in Figure 6-Figure 11 Various applications that retrieve or use this data are shown as examples. Figure 5 The structure for training and using machine learning models for these applications (and others) is illustrated in . Figure 5A schematic diagram of the interaction between a computer-controlled machine 500 and a control system 502 is depicted. The computer-controlled machine 500 includes an actuator 504 and a sensor 506. The actuator 504 may include one or more actuators, and the sensor 506 may include one or more sensors. The sensor 506 is configured to sense a condition of the computer-controlled machine 500. The sensor 506 may be configured to encode the sensed condition into a sensor signal 508 and transmit the sensor signal 508 to the control system 502. Non-limiting examples of the sensor 506 include video, radar, LiDAR, microphone, ultrasound, and motion sensors. In one embodiment, the sensor 506 is an optical sensor configured to sense an optical image of an environment proximate to the computer-controlled machine 500.

[0065] The control system 502 is configured to receive sensor signals 508 from the computer controlled machine 500. As explained below, the control system 502 may be further configured to calculate actuator control commands 510 depending on the sensor signals and transmit the actuator control commands 510 to the actuators 504 of the computer controlled machine 500.

[0066] like Figure 5 As shown in , the control system 502 includes a receiving unit 512. The receiving unit 512 can be configured to receive a sensor signal 508 from the sensor 506 and transform the sensor signal 508 into an input signal x. In an alternative embodiment, without the receiving unit 512, the sensor signal 508 is directly received as the input signal x. Each input signal x can be a part of each sensor signal 508. The receiving unit 512 can be configured to process each sensor signal 508 to generate each input signal x. The input signal x can include data corresponding to an image recorded by the sensor 506.

[0067] The control system 502 includes a classifier 514. The classifier 514 can be configured to classify the input signal x into one or more labels using a machine learning algorithm, such as the neural network described above. The classifier 514 is configured to be parameterized by parameters such as those described above (e.g., parameter θ). The parameter θ can be stored in and provided by the non-volatile storage device 516. The classifier 514 is configured to determine the output signal y based on the input signal x. Each output signal y includes information for assigning one or more labels to each input signal x. The classifier 514 can transmit the output signal y to a conversion unit 518. The conversion unit 518 is configured to convert the output signal y into an actuator control command 510. The control system 502 is configured to transmit the actuator control command 510 to the actuator 504, and the actuator 504 is configured to actuate the computer-controlled machine 500 in response to the actuator control command 510. In another embodiment, the actuator 504 is configured to actuate the computer-controlled machine 500 directly based on the output signal y.

[0068] When the actuator 504 receives the actuator control command 510, the actuator 504 is configured to perform an action corresponding to the associated actuator control command 510. The actuator 504 may include control logic configured to transform the actuator control command 510 into a second actuator control command for controlling the actuator 504. In one or more embodiments, the actuator control command 510 may also be used to control a display instead of or in addition to the actuator.

[0069] In another embodiment, the control system 502 includes the sensor 506 instead of or in addition to the computer-controlled machine 500 including the sensor 506. The control system 502 may also include the actuator 504 instead of or in addition to the computer-controlled machine 500 including the actuator 504.

[0070] like Figure 5 As shown in , the control system 502 also includes a processor 520 and a memory 522. The processor 520 may include one or more processors. The memory 522 may include one or more memory devices. The classifier 514 of one or more embodiments (e.g., a machine learning algorithm, such as those described above) can be implemented by the control system 502, which includes a non-volatile storage device 516, a processor 520, and a memory 522.

[0071] The non-volatile storage device 516 may include one or more persistent data storage devices, such as a hard drive, an optical drive, a tape drive, a non-volatile solid-state device, a cloud storage device, or any other device capable of persistently storing information. The processor 520 may be the processor described above with reference to Figure 1-Figure 2Any of the processors or processor subsystems described, and may include one or more devices selected from a high performance computing (HPC) system, including a high performance core, a microprocessor, a microcontroller, a digital signal processor, a microcomputer, a central processing unit, a field programmable gate array, a programmable logic device, a state machine, a logic circuit, an analog circuit, a digital circuit, a tensor processing unit, a graphics processing unit, an ASIC, or any other device that manipulates signals (analog or digital) based on computer executable instructions residing in the memory 522. The memory 522 may include a single memory device or multiple memory devices, including but not limited to random access memory (RAM), volatile memory, non-volatile memory, static random access memory (SRAM), dynamic random access memory (DRAM), flash memory, cache memory, or any other device capable of storing information.

[0072] The processor 520 may be configured to read into the memory 522 and execute computer executable instructions residing in the non-volatile storage device 516 and embodying one or more machine learning algorithms and / or method techniques of one or more embodiments. The non-volatile storage device 516 may include one or more operating systems and applications. The non-volatile storage device 516 may store data compiled and / or interpreted from a computer program created using a variety of programming languages ​​and / or techniques, including without limitation and alone or in combination Java, C, C++, C#, Objective C, Fortran, Pascal, JavaScript, Python, Perl, and PL / SQL.

[0073] When executed by the processor 520, the computer executable instructions of the non-volatile storage device 516 can cause the control system 502 to implement one or more of the machine learning algorithms and / or methodological techniques disclosed herein. The non-volatile storage device 516 may also include machine learning data (including data parameters) that support the functions, features, and processes of one or more embodiments described herein.

[0074] The program code embodying the algorithm and / or method technology described herein can be distributed separately or jointly as a program product in various different forms. The program code can be distributed using a computer-readable storage medium having a computer-readable program instruction thereon, for causing the processor to implement aspects of one or more embodiments. The inherently non-transitory computer-readable storage medium may include volatile and non-volatile and removable and non-removable tangible media implemented in any method or technology for storing information, such as computer-readable instructions, data structures, program modules or other data. The computer-readable storage medium may further include RAM, ROM, erasable programmable read-only memory (EPROM), electrically erasable programmable read-only memory (EEPROM), flash memory or other solid-state memory technology, portable compact disk read-only memory (CD-ROM) or other optical storage device, cassette, tape, magnetic disk storage device or other magnetic storage device, or any other medium that can be used to store the desired information and can be read by a computer. The computer-readable program instruction can be downloaded from the computer-readable storage medium to a computer, another type of programmable data processing device or another device, or downloaded to an external computer or external storage device via a network.

[0075] Computer-readable program instructions stored in a computer-readable medium can be used to guide a computer, other types of programmable data processing devices, or other devices to operate in a particular manner so that the instructions stored in the computer-readable medium produce an article of manufacture including instructions for implementing the functions, actions, and / or operations specified in the flowchart or chart. In certain alternative embodiments, the functions, actions, and / or operations specified in the flowchart and chart can be reordered, processed serially, and / or processed concurrently in accordance with one or more embodiments. In addition, any of the flowcharts and / or charts may include more or fewer nodes or blocks than those illustrated in accordance with one or more embodiments.

[0076] A process, method or algorithm may be embodied in whole or in part using suitable hardware components, such as an application specific integrated circuit (ASIC), a field programmable gate array (FPGA), a state machine, a controller or other hardware components or devices, or a combination of hardware, software and firmware components.

[0077] Figure 6-Figure 11 Embodiments of environments in which the federated learning system described herein may be implemented are illustrated. Each of these embodiments illustrates an embodiment of a client device. In these embodiments, the data originating from the sensor 506 may be raw source data that is used to train a machine learning model on the device (client), but is not transmitted to the server to protect the data. Figure 6A schematic diagram of a control system 502 is depicted that is configured to control a vehicle 600, which may be an at least partially autonomous vehicle or an at least partially autonomous robot. The vehicle 600 includes an actuator 504 and a sensor 506. The sensor 506 may include one or more video sensors, cameras, radar sensors, ultrasonic sensors, LiDAR sensors, and / or location sensors (e.g., GPS). One or more of the one or more specific sensors may be integrated into the vehicle 600. The sensor 506 may include a software module that is configured to determine the state of the actuator 504 when executed. A non-limiting example of a software module includes a weather information software module that is configured to determine the current or future state of the weather near the vehicle 600 or other location.

[0078] The classifier 514 of the control system 502 of the vehicle 600 can be configured to detect an object near the vehicle 600 depending on the input signal x. In such an embodiment, the output signal y may include information characterizing the proximity of the object to the vehicle 600. The actuator control command 510 may be determined based on this information. The actuator control command 510 may be used to avoid collision with the detected object. The original source data for federated learning may include raw images of the vehicle's surroundings, however the vehicle's processing of objects in the surroundings may change the weights in the machine learning model used on the vehicle; these adjusted weights may then be sent back to the server's model for updating.

[0079] In embodiments where the vehicle 600 is at least partially autonomous, the actuator 504 may be embodied in the brakes, propulsion system, engine, drive train, or steering of the vehicle 600. Actuator control commands 510 may be determined to control the actuator 504 so that the vehicle 600 avoids colliding with a detected object. The detected objects may also be classified based on what the classifier 514 thinks they are most likely to be, such as a pedestrian or a tree. The actuator control commands 510 may be determined depending on the classification. In scenarios where adversarial attacks may occur, the above system may be further trained to better detect objects or identify changes in lighting conditions or angles of sensors or cameras on the vehicle 600.

[0080] In other embodiments where the vehicle 600 is an at least partially autonomous robot, the vehicle 600 may be a mobile robot configured to perform one or more functions, such as flying, swimming, diving, and stepping. The mobile robot may be an at least partially autonomous lawn mower or an at least partially autonomous cleaning robot. In such embodiments, the actuator control commands 510 may be determined such that a propulsion unit, a steering unit, and / or a braking unit of the mobile robot may be controlled such that the mobile robot may avoid colliding with an identified object.

[0081] In another embodiment, the vehicle 600 is an at least partially autonomous robot in the form of a gardening robot. In such an embodiment, the vehicle 600 can use an optical sensor as a sensor 506 to determine the state of plants in the environment close to the vehicle 600. The actuator 504 can be a nozzle configured to spray a chemical. Depending on the identified species and / or the identified state of the plant, the actuator control command 510 can be determined to cause the actuator 504 to spray the plant with an appropriate amount of an appropriate chemical.

[0082] The vehicle 600 may be an at least partially autonomous robot in the form of a household appliance. Non-limiting examples of household appliances include a washing machine, a stove, an oven, a microwave, or a dishwasher. In such a vehicle 600, the sensor 506 may be an optical sensor configured to detect the state of an object to be processed by the household appliance. For example, in the case where the household appliance is a washing machine, the sensor 506 may detect the state of the laundry in the washing machine. The actuator control command 510 may be determined based on the detected state of the laundry.

[0083] Figure 7 A schematic diagram of a control system 502 is depicted, the control system 502 being configured to control a system 700 (e.g., a manufacturing machine), such as a punch tool, a tool, or a gun drill, of a manufacturing system 702 (such as part of a production line). The control system 502 may be configured to control an actuator 504, which is configured to control the system 700 (e.g., a manufacturing machine).

[0084] The sensor 506 of the system 700 (e.g., a manufacturing machine) may be an optical sensor configured to capture one or more attributes of the manufactured product 704. The classifier 514 may be configured to determine a state of the manufactured product 704 based on the one or more captured attributes. The actuator 504 may be configured to control the system 700 (e.g., a manufacturing machine) depending on the determined state of the manufactured product 704 for subsequent manufacturing steps of the manufactured product 704. The actuator 504 may be configured to control the function of the system 700 (e.g., a manufacturing machine) on the subsequent manufactured product 706 of the system 700 (e.g., a manufacturing machine) depending on the determined state of the manufactured product 704.

[0085] Figure 8 A schematic diagram of a control system 502 configured to control a power tool 800 , such as a power drill or driver, having an at least partially autonomous mode is depicted. The control system 502 may be configured to control an actuator 504 configured to control the power tool 800 .

[0086] The sensor 506 of the power tool 800 can be an optical sensor configured to capture one or more properties of the working surface 802 and / or the fastener 804 driven into the working surface 802. The classifier 514 can be configured to determine the state of the working surface 802 and / or the fastener 804 relative to the working surface 802 based on the one or more captured properties. The state can be that the fastener 804 is flush with the working surface 802. Alternatively, the state can be the hardness of the working surface 802. The actuator 504 can be configured to control the power tool 800 so that the driving function of the power tool 800 is adjusted depending on the determined state of the fastener 804 relative to the working surface 802 or one or more captured properties of the working surface 802. For example, if the state of the fastener 804 is flush with the working surface 802, the actuator 504 can interrupt the driving function. As another non-limiting example, the actuator 504 can apply additional or less torque depending on the hardness of the working surface 802.

[0087] Fig. 9 Depicted is a schematic diagram of a control system 502 configured to control an automated personal assistant 900. The control system 502 may be configured to control an actuator 504, which is configured to control the automated personal assistant 900. The automated personal assistant 900 may be configured to control a household appliance, such as a washing machine, stove, oven, microwave, or dishwasher.

[0088] Sensor 506 may be an optical sensor and / or an audio sensor. The optical sensor may be configured to receive a video image of user 902's gesture 904. The audio sensor may be configured to receive a voice command of user 902.

[0089] The control system 502 of the automated personal assistant 900 can be configured to determine an actuator control command 510 configured to control the system 502. The control system 502 can be configured to determine the actuator control command 510 based on the sensor signal 508 of the sensor 506. The automated personal assistant 900 is configured to transmit the sensor signal 508 to the control system 502. The classifier 514 of the control system 502 can be configured to execute a gesture recognition algorithm to identify the gesture 904 made by the user 902, thereby determining the actuator control command 510, and transmitting the actuator control command 510 to the actuator 504. The classifier 514 can be configured to retrieve information from the non-volatile memory in response to the gesture 904, and output the retrieved information in a form suitable for reception by the user 902.

[0090] Fig.10A schematic diagram of a control system 502 configured to control a surveillance system 1000 is depicted. The surveillance system 1000 can be configured to physically control access through a door 1002. A sensor 506 can be configured to detect scenes relevant to deciding whether to grant access. The sensor 506 can be an optical sensor configured to generate and transmit image and / or video data. The control system 502 can use such data to detect a person's face.

[0091] The classifier 514 of the control system 502 of the monitoring system 1000 can be configured to interpret the image and / or video data by matching the identities of known persons stored in the non-volatile storage device 516 to determine the identity of the person. The classifier 514 can be configured to generate an actuator control command 510 in response to the interpretation of the image and / or video data. The control system 502 is configured to transmit the actuator control command 510 to the actuator 504. In this embodiment, the actuator 504 can be configured to lock or unlock the door 1002 in response to the actuator control command 510. In other embodiments, non-physical logical access control is also possible.

[0092] The monitoring system 1000 may also be a surveillance system. In such an embodiment, the sensor 506 may be an optical sensor configured to detect a scene being supervised, and the control system 502 is configured to control the display 1004. The classifier 514 is configured to determine a classification of the scene, such as whether the scene detected by the sensor 506 is suspicious. The control system 502 is configured to transmit an actuator control command 510 to the display 1004 in response to the classification. The display 1004 may be configured to adjust the displayed content in response to the actuator control command 510. For example, the display 1004 may highlight an object that is considered suspicious by the classifier 514. Using embodiments of the disclosed system, the surveillance system can predict the appearance of an object at a specific time in the future.

[0093] Fig.11A schematic diagram of a control system 502 is depicted, which is configured to control an imaging system 1100, such as an MRI device, an x-ray imaging device, or an ultrasound device. The sensor 506 can be, for example, an imaging sensor. The classifier 514 can be configured to determine the classification of all or part of the sensed image. The classifier 514 can be configured to determine or select an actuator control command 510 in response to the classification obtained by the trained neural network. For example, the classifier 514 can interpret an area of ​​the sensed image as a potential abnormality. In this case, the actuator control command 510 can be determined or selected so that the display 1102 displays the imaging and highlights the potential abnormal area. The sensed image can be used internally in a hospital environment for training a machine learning system within the hospital (client), but the data is not sent to the server for training the server's model. Instead, the adjusted weights of the hospital adjusted based on the sensed image can be sent to the server for adjusting the weights on the server side.

[0094] Although exemplary embodiments are described above, it is not intended that these embodiments describe all possible forms covered by the claims. The words used in the specification are descriptive rather than restrictive words, and it should be understood that various changes can be made without departing from the spirit and scope of the present disclosure. As previously described, the features of the various embodiments can be combined to form other embodiments of the present invention that may not be explicitly described or illustrated. Although various embodiments may have been described as providing advantages or preferred over other embodiments or prior art implementations in terms of one or more desired characteristics, it is recognized by those of ordinary skill in the art that one or more features or characteristics can be compromised to achieve the desired overall system properties, depending on the specific application and implementation. These properties may include, but are not limited to, cost, strength, durability, life cycle cost, marketability, appearance, packaging, size, applicability, weight, manufacturability, ease of assembly, etc. As such, to the extent that any embodiment is described as less desirable than other embodiments or prior art implementations in terms of one or more characteristics, these embodiments are not outside the scope of the present disclosure and may be desirable for a particular application.

Claims

1. A method for training a neural network using federated learning, the method comprising: sending at least portions of the machine learning models maintained by the plurality of servers from the servers to the plurality of clients, thereby generating a plurality of local machine learning models; At each client, training a plurality of local machine learning models using locally stored data stored locally at the respective client, wherein the training at each client comprises determining a respective loss for each of the plurality of local machine learning models and updating a respective weight for each of the plurality of local machine learning models; Transmitting the corresponding updated weights from each client to the server without transmitting the client's locally stored data; and At the server, multiple server-maintained machine learning models are trained with the updated weights sent from each client.

2. The method according to claim 1, further comprising: Select machine learning models maintained by multiple servers from the machine learning model pool.

3. The method of claim 2, wherein the machine learning models maintained by multiple servers are selected from a pool based on resource constraints associated with multiple clients.

4. The method of claim 1, wherein training multiple local machine learning models at each client comprises determining a loss based on a regularization term and one or more latent features of the local machine learning model.

5. The method according to claim 4, wherein the loss is determined by the following formula: Among them (D i ,y i ) represents the data stored locally at a specific client i, where λ is a tunable hyperparameter corresponding to the regularization term R, and Where g is the local machine learning model One or more hidden features.

6. The method according to claim 5, further comprising: At the server, information received from the clients is aggregated to perform training of multiple server-maintained machine learning models using updated weights.

7. The method of claim 6, wherein the aggregating comprises performing: where Z represents the index of machine learning models maintained by multiple servers, and Where W con Indicates the machine learning models W1, W2, ..., W maintained by multiple servers L cascade weight.

8. The method according to claim 1, further comprising: determining that a first client of the plurality of clients is disconnected or otherwise unable to receive at least a portion of the machine learning models maintained by the plurality of servers from the server; connecting the first client to a neighboring client capable of communicating with the server; and The portions of the machine learning models maintained by the plurality of servers are sent from the neighboring clients to the first client.

9. The method of claim 8, wherein the connecting comprises connecting the first client to a plurality of adjacent clients, the method further comprising: Interpolation is performed on the portions of the multiple server-maintained machine learning models received from multiple adjacent clients.

10. The method according to claim 9, wherein the interpolation is Where W + is composed of multiple adjacent clients C b The interpolation model of the received model W, and Among them A i It is model W i The linear combination weights of .

11. A system for training a neural network using federated learning, the system comprising: a memory for storing instructions; and A plurality of processors that, when executing instructions stored in a memory, collectively perform: sending at least portions of the machine learning models maintained by the plurality of servers from the servers to the plurality of clients, thereby generating a plurality of local machine learning models; At each client, training a plurality of local machine learning models using locally stored data stored locally at the respective client, wherein the training at each client comprises determining a respective loss for each of the plurality of local machine learning models and updating a respective weight for each of the plurality of local machine learning models; Transmitting the corresponding updated weights from each client to the server without transmitting the client's locally stored data; and At the server, multiple server-maintained machine learning models are trained with the updated weights sent from each client.

12. The system of claim 11, wherein the instructions further cause the processor to collectively perform: Select machine learning models maintained by multiple servers from the machine learning model pool.

13. The system of claim 12, wherein the machine learning models maintained by the plurality of servers are selected from a pool based on resource constraints of the plurality of clients and sent to the plurality of clients.

14. The system of claim 11, wherein training multiple local machine learning models at each client comprises determining a loss based on a regularization term and one or more latent features of the local machine learning models.

15. The system of claim 14, wherein the instructions further cause the processor to collectively perform: At the server, information received from the clients is aggregated to perform training of multiple server-maintained machine learning models using updated weights.

16. A non-transitory computer readable storage medium tangibly embodying a computer readable program code having computer readable instructions that, when executed, cause a computing system to train a neural network using federated learning by: sending at least portions of the machine learning models maintained by the plurality of servers from the servers to the plurality of clients, thereby generating a plurality of local machine learning models; At each client, training a plurality of local machine learning models using locally stored data stored locally at the respective client, wherein the training at each client comprises determining a respective loss for each of the plurality of local machine learning models and updating a respective weight for each of the plurality of local machine learning models; Transmitting the corresponding updated weights from each client to the server without transmitting the client's locally stored data; and At the server, multiple server-maintained machine learning models are trained with the updated weights sent from each client.

17. The computer-readable storage medium of claim 16, wherein the computer-readable instructions further cause a computing system to train a neural network using federated learning by: Select machine learning models maintained by multiple servers from the machine learning model pool.

18. The computer-readable storage medium of claim 17, wherein the machine learning models maintained by the plurality of servers are selected from a pool and sent to the plurality of clients based on resource constraints of the plurality of clients.

19. The computer-readable storage medium of claim 16, wherein training multiple local machine learning models at each client comprises determining a loss based on a regularization term and one or more latent features of the local machine learning model.

20. The computer-readable storage medium of claim 19, wherein the computer-readable instructions further cause a computing system to train a neural network using federated learning by: At the server, information received from the clients is aggregated to perform training of multiple server-maintained machine learning models using updated weights.

Images