Federated learning with model diversity and backup with disconnected clients

Abstract

Methods and systems for training a neural network using federated learning. The server-maintained machine learning model is sent from the server to the plurality of clients, thereby generating a local machine learning model. At each client, a local machine learning model is trained with local stored data stored locally at the respective client. For each of the local machine learning models, a respective loss is determined and a weight is updated. The updated weights are passed to the server for updating the server-maintained machine learning models for training those models. If one of the clients is disconnected or otherwise unable to receive a server-maintained model, the disconnected client may connect to neighboring clients to receive models from those neighboring clients and train those models with the disconnected client's own local stored data.

Description

Technical Field

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

[0002] 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 data set. Federated learning aims to train a global machine learning algorithm (e.g., a deep neural network) based on multiple local data sets contained in a local node (also known as a client) 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 transmits 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, thereby allowing the user to reap the advantages of a shared model trained from the client's data without having to transfer or centrally store data from the client. This is particularly useful in situations where the exchange of sensitive or personal data (e.g., medical information, IoT devices, personal devices, such as smart phones) is excluded. Summary of the invention

[0003] In an embodiment, a method for training a neural network using federated learning includes the following: sending at least a portion of a plurality of server-maintained machine learning models from a server to a plurality of clients, thereby generating a plurality of local machine learning models; at each client, training the plurality of local machine learning models using local storage data stored locally at the corresponding client, wherein the training at each client includes determining a corresponding loss for each of the plurality of local machine learning models and updating a corresponding weight for each of the plurality of local machine learning models; passing the corresponding updated weights from each client to the server without passing the local storage data of the client; at the server, training the plurality of server-maintained machine learning models using the updated weights sent from each of the clients; determining that a first client among the plurality of clients is disconnected or otherwise unable to receive the at least a portion of the plurality of server-maintained machine learning models from the server; connecting the first client to an adjacent client capable of communicating with the server; and sending a portion of the plurality of server-maintained machine learning models from the adjacent client to the first client.

[0004] In an embodiment, a system for training a neural network using federated learning includes: a memory storing instructions and multiple processors, wherein the multiple processors jointly perform the following when executing the instructions stored in the memory: sending at least part of multiple server-maintained machine learning models from a server to multiple clients, thereby generating multiple local machine learning models; at each client, training the multiple local machine learning models using local storage data stored locally at the corresponding client, wherein the training at each client includes determining a corresponding loss for each of the multiple local machine learning models and updating a corresponding weight for each of the multiple local machine learning models; passing the corresponding updated weights from each client to the server without passing the local storage data of the client; at the server, training the multiple server-maintained machine learning models using the updated weights sent from each of the clients; determining that a first client among the multiple clients is disconnected or otherwise unable to receive at least part of the multiple server-maintained machine learning models from the server; connecting the first client to an adjacent client that can communicate with the server; and sending the portion of the multiple server-maintained machine learning models from the adjacent client to the first client.

[0005] In an embodiment, a method for training a neural network using federated learning includes the following: sending at least part of a plurality of server-maintained machine learning models from a server to a plurality of clients, thereby generating a plurality of local machine learning models; determining that a first client among the plurality of clients is disconnected or otherwise unable to receive the at least part of the machine learning models maintained by the plurality of servers; at each of the plurality of clients except the first client, training the plurality of local machine learning models using local storage data stored locally at the corresponding client, wherein the training at each client includes determining a corresponding loss for each of the plurality of local machine learning models and updating a corresponding weight for each of the plurality of local machine learning models; transmitting the local storage data from each of the plurality of clients except the first client to the local storage data without transmitting the local storage data of the client; the first client, transmitting the corresponding updated weights of the plurality of local machine learning models to the server; connecting the first client to a plurality of adjacent clients among the plurality of clients that are capable of communicating with the server; sending portions of the plurality of server-maintained machine learning models from the adjacent clients to the first client; at the first client, training the plurality of local machine learning models using local storage data stored locally at the first client, wherein the training at the first client includes 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; once the first client is reconnected to the server, sending the updated weights from the first client to the server; and at the server, training the plurality of server-maintained machine learning models using the updated weights from the first client. BRIEF DESCRIPTION OF THE DRAWINGS

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

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

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

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

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

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

