Federated learning with model diversity and backup in case of a disconnected client

Abstract

Methods and systems for training neural networks using federated learning. Server-maintained machine learning models are sent from a server to multiple clients, resulting in local machine learning models. In each client, the local machine learning models are trained using locally stored data. Losses are determined and weights are updated for each local machine learning model. Updated weights are then transferred to the server to update the server-maintained machine learning models for training. If a client becomes disconnected or otherwise unable to receive the server-maintained models, it can connect to neighboring clients, receive the models from these neighboring clients, and train these models using the disconnected clients' own locally stored data.

Description

Technical FieldThe present disclosure relates to methods and systems for federated learning with diversity in machine learning models.Prior ArtFederated learning (also known as collaborative learning) is a machine learning technique that trains a machine learning algorithm over multiple independent sessions, each using its own dataset. Federated learning aims to train a global machine learning algorithm, for example, deep neural networks, based on multiple local data sets included in local nodes (also referred to as clients) without explicitly exchanging data samples. The learning task is solved by federation of participating devices, which are coordinated by a central server. Each participating device (client) has a local training dataset that is not uploaded to the server. Instead, each client calculates an update to the current global model maintained by the server. The clients communicate this update, but not the training dataset, to the server for updating the global model. The resulting shared model may be trained by learning from the training of the clients to allow users to take advantage of shared models trained from the data of the clients without having to transfer or centrally store the data from the clients. This is particularly useful in situations where the exchange of sensitive or personal data (e.g., medical information, things' Internet devices, personal devices such as smartphones) is excluded.Summary of the InventionIn one embodiment, a method for training federated learning neural networks comprises: sending at least portions of multiple server-maintained machine learning models from a server to multiple clients, thereby yielding multiple local machine learning models; training the multiple local machine learning models in each client with locally stored data locally stored in that respective client, wherein the training in each client comprises determining a respective loss for each of the multiple local machine learning models and updating respective weights for each of the multiple local machine learning models; transferring the respective updated weights from each client to the server without transferring the locally stored data of the clients; training the multiple server-maintained machine learning models in the server with the updated weights sent from each of the clients; determining that a first client of the plurality of clients is separate or otherwise unable to receive the at least portions of the plurality of server-maintained machine learning models from the server; connecting the first client to a neighbor client capable of communicating with the server; and sending the portions of the plurality of server-maintained machine learning models from the neighbor client to the first client.In one embodiment, a system for training federated learning neural networks includes memory storing instructions, and multiple processors that, when executing the instructions stored in the memory, collectively perform: sending at least portions of multiple server-maintained machine learning models from a server to multiple clients, thereby yielding multiple local machine learning models; training the multiple local machine learning models in each client with locally stored data stored locally in that respective client, wherein the training in each client comprises determining a respective loss for each of the multiple local machine learning models and updating respective weights for each of the multiple local machine learning models; transferring the respective updated weights from each client to the server without transferring the locally stored data of the clients; training the plurality of server-maintained machine learning models in the server with the updated weights sent from each of the clients; determining that a first client of the plurality of clients is separate or otherwise unable to receive the at least portions of the plurality of server-maintained machine learning models from the server; connecting the first client to a neighbor client capable of communicating with the server; and sending the portions of the plurality of server-maintained machine learning models from the neighbor client to the first client.In one embodiment, a method for training federated learning neural networks comprises: sending at least portions of multiple server-maintained machine learning models from a server to multiple clients, thereby yielding multiple local machine learning models; determining that a first client of the multiple clients is separate or otherwise unable to receive the at least portions of the multiple server-maintained machine learning models; training the multiple local machine learning models in each of the multiple clients, other than the first client, with locally stored data stored locally in that respective client, wherein training in each client comprises determining a respective loss for each of the multiple local machine learning models and updating respective weights for each of the multiple local machine learning models; transferring the respective updated weights from each of the plurality of clients other than the first client to the server without transferring the locally stored data of the clients; connecting the first client to a plurality of neighboring clients of the plurality of clients capable of communicating with the server; sending the portions of the plurality of server-maintained machine learning models from the neighboring clients to the first client, training the plurality of server-maintained machine learning models in the first client with locally stored data locally stored in that first client, wherein training in the first client comprises determining a loss for each of the plurality of local machine learning models and updating weights associated with each of the local machine learning models; sending the updated weights from the first client to the server once the first client is reconnected to the server; training the plurality of server-maintained machine learning models in the server with the updated weights from the first client.Brief Description of the DrawingsFIG. 1 illustrates a system for training a neural network according to an embodiment. FIG. 2 illustrates a computer-implemented method for training and using a neural network, according to an embodiment. FIG. 3A shows an example diagram or layout of a federated learning system, FIG. 3B shows a flowchart of a method for training neural networks via federated learning. FIG. 4 shows a diagram of a deep neural network with nodes in an input layer, multiple hidden layers, and an output layer, according to an embodiment. FIG. 5 is a schematic illustration of interaction between a computer controlled machine and a control system, according to an embodiment. FIG. 6 shows a schematic illustration of the control system of FIG. 5 configured to control a vehicle, which may be a partially autonomous vehicle, a fully autonomous vehicle, a partially autonomous robot, or a fully autonomous robot, according to an embodiment. FIG. 7 is a schematic illustration of the control system of FIG. 5 configured to control a manufacturing machine, such as a punching, cutting, or drilling tool, of a manufacturing system, such as as part of a manufacturing line. FIG. 8 shows a schematic illustration of the control system of FIG. 5 configured to control a power tool, such as a drilling machine or a driver, having an at least partially autonomous mode. FIG. 9 is a schematic illustration of the control system of FIG. 5 configured to control an automated personal assistant. FIG. 10 shows a schematic illustration of the control system of FIG. 5 configured to control a monitoring system, such as an access control system or monitoring system. FIG. 11 is a schematic illustration of the control system of FIG. 5 configured to control an imaging system, for example, an MRI apparatus, an X-ray imaging apparatus, or an ultrasound apparatus.Disclosure of the InventionEmbodiments of the present disclosure are described herein. It is to be understood, however, that the disclosed embodiments are merely examples and other embodiments may take various and alternative forms. The figures are not necessarily to scale; some features could be exaggerated or minimized to show details of particular components. Specific structural and functional details disclosed herein are therefore not to be interpreted as limiting, but merely as a representative basis for teaching one skilled in the art to variously employ the embodiments. As will be appreciated by those of ordinary skill in the art, various features illustrated and described with reference to any one of the figures may be combined with features illustrated in one or more other figures to produce embodiments that are not expressly illustrated or described. The combinations of features illustrated provide representative embodiments for typical applications. However, for certain applications or implementations, various combinations and modifications of the features consistent with the teachings of the present disclosure may be desired.As used herein, "a," "an," and "the / s" refer to both singular and plural referents unless the context clearly indicates otherwise. For example, "a processor" programmed to perform various functions refers to a processor programmed to perform each individual function and all functions, or more than one processor collectively programmed to perform each of the various functions.The present disclosure relates to federated learning. References herein to a "server" of the federated learning system refer to the centralized server or servers that communicate with the clients to exchange data with them. For example, one or more servers in the cloud or remote from end users may represent a server. References herein to a "client" of the federated learning system refer to local nodes or devices corresponding to a particular end user. For example, a smartphone, an Internet of Things device, or the like would represent a client. The server and the client may each use a respective computer system for machine learning training, such as those described herein.Federated learning (also known as collaborative learning) is a machine learning technique that trains a machine learning algorithm over multiple independent sessions, each using its own dataset. Federated learning aims to train a global machine learning algorithm (e.g., deep neural networks) based on multiple local data sets included in local nodes (also referred to as clients) without explicitly exchanging data samples. The learning task is solved by federation of participating devices, which are coordinated by a central server. Each participating device (client) has a local training dataset that is not uploaded to the server. Instead, each client calculates an update to the current global model maintained by the server. The clients communicate this update, but not the training dataset, to the server for updating the global model. The resulting shared model may be trained by learning from the training of the clients to allow users to take advantage of shared models trained from the data of the clients without having to transfer or centrally store the data from the clients.Federated learning has particular utility in situations where the exchange of sensitive or personal data (e.g., medical information, Internet of Things devices, personal devices such as smart phones) is excluded. Take smartphones as a simple common example. If persons type an email or text message, they could have an autocorrection or auto fill feature that automatically corrects a person's type of typing error or proposes corrections or additions to the text. This type of system typically relies on a machine learning model that is trained based on prior word usage of the user and could be different from user to user. Due to the sensitive nature of the information used, the raw data of the words typed in by the user are not sent to a central server for training the model. Instead, the user's smartphone may receive a basic model from the server and may locally train that model to perform autocorrection in a manner tailored to the history of the word usage of that particular user. Information on how the model was trained locally may be sent to the server without requiring the raw data (e.g., the user's words and / or corrections) to be sent to the server.Federated learning is a technique that allows data to be stored locally to devices of clients while the server acts as an orchestrator for the learning process, aggregates learned information, and synchronizes with clients (e.g., users, AI tasks... ). However, the system may experience reduced efficiency and robustness due to problems such as data heterogenity, distribution relocations, and communication may be unreliable, and even in cases with hardware failures. In addition, various federated learning architectures have been proposed, such as single global models and peer-to-peer with single models, some of which include personalized versions.FedAvg is one type of federated learning technique in which a distributed machine learning algorithm allows clients to collaboratively train a global server model while keeping their data stored locally and private. It functions by sending the initial model from the server to clients, aggregating the updates of the clients into a global model, and repeating this process until convergence is achieved. FedAvg enables updating of the global model by aggregating the knowledge and insights of multiple clients. However, the server usually has only one stored model and may suffer a drop in accuracy and robustness due to distribution relocation as well as data heterogenity. In addition, in many of the applications, clients have various capabilities with respect to memory, computational resources, and other hardware characteristics. In addition, a single model may cause resource waste for some clients and computational congestion for other clients as well.In view of the mentioned problems and the various federated learning architectures and frames, the present disclosure seeks to address these problems by proposing a novel federated learning frame. Although other model interpolation methods are proposed for federated learning systems that use either a global model or other client models, and still others are claimed to increase robustness, the approach of the present disclosure differs in several aspects. For example, the present disclosure shows a framework in which servers acting as a federation store trainable and diverse models, while models of clients are formed by combining these diverse models. At the same time, clients help train the models in the federation. To ensure model diversity during training, embodiments of the present disclosure provide a framework that includes interpolation methods to account for distribution relocations and even connection failures of clients. In addition, the present disclosure provides backup solutions for cases of unsuccessful communication in a federated training system. This provides solutions for non-robustness existing in hardware characteristics.While prior work presents model interpolation ideas (global model in the server or client model) to a federated learning system, the present disclosure focuses on multi-resolution model combination with novel orthogonal constraints. In prior art work, model interpolation has been used only to obtain better performance capabilities for federated training, but is not used to provide backup solutions when communication failures occur. The present disclosure provides backup solutions for such failed connection cases.To address the problems of representation inadequacy as well as computational efficiency, the present disclosure proposes embodiments that include the following method. A pool of multiple models is stored on a server or repository from which each client retrieves or retrieves for each round of learning. Clients can select and retrieve from a list of models based on their resource boundary and train the models locally on their own data. After local training, clients may send information back for the server or repository to aggregate and update the multiple models. Adding orthogonal regularization for neural network training can promote model performance as well as robustness and diversity. Therefore, the present disclosure provides novel client-side loss functions to help the optimization process controlling the learning task, as well as a server-side loss function to ensure and achieve the diversity property. In this way, the training of several models with various (semi-orthogonal) properties in federation is performed.The federated learning system may utilize machine learning training and processes as shown in FIGS. 1-2. FIG. 1 shows a system 100 for training a neural network, e.g. a deep neural network. The neural network being trained may reside on the server or the client. In other words, both the server and the client may use the teachings of FIG. 1. The system 100 may include an input interface for accessing training data 102 for the neural network. For example, as shown in FIG. 1, the input interface may be formed by a data storage interface 104 that may access the training data 102 from data storage 106. For example, the data storage interface 104 may be a storage interface or a persistent storage interface, e.g., a hard disk or an SSD interface, but may also be a personal, local or wide area network interface, such as a Bluetooth, Zigbee, or WiFi interface, or an Ethernet or fiber optic interface. The data storage 106 may be internal data storage of the system 100, such as a hard disk or SSD, but also external data storage, e.g., network-accessible data storage.In some embodiments, the data storage 106 may further include a data representation 108 of an untrained version of the neural network that may be accessed by the system 100 from the data storage 106. However, it should be appreciated that the training data 102 and the data representation 108 of the untrained neural network may also be accessed from a different data storage, e.g., via a different subsystem of the data storage interface 104. Each subsystem may be of a type described above for the data storage interface 104. In other embodiments, the data representation 108 of the untrained neural network may be generated internally by the system 100 based on design parameters for the neural network and therefore may not be expressly stored in the data storage 106. The system 100 may further include a processor subsystem 110 that may be configured to provide an iterative function to replace a stack of layers of the neural network to be trained during operation of the system 100. Respective layers of the stack of layers that are replaced may here have weights divided from each other and may receive as input an output of a previous layer or for a first layer of the stack of layers an initial activation and a portion of the input of the stack of layers. The processor subsystem 110 may be further configured to iteratively train the neural network using the training data 102.An iteration of the training by the processor subsystem 110 may here include a forward propagation portion and a backward propagation portion. The processor subsystem 110 may be configured to execute the forward propagation portion by determining an equilibrium point of the iterative function at which the iterative function converges to a fixed point, wherein determining the equilibrium point comprises using a numerical root finding algorithm to find a root solution for the iterative function minus its input, among other operations defining the forward propagation portion that may be executed, and by providing the equilibrium point as a replacement for an output of the 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; this data may also be referred to as trained model data 112. For example, as also shown in FIG. 1, the output interface may be formed by the data storage interface 104, which interface in these embodiments is an input / output, IO, interface through which the trained model data 112 may be stored in the data storage 106. For example, the data representation 108 defining the "trained" neural network may be at least partially replaced with the trained neural network data representation 112 during or after training in that the neural network parameters, such as weights, hyperparameters, and other types of neural network parameters, may be adjusted to reflect training on the training data 102. This is also illustrated in Figure 1 with reference numerals 108, 112 which relate to the same data record in the data storage 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 be generally of a type as described above for the data storage interface 104.The structure of the system 100 is an example of a system that can be used to train the models that can be used by the federated learning system described herein. Additional structure for operating and training these machine learning models is shown in FIG. 2.FIG. 2 shows a federated learning system 200 configured to execute and train the machine learning models described herein, for example, the neural networks or deep neural networks. The system 200 may be implemented to perform the federated learning processes described herein. The system 200 may include at least one data processing system 202. The data processing system 202 may be part of or executed by a client device, such as a smartphone, an Internet of Things device, a medical device, or other device, such as those described herein with reference to FIGS. 6-11 described below. For example, and not by way of limitation, the data processing system 202 may be an embedded computer system, a SoC (system on a chip), an SBC (single board computer system) (such as a COM (computer on module) or SOM (system on module)), a laptop computer, a personal device such as a smartphone or tablet, a mesh of personal devices, or a combination thereof. The data processing system 202 may include at least one processor 204 operatively connected to a storage unit 208. The processor 204 may include one or more integrated circuits that implement the functionality of a CPU (central processing unit) 206. The CPU 206 may be a commercially available processing unit that implements an instruction set such as one of the instruction set families x86, ARM, Power, or MIPS. During operation, the CPU 206 may execute stored program instructions that are retrieved from the memory unit 208. The stored program instructions may include software that controls the operation of the CPU 206 to perform the operation described herein. In some examples, processor 204 may be an on-a-chip (SoC) system that integrates the functionality of CPU 206, memory unit 208, a network interface, and input / output interfaces into a single integrated device. The data processing system 202 may implement an operating system for managing various aspects of the operation. While a processor 204, a CPU 206, and a memory 208 are shown in FIG. 2, more than one of them may, of course, be used in an overall system.The storage unit 208 may include volatile memory and nonvolatile memory for storing instructions and data. The 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 maintains data when the data processing system 202 is deactivated or disconnected from power. The volatile memory may include static or dynamic random access memory (RAM) storing program instructions and data. For example, the storage unit 208 may store a machine learning model 210 or algorithm(s), a training dataset 212 for the machine learning model 210, raw source dataset 216.The data processing system 202 may include a network interface device 222 configured to provide communication with external systems and devices. For example, the network interface device 222 may include a wired and / or wireless Ethernet interface in accordance with 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 be further configured to provide a communication interface to an external network 224 or a cloud, whereby the device executing the data processing system 202 (e.g., client device) may communicate with the server 230.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 networks.One or more servers 230 may be in communication with the external network 224. Each server may include a data processing system, such as data processing system 202, such that server 230 is configured to perform machine learning and train neural networks. Of course, in accordance with the spirit of the present disclosure, certain personal or sensitive raw source data 216 originating from a particular client device may not be transferred to the server 230, and thus the raw source data may not exist in the server or may be completely independent of the raw source data on a computing system 202 of a client device. During operation of the federated learning system, as described below, the data processing system 202 associated with a client device may exchange portions of the training data 212, but not the raw source data 216 or any personal data, so as to preserve privacy for any sensitive personal data residing on the client device. Server 230 may then access this information via connection to network 224 and update its stored models on the server side.The data processing system 202 may include an input / output or I / O interface 220, which may be configured to provide digital and / or analog inputs and outputs. I / O interface 220 is used to transfer information between internal storage and external input and / or output devices (e.g., HMI devices). The I / O interface 220 may include associated circuitry or bus networks for transferring information to or between the processor(s) and storage. For example, the I / O interface 220 may include digital I / O logic lines that may be read or set by the processor(s), handshake lines to oversee data transfer over the I / O lines, timing and counting devices, and other structure known to provide such functions. Examples of input devices include a keyboard, a mouse, a camera, sensors, etc. Examples of output devices include monitors, screens, printers, speakers, etc. The I / O interface 220 may include additional serial interfaces for communication with external devices (e.g., a Universal Serial Bus (USB) interface). The I / O interface 220 may be referred to as an input interface (insofar as it transfers data from an external input, such as a sensor), or an output interface (insofar as it transfers data to an external output, such as a display).The data processing 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 include human interface inputs such as a keyboard, a mouse, a touch screen, voice input devices (e.g., a microphone), and other similar devices. The data processing system 202 may include a display device 232. The data processing 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 device for displaying information to a user or operator. The data processing system 202 may be further configured to allow interaction with remote HMI and remote display devices via the network interface device 222.The system 200 may be implemented using one or more computing systems. While the example shows a single computing system 202 implementing all of the described features, it is intended that various features and functions may be separated and implemented by multiple computing devices in communication with one another. In particular, a client device may implement the data processing system 202, and the server 230 may also include its own data processing system 202. The particular system architecture selected depends on a variety of factors.The federated learning system 200 may be implemented as a machine learning algorithm 210 configured to analyze the raw source dataset 216. The raw source dataset 216 may include raw or raw sensor data, which may represent an input dataset for a machine learning system. The raw source dataset 216 may include video, video segments, images, text-based information, audio or human speech, time-series data (e.g., pressure sensor signal over time), and raw or partially processed sensor data (e.g., radar map of objects). The raw source dataset 216 may include sensitive or personal data with increased security needs and therefore the raw source dataset 216 may not be transferred from the client device to the server 230. With reference to FIGS. 5-11, several different examples of inputs are shown and described. In some examples, the machine learning algorithm 210 may be a neural network algorithm (e.g., deep neural network) configured to perform a predetermined function. For example, in automotive applications, the neural network algorithm may be configured to identify traffic signs or pedestrians in images. The neural network algorithm may be configured to automatically correct text or speech based on the context of the words from the individual.The data processing system 202 may store a training dataset 212 for the machine learning algorithm 210. The training data set 212 may represent a set of previously created data for training the machine learning algorithm 210. The training dataset 212 may be used by the machine learning algorithm 210 to learn weighting factors associated with a neural network algorithm. The training data set 212 may include a set of source data having corresponding results or results that the machine learning algorithm 210 attempts to duplicate via the learning process.The machine learning algorithm 210 may be operated in a learning mode using the training dataset 212 as input. The machine learning algorithm 210 may be executed using the data from the training dataset 212 over a series of iterations. At each iteration, the machine learning algorithm 210 may update internal weighting factors based on the obtained results. For example, the machine learning algorithm 210 may compare output results (e.g., a reconstructed or augmented image if image data is the input) with those included in the training dataset 212. Because the training dataset 212 includes the expected results, the machine learning algorithm 210 may determine when the performance is acceptable. After the machine learning algorithm 210 reaches a predetermined level of performance (e.g., 100% match with the results associated with the training dataset 212) or convergence, the machine learning algorithm 210 may be executed using data not included in the training dataset 212. It should be understood that "convergence" in this disclosure may mean that a fixed (e.g., predetermined) number of iterations has occurred, or that the remainder is sufficiently small (e.g., the change in approximate probability over iterations changes by less than a threshold), or other convergence conditions. The trained machine learning algorithm 210 may be applied to new data sets to generate annotated data.The machine learning algorithm 210 may be configured to identify a particular feature in the raw source data 216. The raw source data 216 may include a plurality of instances or an input dataset for which augmentation results are desired. For example, the machine learning algorithm 210 may be configured to detect the presence of a person in video images and annotate the incidents. The machine learning algorithm 210 may be programmed to process the raw source data 216 to identify the presence of the particular features. The machine learning algorithm 210 may be configured to identify a feature in the raw source data 216 as a predetermined feature (e.g., a particular word if text or spoken words are the input). The raw source data 216 may be derived from a variety of sources. For example, the raw source data 216 may be actual input data collected by a machine learning system. The raw source data 216 may be machine generated to test the system. For example, raw source data 216 may include raw images or video from a camera, spoken words from a microphone, or typed or written words from a keyboard or touch screen, or the like.FIG. 3A illustrates an example diagram or layout of a federated learning system 300 according to an embodiment. The federated learning system 300 here includes a server 302 and a pool 304 of multiple client devices 306. The server 302 may correspond to the server 230, and the client devices 304 may correspond to devices (e.g., cameras, smart phones, etc.) described above. Both the server 302 and each of the client devices 306 may execute the machine learning processes described herein, for example, via a respective computing system 202. The server 302 may be a centralized server that stores a number L of (e.g., randomly) initialized models (e.g., based on neural networks) represented as W 1, W 2,..., W L. W con represents linked weights of models W 1, W 2,..., W L. The server 302 may orchestration 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.The client devices and the server may each operate with a set of parameters. In one embodiment, a client pool shown at 304 includes a number N of clients 306 in federated learning system 300. The clients have categorized levels of hardware resources (bill, memory, etc.). A number of incrementally-fetched models by client i is referred to as l i where l is 2, ∈[L]. A larger l i indicates better existing hardware characteristics (e.g., a device with more computational resources, processing power, memory, etc.). Further, S i= {1,2,..., l i} may represent the set of model index for client i, and Z l= { i:l ∈ S i}, where Z I is the index for clients that have obtained model l. For each client i, its locally stored data is referred to as (D i, y i). For each client, its local models areFor example, assuming a set of selected intermediate layer latent output features (defined by various tasks, architecture, and data-driven criteria), these features may be represented as. In addition, there may be some other parameters as follows. For local client training, a number of epochs of training between each round of communication (with server), batch size, learning rate, optimizer type, and so forth. If a connected neighbor group is referred to as G, clients may be with failures of index b. Therefore, the neighbors of client b can be referred to as C b= [ i, G(i, b)≠0}.The neural networks trained and executed in either server 302 or client devices in client pool 304 may be exemplified by the illustration shown in FIG. 4. FIG. 4 shows an embodiment of a model that is subjected to training by either the server or the client. As discussed above, the federated learning system may include machine learning models, such as neural network (e.g., and in some cases, although not required, deep neural network) based models. The model may include an input layer (having multiple input nodes) and an output layer (having multiple output nodes). In some examples, the model may include multiple hidden layers. The nodes of the input layer, the output layer, and the hidden layers may be coupled to nodes of subsequent or previous layers. And each of the nodes of the output layer may perform an activation function, e.g., a function that helps whether the respective nodes should be activated to provide an output of the model. The numbers of nodes shown in the input, hidden, and output layers are merely exemplary, and any suitable numbers may be used.Referring again to FIG. 3A, at the beginning of each round of federated training, the server 302 sends model information to each qualified (e.g., online, responsible, etc.) Client device 306, e.g., this may be via networked communication, such as illustrated and described with reference to FIG. 2. After each client device 306 receives the information from the server 302, each client device 306 begins training on its locally stored data (D i, y i). The loss of each client i is denoted L i where λ is an adjustable hyperparameter corresponding to a regularization term that controls the relative weight between learning of the task, reaching or ensuring model diversity. Since latent features represent from selected intermediate layers, the concatenated latent features may be represented asA regularization term R may be defined asThe distance function of equation (3) may be represented as or ||A - B|| ∞ or σ(A - B), or a weighted average thereof with σ as a spectral norm or angle margin contrast regularizer, etc. Client i can solve the loss optimization as indicated in equation (1) above (either exactly or approximately) and derives updates for.The client devices may then send the updated weights to the server for aggregation and update of the models on the server side without transferring raw personal source data. In the aggregation phase, the server receives information from the clients and performs aggregation. To aggregate the information and have model diversity, the server may solve the following optimization to obtain updates for W 1, W 2,..., W LHere, the first term may be converted to other types of re-weighting and the second term may be generated in other metrics. Note here that W con denotes the linked weights of the plurality of server-maintained machine learning models W 1, W 2,..., W L. The aggregation process on the server side solves an optimization problem for finding updated weights W 1, W 3,..., W L such that each W l, comes close to the average of weights collected from clients getting the model l (or about whose model sets S i have the model l), and also attempts to meet the diversity constraints.This process may repeat or loop until a stop criterion is reached, such as convergence or a certain number of rounds or tolerance. Alternatively, this continuous learning process may repeat continuously or may loop.In addition to the training process, if any client b has a communication failure to the server, that separate client (or node) may retrieve the machine learning model from its neighboring clients or nodes and perform interpolation of its models as follows: where A i is a linear combination weight for model W i. In one embodiment, neighbors of client b are referred to as C b= { i, G(i, b)≠0}.With this description in the back head, FIG. 3B shows a flowchart of a method 350 for training neural networks via federated learning. The method has a server side, wherein functions are performed in one or more of the servers (e.g., servers 230), and a client side, wherein functions are performed in the clients (e.g., client devices 306). At 352, the server maintains multiple machine learning models, for example, models W 1, W 2, W 3..., W L. shown at 302. These models may be global models that may be distributed among a variety of client devices.The models are transferred to the various clients. The models selected for transfer may conform to the needs or requirements of the clients to which they are transferred. Then, in each of the clients to which the models are transferred, the models are trained with locally stored data on that respective client. In other words, each client device uses its own locally stored data (D i, y i,) to train the model or models it receives from the server.During training, at 356, each client device may determine losses and update weights of the models it trains in that particular client device. The loss of each client device is exemplified above in equation (1). An adjustable hyperparameter R corresponding to a regularization term controls the relative weight between learning the particular task and achieving model diversity. The regularization is shown above in equation (1) as an example.If a client is disconnected from communication with the server or otherwise unable to receive the model from the server, an optional backup step 357 is provided. Here, the separate client (e.g., client b) or node may retrieve the model from its neighbors. For example, the client device may connect to and receive the model from those nearby devices. This may be via wireless communication, such as any of the wireless communication examples described herein. In one embodiment, the separate client is first matched to another client having a similar make, model, network settings, or the like, which can ensure that the proper model can be transferred from the connected device to the separate device. In one embodiment, the separate device client b may perform interpolation of the received models from the connected client(s) according to equation (4) above. The neighbor client may be selected to communicate the model with the separate client depending on the neighbor client being within range of particular wireless communication, such as direct client-to-client communication (e.g., WiFi, Bluetooth, short range communication, DSRC (dedicated short range communication), etc.). Once the separate device client b receives the model(s) from the other neighbor devices or nodes, the separate device client b may perform the training of 354 and loss determination and weight update of 356 based on the locally stored data in the separate device client b.The updated weights trained with the locally stored data in the clients may then be transferred to the server. Again, it should be noted that the locally stored data is not transferred. At 358, the server trained its multiple machine learning models with the received information from the clients. Specifically, the server may set the weights of its models based on the weight adjustment information experienced by the client devices. This can be done using equation (3) as an example in aggregation. Losses can also be determined on the server side during training in the server.Steps 352- 358 may be fully or partially repeated, for example, until convergence is repeated in a loop, or continuously in continuous learning.The machine learning models described herein may be used in many different applications. As described above, the raw source data stored locally may be image data, sound data, or the like, and thus, in FIG. 6-11, as an example, various applications in which this data is retrieved or used are shown. Structure used for training and use of machine learning models for these applications (and other applications) are exemplified in FIG. 5. FIG. 5 shows a schematic illustration of interaction between a computer controlled machine 500 and a control system 502. 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 state of the computer controlled machine 500. The sensor 506 may be configured to encode the sensed state into sensor signals 508 and transmit the sensor signals 508 to the control system 502. Non-limiting examples of the sensor 506 include video, radar, lidar, microphone, ultrasonic, and motion sensors. In one embodiment, sensor 506 is an optical sensor configured to acquire optical images of an environment proximate to computer controlled machine 500.The control system 502 is configured to receive the sensor signals 508 from the computer controlled machine 500. As set forth below, the control system 502 may be further configured to calculate actuator control commands 510 and transmit the actuator control commands 510 to the actuator 504 of the computer controlled machine 500 depending on the sensor signals.As shown in FIG. 5, the control system 502 includes a receiving unit 512. The receiving unit 512 may be configured to receive sensor signals 508 from the sensor 506 and to transform the sensor signals 508 into input signals x. In an alternative embodiment, the sensor signals 508 are received directly as input signals x without the receiving unit 512. Each input signal x may be a portion of each sensor signal 508. The receiving unit 512 may be configured to process each sensor signal 508 to produce each input signal x. The input signal x may include data corresponding to an image recorded by the sensor 506.The control system 502 includes a classifier 514. The classifier 514 may be configured to classify input signals x into one or more labels using a machine learning algorithm, such as a neural network described above. The classifier 514 is configured to be parameterized by parameters such as those described above (e.g., parameters θ). Parameter θ may be stored in and provided by non-volatile storage 516. The classifier 514 is configured to determine output signals y from input signals x. Each output signal y includes information that assigns one or more labels to each input signal x. The classifier 514 may transmit output signals y to the conversion unit 518. The conversion unit 518 is configured to convert output signals y into actuator control commands 510. The control system 502 is configured to transmit the actuator control commands 510 to the actuator 504, which is configured to actuate the computer controlled machine 500 in response to actuator control commands 510. In another embodiment, the actuator 504 is configured to actuate the computer controlled machine 500 directly based on the output signals y.Upon receipt of the actuator control commands 510 by the actuator 504, 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 convert the actuator control commands 510 to a second actuator control command used to control the actuator 504. In one or more embodiments, actuator control commands 510 may be used to control a display instead of or in addition to an actuator.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.As shown in FIG. 5, 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 storage devices. The classifier 514 (e.g., machine learning algorithms as described above) of one or more embodiments may be implemented by the control system 502 including the non-transitory storage 516, the processor 520, and the memory 522.The non-volatile storage 516 may include one or more persistent storage devices, such as a hard disk, an optical drive, a tape drive, a non-volatile solid state device, cloud storage, or any other device capable of permanently storing information. The processor 520 may be any of the processors or processor subsystems described above with reference to FIGS. 1-2, and may include one or more devices selected from high-performance computing (HPC) systems including high-performance cores, microprocessors, microcontrollers, digital signal processors, microcomputers, central processing units, field programmable gate arrays, programmable logic devices, state machines, logic circuits, analog circuits, digital circuits, tensor processor, graphics processor, ASIC, or any other device that manipulate (analog or digital) signals based on computer-executable instructions residing in a memory 522. The memory 522 may include a single memory device or a number of 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.The processor 520 may be configured to read into the memory 522 and execute computer-executable instructions residing in the non-transitory storage 516 that implement one or more machine learning algorithms and / or methodologies of one or more embodiments. The non-volatile storage 516 may include one or more operating systems and applications. The non-transitory storage 516 may be compiled and / or interpreted from computer programs created using a variety of programming languages and / or technologies, including, without limitation, and either alone or in combination, Java, C, C++, C#, Objective-C, Fortran, Pascal, Java Script, Python, Perl, and PL / SQL.When executed by the processor 520, the computer-executable instructions of the non-transitory storage 516 may cause the control system 502 to implement one or more of the machine learning algorithms and / or methodologies disclosed herein. The non-transitory storage 516 may also include machine learning data (including data parameters) that support functions, features, and processes of the one or more embodiments described herein.The program code implementing the algorithms and / or methodologies described herein may be distributed individually or collectively in a variety of different forms as a program product. The program code may be distributed using a computer readable storage medium having computer readable program instructions thereon for causing a processor to execute aspects of one or more embodiments. Computer readable storage media that are inherently non-transitory may include volatile and non-transitory 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. Computer readable storage media 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 disc read only memory (CD-ROM), or other optical storage, magnetic cassettes, magnetic tape, magnetic disk storage or other magnetic storage devices, or any other medium that can be used to store the desired information and read by a computer. Computer readable program instructions may be downloaded from a computer readable storage medium to a computer, other type of programmable data processing apparatus or other device, or via a network to an external computer or device.Computer readable program instructions stored on a computer readable medium may be used to direct a computer, other types of programmable data processing apparatus, or other devices to operate in a particular manner, such that the instructions stored on the computer readable medium produce an article of manufacture including instructions that implement the functions, acts, and / or operations specified in the flowcharts or diagrams. In certain alternative embodiments, the functions, acts, and / or operations specified in the flowcharts and diagrams may be reordered, serially processed, and / or concurrently processed in accordance with one or more embodiments. Additionally, any of the flowcharts and / or diagrams may include more or fewer nodes or blocks than those illustrated in accordance with one or more embodiments.The processes, methods, or algorithms can be implemented in whole or in part using suitable hardware components, such as application specific integrated circuits (ASICs), field programmable gate arrays (FPGAs), state machines, controllers or other hardware components or devices, or a combination of hardware, software and firmware components.FIGS. 6-11 show embodiments of environments in which the federated learning systems described herein may be implemented. Each of these embodiments shows an embodiment of a client device. Data originating from the sensor 506 in these embodiments may be the raw source data used to train a machine learning model on board the device (client), but is not transferred to the server to protect the data. FIG. 6 shows a schematic illustration of a control system 502 configured to control a vehicle 600, which may be an at least partially autonomous vehicle or robot. The vehicle 600 includes an actuator 504 and a sensor 506. The sensor 506 may include one or more video sensors, cameras, a microphone, radar sensors, ultrasonic sensors, LiDAR sensors, and / or position sensors (e.g., GPS). One or more of the one or more specific sensors may be integrated with the vehicle 600. The sensor 506 may include a software module that, when executed, is configured to determine a state of the actuator 504. A non-limiting example of a software module would be a weather information software module configured to determine a current or future state of the weather in the vicinity of the vehicle 600 or another location.The classifier 514 of the control system 502 of the vehicle 600 may be configured to detect objects in the vicinity of the vehicle 600 depending on input signals x. In such an embodiment, the output signal y may include information characterizing the environment of objects of the vehicle 600. The actuator control command 510 may be determined according to this information. The actuator control command 510 may be used to avoid collisions with the detected objects. The raw source data for federated learning may include the raw images of the vehicle environment, however, the processing of the objects in the environment by the vehicle could change weights in the machine learning model used onboard the vehicle; these adjusted weights may then be returned to the models of the server for update.In embodiments where the vehicle 600 is an at least partially autonomous vehicle, the actuator 504 may be implemented in a brake, drive system, engine, powertrain, or steering of the vehicle 600. Actuator control commands 510 may be determined to control actuator 504 such that vehicle 600 avoids collisions with detected objects. Detected objects may also be classified as to which classifier 514 is most likely to hold, for example, pedestrians or trees. The actuator control commands 510 may be determined depending on the classification. In a scenario where an opposing attack could occur, the system described above may be further trained to better detect objects or identify a change in lighting conditions or angle for a sensor or camera on the vehicle 600.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 walking. 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 command 510 may be determined such that a drive unit, steering unit, and / or braking unit of the mobile robot may be controlled such that the mobile robot may avoid collisions with identified objects.In another embodiment, the vehicle 600 is an at least partially autonomous robot in the form of a garden robot. In such an embodiment, the vehicle 600 may use an optical sensor as the sensor 506 to determine a condition of plants in an environment proximate the vehicle 600. The actuator 504 may be a nozzle configured to spray chemicals. Depending on an identified species and / or condition of the plants, the actuator control command 510 may be determined to cause the actuator 504 to spray the plants with an appropriate amount of suitable chemicals.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, oven, oven, microwave oven, or dishwasher. In such a vehicle 600, the sensor 506 may be an optical sensor configured to detect a state of an object to be subjected to processing by the home appliance. For example, if the household appliance is a washing machine, the sensor 506 may detect a state of the laundry in the washing machine. The actuator control command 510 may be determined based on the detected state of the laundry.FIG. 7 shows a schematic diagram of a control system 502 configured to control a system 700 (e.g., manufacturing machine) such as a die cut device, a cutting device, or a gun drill, a manufacturing system 702, such as part of a manufacturing line. The control system 502 may be configured to control an actuator 504 configured to control the system 700 (e.g., manufacturing machine).A sensor 506 of the system 700 (e.g., manufacturing machine) may be an optical sensor configured to sense one or more characteristics of a make 704. The classifier 514 may be configured to determine a state of the product 704 from one or more of the detected characteristics. The actuator 504 may be configured to control the system 700 (e.g., the manufacturing machine) depending on the particular state of the fab 704 for a subsequent manufacturing step of the fab 704. The actuator 504 may be configured to control functions of the system 700 (e.g., manufacturing machine) at a next make 706 of the system 700 (e.g., manufacturing machine) depending on the predicted state of the make 704.FIG. 8 shows a schematic diagram of a control system 502 configured to control a power tool 800, such as a drilling machine or an electric power drill, having an at least partially autonomous mode. The control system 502 may be configured to control an actuator 504 configured to control the power tool 800.The sensor 506 of the power tool 800 may be an optical sensor configured to sense one or more characteristics of the work surface 802 and / or the fastener 804 being driven into the work surface 802. The classifier 514 may be configured to determine a state of the work surface 802 and / or the fastener 804 relative to the work surface 802 from one or more of the detected characteristics. The condition may be that the fixture 804 is flush with the work surface 802. Alternatively, the condition may be hardness of the working surface 802. The actuator 504 may be configured to control the power tool 800 to adjust the driving function of the power tool 800 depending on the particular state of the fastener 804 relative to the work surface 802, or one or more sensed characteristics of the work surface 802. For example, the actuator 504 may stop the propulsion function when the state of the fastener 804 is flush relative to the work surface 802. As another non-limiting example, the actuator 504 may apply more or less torque depending on the hardness of the working surface 802.FIG. 9 shows a schematic illustration of the control system 502 configured to control an automated personal assistant 900. The control system 502 may be configured to control the 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, oven, oven, microwave, or dishwasher.The sensor 506 may be an optical sensor and / or an audio sensor. The optical sensor may be configured to receive video images of gestures 904 of the user 902. The audio sensor may be configured to receive a voice command of the user 902.The control system 502 of the automated personal assistant 900 may be configured to determine actuator control commands 510 configured to control the system 502. The control system 502 may be configured to determine actuator control commands 510 according to sensor signals 508 of the sensor 506. The automated personal assistant 900 is configured to transmit sensor signals 508 to the control system 502. The classifier 514 of the control system 502 may be configured to execute a gesture recognition algorithm to identify a gesture 904 of the user 902, to determine actuator control commands 510, and to transmit the actuator control commands 510 to the actuator 504. Classifier 514 may be configured to retrieve information from the non-volatile storage in response to gesture 904 and output the retrieved information in a form suitable for receipt by user 902.FIG. 10 shows a schematic diagram of the control system 502 configured to control a monitoring system 1000. The monitoring system 1000 may be configured to physically control access through a door 1002. The sensor 506 may be configured to detect a scene relevant in deciding whether access is granted. The sensor 506 may be an optical sensor configured to generate and transmit image and / or video data. Such data may be used by the control system 502 to detect a person's face.The classifier 514 of the control system 502 of the monitoring system 1000 may be configured to interpret the image and / or video data by matching with identities of known persons stored in the non-volatile storage 516, thereby determining an identity of a person. The classifier 514 may 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 may 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.The monitoring system 1000 may also be an observation system. In such an embodiment, the sensor 506 may be an optical sensor configured to detect an observed scene and the control system 502 is configured to control the display 1004. The classifier 514 is configured to determine a classification of a scene, e.g., whether the scene detected by the sensor 506 is suspect. 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 emphasize an object deemed suspect by the classifier 514. Using an embodiment of the disclosed system, the observation system can predict objects that appear at certain times in the future.FIG. 11 shows a schematic diagram of the control system 502 configured to control an imaging system 1100, for example an MRI apparatus, an X-ray imaging apparatus or an ultrasound apparatus. The sensor 506 may be, for example, an imaging sensor. The classifier 514 may be configured to determine a classification of all or a portion of the captured image. The classifier 514 may be configured to determine or select an actuator control command 510 in response to the classification obtained by the trained neural network. For example, classifier 514 may interpret a region of a captured image as potentially abnormal. In this case, the actuator control command 510 may be determined or selected to cause the display 1102 to display the imaging and emphasize the potentially abnormal region. The captured image may be used internally in a hospital environment to train machine learning systems in the hospital (client), but this data is not sent to the server for training the models of the server. Instead, the set weights of the hospital set based on the captured images may be sent to the server to set the weights on the server side.While exemplary embodiments are described above, it is not intended that these embodiments describe all possible forms encompassed by the claims. The terms used in the specification are terms of description and not limitation, and it is understood that various changes may be made without departing from the spirit and scope of the disclosure. As described above, the features of various embodiments may be combined to form further embodiments of the invention that may not be explicitly described or illustrated. While various embodiments may have been described as providing advantages or being preferred over other embodiments or prior art implementations with respect to one or more desired characteristics, those of ordinary skill in the art recognize that one(s) or more features or characteristics may be compromised to achieve desired overall system attributes, which depend on the particular application and implementation. These attributes may include, but are not limited to, cost, strength, durability, life cycle cost, marketability, appearance, packaging, size, serviceability, weight, microencapsulated quality, ease of assembly, etc. Thus, when embodiments are described as less desirable than other embodiments or prior art implementations with respect to one or more characteristics, these embodiments are not outside the scope of the disclosure and may be desirable for particular applications.

Claims

A method for training federated learning neural networks, the method comprising: sending at least portions of a plurality of server-maintained machine learning models from a server to a plurality of clients, thereby yielding a plurality of local machine learning models; training the plurality of local machine learning models in each client with locally stored data locally stored in that respective client, wherein the training in each client comprises determining a respective loss for each of the plurality of local machine learning models and updating respective weights for each of the plurality of local machine learning models; transferring the respective updated weights from each client to the server without transferring the locally stored data of the clients; training the plurality of server-maintained machine learning models in the server with the updated weights sent from each of the clients; determining that a first client of the plurality of clients is separate or otherwise unable to receive the at least portions of the plurality of server-maintained machine learning models from the server; connecting the first client to a neighbor client capable of communicating with the server; and sending the portions of the plurality of server-maintained machine learning models from the neighbor client to the first client.The method of claim 1, wherein the connecting comprises connecting the first client to a plurality of neighboring clients capable of communicating with the server, and wherein transmitting the portions comprises transmitting the portions of the plurality of server-maintained machine learning models from the plurality of neighboring clients to the first client.The method of claim 2, further comprising: performing interpolation on the first client of the portions of the plurality of server-maintained machine learning models received from the plurality of neighboring clients.The method of claim 3, wherein the interpolation is: W + = W + ∑ { i ∈ C b } A i ⋅ ( W i - W ), wherein W + is an interpolated model for models W received by the plurality of neighboring clients C b and wherein A i is a linear combination weight for the model W i.The method of claim 4, wherein the weighted combination A i is represented by: A i = L b ( W ) - L b ( W i ) | | W - W i | | 2 where L b is a loss associated with the first client.The method of claim 1, further comprising: selecting the neighbor client for communication with the first client based on the neighbor client already receiving the at least portions of the plurality of server-maintained machine learning models from the server.The method of claim 1, wherein the neighbor client is a plurality of neighbor clients.A system for training federated learning neural networks, the system comprising: memory storing instructions; and a plurality of processors that, when executing the instructions stored in the memory, collectively perform: sending at least portions of a plurality of server-maintained machine learning models from a server to a plurality of clients, thereby yielding a plurality of local machine learning models; training the plurality of local machine learning models in each client with locally stored data stored locally in that respective client, wherein the training in each client comprises determining a respective loss for each of the plurality of local machine learning models and updating respective weights for each of the plurality of local machine learning models; transferring the respective updated weights from each client to the server without transferring the locally stored data of the clients; training the plurality of server-maintained machine learning models in the server with the updated weights sent from each of the clients; determining that a first client of the plurality of clients is separate or otherwise unable to receive the at least portions of the plurality of server-maintained machine learning models from the server; connecting the first client to a neighbor client capable of communicating with the server; and sending the portions of the plurality of server-maintained machine learning models from the neighbor client to the first client.The system of claim 8, wherein the connecting comprises connecting the first client to a plurality of neighboring clients capable of communicating with the server, and wherein the sending the portions comprises sending the portions of the plurality of server-maintained machine learning models from the plurality of neighboring clients to the first client.The system of claim 9, wherein the instructions further cause the processors to collectively perform: performing interpolation of the portions of the plurality of server-maintained machine learning models received from the plurality of neighboring clients.The system of claim 10, wherein the interpolation is: W + = W + ∑ { i ∈ C b } A i ⋅ ( W i - W ), wherein W + is an interpolated model for models W received by the plurality of neighboring clients C b and wherein A i is a linear combination weight for the model W i.The system of claim 11, wherein the loss difference ratio A i is represented by: A i = L b ( W ) - L b ( W i ) | | W - W i | | 2 where L b is a loss associated with the first client.The system of claim 8, wherein the instructions further cause the processors to collectively perform: selecting the neighbor client for communication with the first client depending on the neighbor client already having received the at least portions of the plurality of server-maintained machine learning models from the server.The system of claim 8, wherein the neighbor client is a plurality of neighbor clients.A method for training federated learning neural networks, the method comprising: sending at least portions of a plurality of server-maintained machine learning models from a server to a plurality of clients, thereby yielding a plurality of local machine learning models; determining that a first client of the plurality of clients is separate or otherwise unable to receive the at least portions of the plurality of server-maintained machine learning models; training the plurality of local machine learning models in each of the plurality of clients, other than the first client, with locally stored data stored locally in that respective client, wherein training in each client comprises determining a respective loss for each of the plurality of local machine learning models and updating respective weights for each of the plurality of local machine learning models; transferring the respective updated weights from each of the plurality of clients other than the first client to the server without transferring the locally stored data of the clients; connecting the first client to a plurality of neighboring clients of the plurality of clients capable of communicating with the server; sending the portions of the plurality of server-maintained machine learning models from the neighboring clients to the first client, training the plurality of local machine learning models in the first client with locally stored data locally stored in that first client, wherein training in the first client comprises determining a loss for each of the plurality of local machine learning models and updating weights associated with each of the local machine learning models; sending the updated weights from the first client to the server once the first client is reconnected to the server; training the plurality of server-maintained machine learning models in the server with the updated weights from the first client.The method of claim 15, further comprising: performing interpolation on the first client of the portions of the plurality of server-maintained machine learning models received from the plurality of neighboring clients.The method of claim 16, wherein the interpolation is: W + = W + ∑ { i ∈ C b } A i ⋅ ( W i - W ), wherein W + is an interpolated model for models W received by the plurality of neighboring clients C b and wherein A i is a linear combination weight for the model W i.The method of claim 17, wherein the loss difference ratio A i is represented by: A i = L b ( W ) - L b ( W i ) | | W - W i | | 2 where L b is a loss associated with the first client.The method of claim 15, further comprising: selecting the neighbor client for communication with the first client depending on the neighbor clients being in a short distance wireless communication with the first client.The method of claim 15, further comprising: selecting the plurality of server-maintained machine learning models from a pool of machine learning models, wherein the plurality of server-maintained machine learning models are selected from the pool based on resource boundaries associated with the plurality of clients.

Images