[0012] Figure 7 Depicts a device configured to control a manufacturing machine of a manufacturing system Figure 5 Schematic diagram of a control system of a manufacturing machine such as a punch cutting machine, a cutting machine or a gun drill, and the manufacturing system such as a part of a production line.

[0013] Figure 8 A device configured to control a power tool having at least a partially autonomous mode is depicted. Figure 5 Schematic diagram of a control system for a power tool such as an electric drill or driver.

[0014] Fig. 9 Depicting a device configured to control an automated personal assistant Figure 5 Schematic diagram of the control system.

[0015] Fig.10 Depicts a device configured to control a surveillance system Figure 5 Schematic diagram of a control system, such as a controlled access system or a monitoring system.

[0016] Fig.11 Depicts a device configured to control an imaging system Figure 5 Schematic diagram of a control system of an imaging system, the imaging system being, for example, an MRI device, an x-ray imaging device or an ultrasound device. DETAILED DESCRIPTION

[0017] Embodiments of the present disclosure are described herein. However, it should be understood that the disclosed embodiments are examples only, and other embodiments may take various and alternative forms. The figures do not have to be drawn to scale; some features may be exaggerated or minimized to show the details of a particular component. Therefore, the specific structural and functional details disclosed herein should not be interpreted as limiting, but only as a representative basis for teaching those skilled in the art to adopt the embodiments in various ways. As will be understood by those skilled in the art, the various features illustrated and described with reference to any one of the figures may be combined with the features illustrated in one or more other figures to produce an embodiment that is not explicitly illustrated or described. The combination of the illustrated features provides a representative embodiment for a typical application. However, various combinations and modifications of features consistent with the teachings of the present disclosure may be desirable for a particular application or implementation.

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

[0019] The present disclosure relates to federated learning. References herein to a "server" of a federated learning system refer to a centralized server (or servers) that communicate with a client to exchange data therewith. For example, one or more servers in the cloud or remote from an end user may constitute a server. References herein to a "client" of a federated learning system refer to a local node or device corresponding to a particular end user. For example, a smartphone, an IoT device, and the like would constitute a client. Each of the server and client may utilize a corresponding computer system for machine learning training, such as those described herein.

[0020] 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 (e.g., 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 transmits 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 client's training, allowing the user to reap the advantages of a shared model trained from the client's data without having to transfer or centrally store the data from the client.

[0021] Federated learning is particularly useful in situations where the exchange of sensitive or personal data (e.g., medical information, IoT devices, personal devices such as smartphones) is excluded. Take smartphones as a simple everyday example. When people type emails or text messages, they may have an auto-correction or auto-fill feature that will automatically correct people's spelling mistakes or suggest corrections or additions to the text. Systems of this kind typically rely on machine learning models trained based on the user's previous word usage, and may differ 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 base model from a server, and the model can be trained locally to perform auto-correction in a manner customized to the word usage history of this particular user. Information about how the model is trained locally can be sent to the server without sending the raw data (e.g., the user's words and / or corrections) to the server.

[0022] Federated learning is a technique that enables data to remain stored locally on the client's device while the server acts as an orchestrator for the learning process, aggregating the learned information and synchronizing with the client (e.g., user, AI task, ...). However, the system may experience reduced efficiency and robustness due to issues like data heterogeneity, distribution shift, and communication may be unreliable, and even in the event of hardware failure. In addition, various federated learning architectures have been proposed, such as a single global model and peer-to-peer with individual models, some of which include personalized versions.

[0023] 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 stored locally 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 the process until convergence is achieved. FedAvg enables updating of the global model by aggregating the knowledge and insights of multiple clients. However, typically, the server has only one model stored and may suffer from decreased accuracy and lack of 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 result in computational overload for other clients.

[0024] In view of the challenges mentioned above and a variety of federated learning architectures and frameworks, the present disclosure aims to solve these problems by proposing a new federated learning framework. Although others have suggested model interpolation methods for federated learning systems using global models or other client models and others have assumed that diverse models can enhance robustness, the scheme of the present disclosure is different in several aspects. For example, the present disclosure presents the following framework: in this framework, a server acting as a federation stores learnable and diverse models, and forms a client model by combining these diverse 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 the following framework: the framework incorporates an interpolation method to adapt to distribution offsets and even to connection failures from the client. In addition, the present disclosure provides a backup solution for the case of unsuccessful communication in a federated training system. This provides a solution to the lack of robustness in hardware properties.

[0025] Whereas prior work presents the idea of ​​model interpolation for federated learning systems (global models at the server or client's model), the present disclosure focuses on multi-resolution model combination with new orthogonal constraints. In prior work, model interpolation is only used to obtain better performance for federated training, but not to provide a backup solution when communication failure occurs. The present disclosure provides a backup solution for such failed connection situations.

[0026] 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 from the server or repository for each learning round. Clients can select and pull from a list of models based on their resource constraints and train the models locally on their own data. After local training, the client can send information back for the server or repository to aggregate and update multiple models. Adding orthogonal regularization for neural network training can improve model performance as well as robustness and diversity. Therefore, the present disclosure provides a new client-side loss function to help optimize process-driven learning tasks, as well as a server-side loss function to ensure and achieve diversity properties. In this way, training of multiple models with diverse (semi-orthogonal) properties in a federation is performed.

[0027] Federated learning systems can take advantage of Figure 1-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 1The system 100 may include an input interface for accessing training data 102 for a neural network. For example, Figure 1 As shown in FIG. 1 , the input interface may be constituted by a data storage interface 104, which may access the training data 102 from a data storage 106. For example, the data storage interface 104 may be a memory interface or a persistent storage interface (e.g., a hard disk or SSD interface), but may also be a personal area network, a local area network, or a wide area network interface (such as a Bluetooth, Zigbee, or Wi-Fi interface, or an Ethernet or fiber optic interface). The data storage 106 may be an internal data storage of the system 100 (such as a hard disk drive or SSD), but may also be an external data storage (e.g., a network accessible data storage).

[0028] In some embodiments, the data store 106 may further include a data representation 108 of an untrained version of the neural network accessible from the data store 106 by the system 100. However, it should be appreciated that the training data 102 and the data representation 108 of the untrained neural network may also both be accessed from different data stores, such as via different subsystems of the data store interface 104. Each subsystem may be of the type described above with respect to the data store 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 thus may not be explicitly stored on the data store 106. The system 100 may further include: a processor subsystem 110, which may be configured to provide an iterated function as a replacement for a layer stack for the neural network to be trained during operation of the system 100. Here, the corresponding layers of the replaced layer stack may have mutually shared weights, and may receive as input the output of a previous layer, or, for the first layer of the layer stack, receive an initial activation and a portion of the input of the layer stack. The processor subsystem 110 may be further configured to iteratively train the neural network using the training data 102. Here, the iterations of training performed by the processor subsystem 110 may include a forward propagation portion and a back propagation portion. The processor subsystem 110 may be configured to perform the forward propagation portion by determining an equilibrium point of the iterative function at which the iterative function converges to a fixed point in addition to defining other operations of the executable forward propagation portion, and by providing the equilibrium point as a substitute for the output of the layer stack in the neural network, wherein determining the equilibrium point includes using a numerical root finding algorithm to find a root solution for the iterative function minus its input. 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, as also described in Figure 1, the output interface may consist of a data store interface 104, which in these embodiments is an input / output ('IO') interface, via which trained model data 112 may be stored in a data store 106. For example, a data representation 108 defining an "untrained" neural network may be at least partially replaced by a data representation 112 of a trained neural network during or after training, as parameters of the neural network (such as weights, hyperparameters, and other types of parameters of the neural network) may be adapted to reflect training on the training data 102. This is illustrated in FIG. Figure 1 106 by reference numerals 108, 112 referring to the same data records on the data store 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 store interface 104, but may generally be of the type described above for the data store interface 104.

[0029] The structure of system 100 is one example of a system that can be utilized 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 .

[0030] Figure 2 A federated learning system 200 configured to execute and train a machine learning model (e.g., a neural network or a deep neural network) described herein is depicted. System 200 can be implemented to perform the federated learning process described herein. System 200 can include at least one computing system 202. Computing system 202 can be part of or executed by a client device, such as a smartphone, an IoT device, a medical device, or a computer such as described herein with reference to the following. Figure 6-11The computing system 202 may include at least one processor 204 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, the processor 204 may be a system on chip (SoC) that integrates the functions of the CPU 206, the memory unit 208, the network interface, and the input / output interface into a single integrated device. The computing system 202 may implement an operating system for managing various aspects of operations. Figure 2 One processor 204, one CPU 206, and one memory 208 are shown, but of course more than one of each device may be utilized in the overall system.

[0031] The memory unit 208 may include volatile memory and non-volatile 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 retains data when the computing system 202 is deactivated or loses power. The 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.

[0032] 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, thereby enabling a device (e.g., a client device) executing the computing system 202 to communicate with the server 230.

[0033] 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.

[0034] One or more servers 230 may communicate with an 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, while remaining 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 passed to server 230, and therefore, the original source data at the server may not exist or may be completely unrelated to 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 portions of 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 may then access this information via a connection to network 224 and update its stored model on the server side.

[0035] 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 internal storage and external input and / or output devices (e.g., HMI devices). The I / O 220 interface may include an associated circuit or BUS network to transfer information to (one or more) processors and storage or to transfer information between (one or more) processors and storage. For example, the I / O interface 220 may include a digital I / O logic line that can be read or set by (one or more) processors, a handshake line for monitoring data transfer via the I / O line, a timing and counting facility, and other structures known to provide such functions. 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 an additional serial interface (e.g., a universal serial bus (USB) interface) for communicating with external devices. The I / O interface 220 may be referred to as an input interface (because it delivers data from an external input such as a sensor) or an output interface (because it delivers data to an external output such as a display) .

[0036] 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 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 be further configured to allow interaction with a remote HMI and a remote display device via a network interface device 222.

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

[0038] 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 clips, 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 that has increased security requirements, and therefore, the raw source data set 216 may not be passed from the client device to the server 230. Reference Figure 5-11 210 to illustrate and describe several different examples of input. In some examples, the machine learning algorithm 210 may be a neural network algorithm (e.g., a deep neural network) designed to perform a predetermined function. For example, a neural network algorithm may be configured in an automotive application to recognize street signs or pedestrians in an image. A neural network algorithm may be configured to automatically correct text or speech based on the context of words from an individual.

[0039] 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 collection of previously constructed data for training the machine learning algorithm 210. The training data set 212 may be used by the machine learning algorithm 210 to learn weighting factors associated with the neural network algorithm. The training data set 212 may include a collection of source data having corresponding achievements or results that the machine learning algorithm 210 attempts to replicate via the learning process.

[0040] The machine learning algorithm 210 may be operated in a learning mode using the training data set 212 as input. The machine learning algorithm 210 may be executed in multiple iterations using data from the training data set 212. With each iteration, the machine learning algorithm 210 may update internal weighting factors based on the achieved results. For example, the machine learning algorithm 210 may compare the output results (e.g., the reconstructed or supplemented image in the case where image data is 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 may determine when the performance is acceptable. After the machine learning algorithm 210 achieves a predetermined performance level (e.g., 100% agreement with the results associated with the training data set 212) or converges, the machine learning algorithm 210 may be executed using data that is not in the training data set 212. It should be understood that in the present disclosure, "convergence" may mean that a set (e.g., predetermined) number of iterations has occurred, or the residual is small enough (e.g., the change in the approximation probability within the iteration 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.

[0041] 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 a person in a video image; and annotate the appearance. 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 a variety of 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 machine generated 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, and the like.

[0042] Figure 3A An example diagram or layout of a federated learning system 300 according to an 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 device described above (e.g., a camera, a smart phone, etc.). Each of the server 302 and the client device 306 can both perform the machine learning process described herein via, for example, the corresponding computing system 202. The server 302 can be a centralized server that stores a number L of initialized (e.g., randomly) models (e.g., based on a neural network), the number L of initialized models being labeled as W1, W2, ..., W L .W 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.

[0043] Each of the client devices and the server can operate with a parameter set. In an embodiment, the client pool shown at 304 includes a number N of clients 306 in the federated learning system 300. The clients have classified 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 better hardware attributes at hand (e.g., devices with more computing resources, processing power, memory, etc.). Further, S i ={1,2,…,l i} can 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 pulled the model l. For each client i, its local storage data is labeled (D i ,y i ). For each client, its local model is

[0044] Assuming, for example, that the set of selected intermediate layers outputs latent features (defined by different tasks, architectures, and data-driven criteria), these features can be represented as In addition, there may be some other parameters as follows. For client-side local training, multiple epochs are trained between each communication (to the server) round, batch size, learning rate, optimizer type, etc. The client with the failure may be of index b using the connected neighbor group denoted by G. Thus, the neighbors of client b may be denoted by C b ={i,G(i,b)≠0}.

[0045] The neural network trained and executed at the server 302 or the client device in the client pool 304 may be Figure 4 The diagram shown in FIG. 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 (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, output layer, and hidden layer may be coupled to nodes of subsequent or previous layers. And, each of the nodes of the output layer may perform an activation function - for example, a function of whether the corresponding node should be activated to contribute to the output of the model. The number of nodes shown in the input, hidden, and output layers is exemplary only, and any suitable number may be used.

[0046] Reference Figure 3A ,At the beginning of each round of federated training, the server 302 sends the model information to each eligible (e.g., online, responsible, etc.) client device 306, e.g. This can be done over a networked communication, such as Figure 2 After each client device 306 receives the information from the server 302, each client device 306 starts storing data locally (D i ,y i ). The loss of each client i is given by L i Marking: where λ is a tunable hyperparameter corresponding to a regularization term that controls the relative weight between learning tasks, achieving or ensuring model diversity. represents the latent features from the selected intermediate layer, so the cascaded latent features can be expressed as:

[0047] The regularization term R can be defined as:

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

[0049] The client device can then send the updated weights to the server for aggregation and updating of the model on the server side without passing the personal original source data. 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 get for W1, W2, ..., W L Update:

[0050] Here, the first term can be changed to other kinds of reweighting, and the second term can be generated to other metrics. Note that W con Indicates the machine learning models W1, W2, ..., W maintained by multiple servers L The aggregation process in 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 With model l) and also trying to satisfy the diversity constraint The average value of weights collected by the clients.

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

[0052] In addition to the training process, if any client b has a communication failure to the server, then the disconnected client (or node) can pull the machine learning models from its neighboring clients or nodes and complete the interpolation of their models as follows: Among them A i For model W i In one embodiment, The neighbor of client b is marked as C b ={i,G(i,b)≠0}.

[0053] Thinking of 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 a client (e.g., client device 306). At 352, the server maintains a plurality of machine learning models, e.g., models W1, W2, W3, ..., W shown at 302. L These models can be global models that can be distributed across multiple client devices.

[0054] 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 of the clients, the model is delivered to the respective client, where it is trained using the locally stored data on the 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.

[0055] During training, at 356, each client device can determine the loss of the model it trained at that particular client device and update the weights of the model. 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.

[0056] If the client becomes disconnected from the communication with the server or otherwise cannot receive the model from the server, an optional backup step 357 is provided. Here, the disconnected client (e.g., client b) or node can pull the model from its neighbor. For example, the client device can be connected to a nearby client device and receive the model from those nearby devices. This can occur on a wireless communication (such as, any of the wireless communication examples described herein). In one embodiment, the disconnected client is first matched with another client with a similar brand, model, network setting, etc., which can ensure that the appropriate model can be transferred from the connected device to the disconnected device. In an embodiment, the disconnected device client b can complete the interpolation of the model received from (one or more) connected clients according to equation (4) above. Adjacent clients can be selected to communicate the model with the disconnected client based on the adjacent client being within the range of a certain wireless communication, such as direct client-to-client communication (e.g., Wi-Fi, Bluetooth, short-range communication, dedicated short-range communication (DSRC)), etc. Once the disconnected device client b receives the model(s) from other neighbor 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 locally stored data in the disconnected device client b.

[0057] The updated weights as trained at the client using the locally stored data can then be passed to the server. Again, it should be noted that the locally stored data is not passed. At 358, the server trains its multiple machine learning models using 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. As an example, this can be done in aggregation using equation (3). Losses can also be determined on the server side during training at the server.

[0058] All or part of steps 352-358 may be repeated in a loop until convergence, such as continuously in continuous learning.

[0059] The machine learning model described herein can be used in many different applications. As described above, the locally stored original source data can be image data, sound data, etc., and thus, as an example, in Figure 6-11 Various applications in which this data is retrieved or used are shown in FIG. Figure 5 The structure for training and using machine learning models for these applications (and others) is illustrated in FIG. 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.

[0060] 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 according to the sensor signals; and transmit the actuator control commands 510 to the actuators 504 of the computer controlled machine 500.

[0061] 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, the sensor signal 508 is directly received as the input signal x without the receiving unit 512. 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 may include data corresponding to an image recorded by the sensor 506.

[0062] 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 516. The classifier 514 is configured to determine the output signal y based on the input signal x. Each output signal y includes information that assigns 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.

[0063] When the actuator control command 510 is received 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 transform the actuator control command 510 into a second actuator control command that is utilized to control the actuator 504. In one or more embodiments, the actuator control command 510 may be utilized to control a display instead of or in addition to an actuator.

[0064] 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 include the actuator 504 instead of or in addition to the computer-controlled machine 500 including the actuator 504.

[0065] 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) may be implemented by the control system 502, which includes a non-volatile storage 516, a processor 520, and a memory 522.

[0066] The non-volatile storage 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, cloud storage, or any other device capable of persistently storing information. The processor 520 may be a processor such as described above with reference to Figure 1-2 Any 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.

[0067] The processor 520 may be configured to read into the memory 522 and execute computer executable instructions residing in the non-volatile storage 516 and embodying one or more machine learning algorithms and / or methods of one or more embodiments. The non-volatile storage 516 may include one or more operating systems and applications. The non-volatile storage 516 may store content compiled and / or interpreted according to a computer program created using a variety of programming languages ​​and / or technologies, including but not limited to, and individually or in combination: Java, C, C++, C#, Objective C, Fortran, Pascal, JavaScript, Python, Perl, and PL / SQL.

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

[0069] The program code embodying the algorithm and / or method described herein can be distributed as a program product individually or collectively in a variety of different forms. The program code can be distributed using a computer-readable storage medium having a computer-readable program instruction for enabling a processor to implement the aspects of one or more embodiments thereon. Intrinsically non-transient computer-readable storage media 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, cassette, tape, disk storage or other magnetic storage device, or any other medium that can be used to store desired information and can be read by a computer. The computer-readable program instructions may be downloaded from the computer-readable storage medium to a computer, another type of programmable data processing apparatus, or another device, or downloaded to an external computer or external storage device via a network.

[0070] The computer-readable program instructions stored in the computer-readable medium can be used to direct a computer, other types of programmable data processing devices, or other devices to function 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 flowcharts or drawings. In certain alternative embodiments, consistent with one or more embodiments, the functions, actions, and / or operations specified in the flowcharts and drawings can be reordered, processed serially, and / or processed simultaneously. In addition, any of the flowcharts and / or drawings may include more or fewer nodes or blocks than those illustrated consistent with one or more embodiments.

[0071] The 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 component or device, or a combination of hardware, software and firmware components.

[0072] Figure 6-11 Embodiments of environments in which the federated learning system described herein may be implemented are illustrated. Each of these embodiments shows an embodiment of a client device. The data originating from the sensor 506 may be the original source data used to train the machine learning model on the device (client) in these embodiments, but is not passed to the server for protecting the data. Figure 6A schematic diagram of a control system 502 configured to control a vehicle 600 is depicted, 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, microphones, 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 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 configured to determine the current or future state of the weather proximate to the vehicle 600 or other location.

[0073] The classifier 514 of the control system 502 of the vehicle 600 can be configured to detect objects near the vehicle 600 according to 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 a 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 modified weights may then be sent back to the server's model for updating.

[0074] In an embodiment where the vehicle 600 is at least partially autonomous, the actuator 504 may be embodied in a brake, propulsion system, engine, drive train, or steering device of the vehicle 600. An actuator control command 510 may be determined so that the actuator 504 is controlled to cause the vehicle 600 to avoid a collision with a detected object. The detected objects may also be classified according to what the classifier 514 considers them to be most likely to be (such as a pedestrian or a tree). The actuator control command 510 may be determined according to the classification. In a scenario where an adversarial attack may occur, the system described above may be further trained to better detect objects or identify changes in lighting conditions or angles for sensors or cameras on the vehicle 600.

[0075] In other embodiments in which 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 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 a collision with the identified object.

[0076] 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 may use an optical sensor as a sensor 506 to determine the state of plants in the environment proximate to the vehicle 600. The actuator 504 may be a nozzle configured to spray a chemical. According to the identified species and / or the identified state of the plant, the actuator control command 510 may be determined to cause the actuator 504 to spray the plant with an appropriate amount of an appropriate chemical.

[0077] 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 laundry inside the washing machine. The actuator control command 510 may be determined based on the detected state of the laundry.

[0078] Figure 7 A schematic diagram of a control system 502 configured to control a system 700 (e.g., a manufacturing machine) of a manufacturing system 702, such as a punch cutter, a cutting machine, or a gun drill, is depicted. The control system 502 may be configured to control an actuator 504 configured to control the system 700 (e.g., a manufacturing machine).

[0079] 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 one or more of the captured attributes. The actuator 504 may be configured to control the system 700 (e.g., a manufacturing machine) according to 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 a function of the system 700 (e.g., a manufacturing machine) on a subsequent manufactured product 706 of the system 700 (e.g., a manufacturing machine) according to the determined state of the manufactured product 704.

[0080] 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 at least a partially autonomous mode is depicted. The control system 502 may be configured to control an actuator 504 configured to control the power tool 800.

[0081] 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 one or more of the captured properties. The state can be that the fastener 804 is flush with the working surface 802. The state can alternatively 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 according to the 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 according to the hardness of the working surface 802.

[0082] Fig. 9 A schematic diagram of a control system 502 configured to control an automated personal assistant 900 is depicted. 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.

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

[0084] The control system 502 of the automated personal assistant 900 may be configured to determine an actuator control command 510 configured to control the system 502. The control system 502 may 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 may be configured to execute a gesture recognition algorithm to recognize a gesture 904 made by the user 902, determine the actuator control command 510, and transmit the actuator control command 510 to the actuator 504. The classifier 514 may be configured to retrieve information from non-volatile storage in response to the gesture 904 and output the retrieved information in a form suitable for receipt by the user 902.

[0085] Fig.10 A 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 that are relevant in deciding whether to grant access. The sensor 506 can be an optical sensor configured to generate and transmit image and / or video data. Such data can be used by the control system 502 to detect a person's face.

[0086] 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 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.

[0087] 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 under surveillance, and the control system 502 is configured to control the display 1004. The classifier 514 is configured to determine the classification of the scene, for example, whether the scene detected by the sensor 506 is suspicious. The control system 502 is configured to transmit the 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 monitoring system may predict objects that appear at certain times in the future.

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

[0089] 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 limiting, and it should be understood that various changes can be made without departing from the spirit and scope of the present disclosure. As described above, the features of various embodiments can be combined to form further embodiments of the present invention that may not be explicitly described or illustrated. Although various embodiments may have been described as providing advantages or preferences with respect to one or more desired characteristics compared to other embodiments or prior art implementations, it should be recognized by those skilled in the art that one or more features or characteristics can be compromised to achieve the desired overall system attributes, which depends on the specific application and implementation. These attributes may include, but are not limited to, cost, strength, durability, life cycle cost, marketability, appearance, packaging, size, serviceability, weight, manufacturability, ease of assembly, etc. Thus, insofar as any embodiment is described as being 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 present disclosure, but may be desirable for specific applications.

Claims

1. A method for training a neural network using federated learning, the method comprising: sending at least a portion of the plurality of server-maintained machine learning models from the server to the plurality of clients, thereby generating a plurality of local machine learning models; At each client, training the 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; communicating the respective updated weights from each client to the server without communicating the client's locally stored data; At the server, training the machine learning models maintained by the plurality of servers using the updated weights sent from each of the clients; determining that a first client of the plurality of clients is disconnected or otherwise unable to receive from the server the at least a portion of the machine learning models maintained by the plurality of servers; connecting the first client to a neighboring client capable of communicating with the server; as well as Sending portions of the machine learning models maintained by the plurality of servers from the neighboring clients to the first client.

2. A method as claimed in claim 1, wherein the connecting includes connecting the first client to multiple adjacent clients capable of communicating with the server, and wherein the sending of the portion includes sending the portion of the machine learning model maintained by the multiple servers from the multiple adjacent clients to the first client.

3. The method of claim 2, further comprising: At the first client, interpolation of the portion of the machine learning models maintained by the plurality of servers received from the plurality of neighboring clients is performed.

4. The method of claim 3, wherein the interpolation is: Where W + is for the plurality of adjacent clients C b The interpolation model of the received model W, and Among them A i For model W i The linear combination weights of .

5. The method of claim 4, wherein the weighted combination A i It is expressed by the following formula: Where L b is the loss associated with the first client.

6. The method of claim 1, further comprising: The neighboring client is selected to communicate with the first client based on the neighboring client having received at least a portion of a plurality of server-maintained machine learning models from the server. The method of claim 1 , wherein the neighboring client is a plurality of neighboring clients.

8. A system for training a neural network using federated learning, the system comprising: a memory for storing instructions; as well as A plurality of processors that, when executing instructions stored in the memory, collectively perform: sending at least a portion of the plurality of server-maintained machine learning models from the server to the plurality of clients, thereby generating a plurality of local machine learning models; At each client, training the 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; communicating the respective updated weights from each client to the server without communicating the client's locally stored data; At the server, training the machine learning models maintained by the plurality of servers using the updated weights sent from each of the clients; determining that a first client of the plurality of clients is disconnected or otherwise unable to receive from the server the at least a portion of the machine learning models maintained by the plurality of servers; connecting the first client to a neighboring client capable of communicating with the server; as well as Sending portions of the machine learning models maintained by the plurality of servers from the neighboring clients to the first client.

9. A system as described in claim 8, wherein the connecting includes connecting the first client to multiple adjacent clients capable of communicating with the server, and wherein the sending of the portion includes sending the portion of the machine learning model maintained by the multiple servers from the multiple adjacent clients to the first client.

10. The system of claim 9, wherein the instructions further cause the processor to collectively perform: Interpolate the portions of the machine learning models maintained by the plurality of servers received from the plurality of adjacent clients.

11. The system of claim 10, wherein the interpolation is: Where W + is for the plurality of adjacent clients C b The interpolation model of the received model W, and Among them A i For model W i The linear combination weights of .

12. The system of claim 11, wherein the loss difference ratio A i It is expressed by the following formula: Where L b is the loss associated with the first client.

13. The system of claim 8, wherein the instructions further cause the processor to collectively perform: The neighboring client is selected to communicate with the first client based on the neighboring client having received at least a portion of a plurality of server-maintained machine learning models from the server. The system of claim 8 , wherein the neighboring client is a plurality of neighboring clients.

15. A method for training a neural network using federated learning, the method comprising: sending at least a portion of the plurality of server-maintained machine learning models from the server to the plurality of clients, thereby generating a plurality of local machine learning models; determining that a first client of the plurality of clients is disconnected or otherwise unable to receive the at least a portion of the machine learning models maintained by the plurality of servers; At each of the plurality of clients except the first client, training the plurality of local machine learning models using the locally stored data stored locally at the corresponding 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; communicating to the server a respective updated weight from each of the plurality of clients except the first client without communicating locally stored data of the client; connecting the first client to a plurality of adjacent clients among the plurality of clients capable of communicating with the server; sending portions of the machine learning models maintained by the plurality of servers from the neighboring clients to the first client; training, at the first client, the plurality of local machine learning models using locally stored data stored locally at the first client, wherein the training at the first client comprises determining a loss for each of the plurality of local machine learning models and updating a weight associated with each of the local machine learning models; Once the first client reconnects to the server, sending the updated weights from the first client to the server; as well as At the server, the machine learning models maintained by the plurality of servers are trained using the updated weights from the first client.

16. The method of claim 15, further comprising: At the first client, interpolation of the portion of the machine learning models maintained by the plurality of servers received from the plurality of neighboring clients is performed.

17. The method of claim 16, wherein the interpolation is: Where W + is for the plurality of adjacent clients C b The interpolation model of the received model W, and Among them A i For model W i The linear combination weights of .

18. The method of claim 17, wherein the loss difference ratio A i It is expressed by the following formula: Where L b is the loss associated with the first client.

19. The method of claim 15, further comprising: The neighboring client is selected to communicate with the first client based on the neighboring client being within a short range of wireless communication with the first client.

20. The method of claim 15, further comprising: The plurality of server-maintained machine learning models are selected from a pool of machine learning models, wherein the plurality of server-maintained machine learning models are selected from the pool based on resource constraints associated with the plurality of clients.

Images