KR20220170583A - Method and apparatus for federated learning - Google Patents

Abstract

According to the present invention, provided are a method and device for federated learning that improve communication efficiency of federated learning by using a loss function and an L1-norm regularization term. Therefore, the communication efficiency of the federated learning is enhanced. The present invention comprises: a step of obtaining a global parameter value; a step of determining a local parameter value; a step of determining a local update value; and a step of transmitting the local update value to the server.

Description

Federated learning method and apparatus {METHOD AND APPARATUS FOR FEDERATED LEARNING}

The present invention relates to a federated learning method and an apparatus for executing the same, and relates to a federated learning method and apparatus for improving the communication efficiency of federated learning using a loss function and an L1-norm regularization term of federated learning.

The contents described below are only described for the purpose of providing background information related to an embodiment of the present invention, and the contents described do not naturally constitute prior art.

Federated learning is a machine learning methodology that ensures privacy across multiple users and devices. Instead of sending their data to the global device (server), local devices (clients) send trained models based on their data. In the global device, a more accurate global model is created by synthesizing the models sent by the local devices. Then, the global model is transmitted to each of the local devices, and the local devices generate a more accurate local model using the received global model and their own local data. By repeating this process, learning a more accurate global model is a method of federated learning.

In federated learning, since local devices do not send their data to global devices, data privacy can be guaranteed. In particular, in the case of data for which privacy needs to be guaranteed, such as patient information, if the federated learning method is used, privacy can be guaranteed by sending a learned model instead of sensitive data.

The performance of federated learning shows less-than-ideal performance due to various factors such as high communication cost, system heterogeneity, heterogeneity in probability distribution of local data, and data privacy issues. Among them, communication cost is an important factor that causes the bottleneck of federated learning. To improve the performance of federated learning, a technology that can increase the communication efficiency of numerous local devices and servers participating in federated learning is required.

On the other hand, the above-mentioned prior art is technical information that the inventor possessed for derivation of the present invention or acquired during the derivation process of the present invention, and cannot necessarily be said to be known art disclosed to the general public prior to the filing of the present invention. .

An object of the present invention is to provide a federated learning method and apparatus for improving the communication efficiency of federated learning by adding an L1-norm regularization term to an objective function of federated learning.

The object of the present invention is not limited to the above-mentioned tasks, and other objects and advantages of the present invention not mentioned above can be understood by the following description and will be more clearly understood by the embodiments of the present invention. It will also be seen that the objects and advantages of the present invention may be realized by means of the instrumentalities and combinations indicated in the claims.

A federated learning method according to an embodiment of the present invention includes obtaining, by a terminal, global parameter values for parameters of a first set of a global model from a server; training to determine local parameter values for parameters of a second set corresponding to at least some of the parameters of the first set; by the terminal, based on the global parameter values and the local parameter values, determining local update values for the parameters of the set; and transmitting, by the terminal, local update values for the parameters of the second set to the server.

Here, the step of determining the local parameter value is based on, by the terminal, a local objective function including a regularizer associated with the local update value and an operation term defined by a weight for the regularizer term. The local parameter value may be determined.

A federated learning method according to an embodiment of the present invention includes transmitting, by a server, a global parameter value for a first set of parameters of a global model to a plurality of terminals, by the server, at least one of the plurality of terminals. receiving local update values for a second set of parameters corresponding to at least some of the first set of parameters from a portion and updating, by the server, the global model based on the local update values; do.

Here, the local update value is of the second set determined based on a local objective function including a regularization term associated with the global parameter value and the local update value and an operating term defined by a weight for the regularization term. It may be a value determined by the terminal based on a local parameter value for the parameter.

A terminal according to an embodiment of the present invention includes a memory for storing local data and a local model and a processor, wherein the processor obtains global parameter values for a first set of parameters of a global model from a server, and the train the local model based on local data to determine local parameter values for parameters in a second set corresponding to at least some of the parameters in the first set; determine a local update value for the second set of parameters, and transmit the local update values for the second set of parameters to the server.

Wherein the processor is configured to use a local objective function including an operand defined by a regularizer associated with the local update value and a weight for the regularizer term to determine the local parameter value. can

A server according to an embodiment of the present invention includes a memory and a processor for storing a global model, wherein the processor transmits global parameter values for a first set of parameters of the global model to a plurality of terminals, and the Receive local update values for parameters of a second set corresponding to at least some of the parameters of the first set from at least some of the plurality of terminals, and update the global model based on the local update values. .

Here, the local update value is of the second set determined based on a local objective function including a regularization term associated with the global parameter value and the local update value and an operating term defined by a weight for the regularization term. It may be a value determined by the terminal based on a local parameter value for the parameter.

Other aspects, features, and advantages other than those described above will become apparent from the following drawings, claims, and detailed description of the invention.

According to the embodiment, the amount of communication data between the terminal and the server per each round is effectively reduced.

According to the embodiment, communication efficiency of associative learning between a terminal and a server can be maximized.

The effects of the present invention are not limited to those mentioned above, and other effects not mentioned will be clearly understood by those skilled in the art from the description below.

1 schematically illustrates an operating environment of a federated learning system according to an embodiment.
2 is a block diagram of a terminal executing federated learning according to an embodiment.
3 is a block diagram of a server executing federated learning according to an embodiment.
4 is a flowchart of a federated learning method according to an embodiment.
5 is a flowchart of a federated learning method according to an embodiment.
6 is a flowchart of a federated learning method according to an embodiment.
7 shows exemplary pseudocode of a federated learning method according to an embodiment.

Hereinafter, the present invention will be described in more detail with reference to the drawings. The invention may be embodied in many different forms and is not limited to the embodiments set forth herein. In the following embodiments, parts not directly related to the description are omitted in order to clearly describe the present invention, but this does not mean that the omitted configuration is unnecessary in implementing a device or system to which the spirit of the present invention is applied. . In addition, the same reference numbers are used for the same or similar elements throughout the specification.

In the following description, terms such as first and second may be used to describe various components, but the components should not be limited by the terms, and the terms refer to one component from another. Used only for distinguishing purposes. Also, in the following description, singular expressions include plural expressions unless the context clearly indicates otherwise.

In the following description, terms such as "comprise" or "having" are intended to indicate that there is a feature, number, step, operation, component, part, or combination thereof described in the specification, but one or more other It should be understood that it does not preclude the possibility of addition or existence of features, numbers, steps, operations, components, parts, or combinations thereof.

Federated learning is a machine learning methodology that guarantees privacy while increasing communication efficiency between local and global devices of various users.

In federated learning, instead of sending their data to the global machine, local devices send a trained model based on their own data. In the global device, a more accurate global model is created by synthesizing the models sent by the local devices.

Then, the global model is transmitted to each of the local devices, and the local devices generate a more accurate local model using the received global model and their own local data. By repeating this process, learning a more accurate global model is a method of federated learning. In federated learning, since local devices do not send their data to global devices, data privacy can be guaranteed. In addition, since a learned local model is transmitted instead of massive data, communication efficiency can be increased.

In the present invention, in order to further improve communication efficiency by reducing the amount of local model data transmitted by local devices, a method for transmitting sparse gradient differences using L1-norm regularization is proposed.

Through the proposed method, information on a local model can be sparsified and transmitted to a global device. Information about the sparse local model can be compressed more efficiently than general data, and through this method, the communication efficiency of federated learning can be maximized.

The present invention will be described in detail with reference to the drawings below.

1 schematically illustrates an operating environment of a federated learning system according to an embodiment.

The federated learning system 1000 according to the embodiment includes a server 200 and a plurality of terminals 100 communicating with the server 200 . For example, the terminal 100 is a device used by a user and includes various types of remote devices. For example, the server 200 communicates with various types of terminals 100 to perform federated learning.

In the federated learning system 1000, the server 200 and the plurality of terminals 100 perform training of an artificial intelligence (AI)-based learning model in association with each other.

Looking at the federated learning process, instead of sending local data stored in the terminal 100 to the central server 200, the terminal 100 uses the local data as input data to generate a local model ( local model) is trained. This protects the privacy of local data in the federated learning process and reduces the communication flow on the network.

The server 200 receives a local update for the local model of the terminal 100 from the terminal 100, updates a global model stored in the server 200, and sends the updated global model to the terminal 100. send.

The terminal 100 updates its own local model based on the received update to the global model. In the federated learning system 1000, the plurality of terminals 100 and the server 200 update the local model and the global model while repeating such a learning process multiple times.

For initial setup, when the terminal 100 initiates participation in federated learning, it communicates with the server 200 to receive information on the global model. For example, when the terminal 100 downloads and installs an application implementing federated learning, information on the global model at that time is obtained.

Looking at one round of federated learning, at least some of the terminals 100 (ie, the first set of terminals) perform local learning on local data and transmit (L_UPDATE) a local update according to the local data to the server 200.

The server 200 integrates the received local update (L_UPDATE) and transmits (G_MODEL) the updated global model to at least some of the terminals 100 (ie, the second set of terminals).

The federated learning system 1000 may repeatedly perform such learning rounds until an end condition is satisfied.

Here, the first set and the second set of terminals 100 are subsets of the entire set of terminals 100 included in the federated learning system 1000, and there may or may not be terminals 100 in common with each other. may be

For example, the server 200 may determine the first set and/or the second set in a random manner from among the entire set of terminals 100 . In one example, the server 200 may re-determine the first set and/or the second set for each learning round.

Here, the server 200 may determine a first set and/or a second set among terminals 100 capable of joint learning with the current server 200 among the entire set of terminals 100 . For example, the server 200 determines the first set and/or the second set among terminals 100 excluding terminals 100 (shown by dotted arrows in FIG. 1 ) that do not currently have connectivity with the server 200. can Meanwhile, the terminal 100 may proceed with learning of a locale model using local data even when there is no connectivity with the server 200 .

The terminal 100 includes a communication terminal capable of performing functions of a computing device (not shown). The terminal 100 includes a desktop computer, a smart phone, a laptop computer, a tablet PC, a smart TV, a mobile phone, a personal digital assistant (PDA), a laptop computer, a media player, a micro server, a global positioning system (GPS) device, and an electronic device operated by a user. Book terminals, digital broadcasting terminals, navigation devices, kiosks, MP3 players, digital cameras, home appliances, and other mobile or non-mobile computing devices, but are not limited thereto. In addition, the terminal 100 may be a wearable device having a communication function and data processing function, such as a watch, glasses, a hair band, and a ring. The terminal 100 is not limited to the above.

The server 200 may include an application server capable of communicating with the terminal 100 . The server 200 may be a database server that provides big data necessary for applying various artificial intelligence algorithms based on the federated learned global model.

2 is a block diagram of a terminal executing federated learning according to an embodiment.

The terminal 100 includes a processor 110 and a memory 120 . The configuration shown in FIG. 2 is exemplary and not limited thereto, and the terminal 100 may further include additional configurations.

The terminal 100 includes a memory 120 that stores a local model 120M and local data 120D. The terminal 100 performs learning of the local model 120M using the local data 120D.

The local data 120D is user data collected by the terminal 100 and means input data for learning the local model 120M. Additionally, the local data 120D may include intermediate data and output data calculated during the learning process of the local model 120M.

The local model 120M is a learning model stored in the terminal 100 and corresponds to an instance of a global model stored in the server 200 . Here, the learning model may include various machine learning models based on artificial neural networks for learning/inference calculations.

The memory 120 may include built-in memory and/or external memory, and may include volatile memory such as DRAM, SRAM, or SDRAM, one time programmable ROM (OTPROM), PROM, EPROM, EEPROM, mask ROM, flash ROM, and NAND. Non-volatile memory such as flash memory or NOR flash memory, flash drives such as SSD, compact flash (CF) card, SD card, Micro-SD card, Mini-SD card, Xd card, or memory stick; Alternatively, it may include a storage device such as a HDD. The memory 120 may include magnetic storage media or flash storage media, but is not limited thereto.

The memory 120 may provide instructions executable by the processor 110 . When executed on processor 110, these instructions cause processor 110 to execute a federated learning process according to an embodiment.

The terminal 100 includes a processor 110 .

The processor 110, as a kind of central processing unit, may execute one or more commands stored in the memory 120 to execute the associated learning process of the terminal 100.

The processor 110 may include any type of device capable of processing data. The processor 110 may mean, for example, a data processing device embedded in hardware having a physically structured circuit to perform a function expressed as a code or command included in a program. As an example of such a data processing device built into hardware, a microprocessor, a central processing unit (CPU), a processor core, a multiprocessor, an application-specific integrated (ASIC) circuit), a field programmable gate array (FPGA), and a graphics processing unit (GPU), but is not limited thereto. Processor 110 may include one or more processors.

The processor 110 acquires global parameter values for the first set of parameters of the global model from the server 200, trains the local model 120M based on the local data 120D, and obtains the first set of parameters determine a local parameter value for a second set of parameters corresponding to at least a part of, determine a local update value for the second set of parameters based on the global parameter value and the local parameter value; A local objective function including an operating term defined by a regularizer associated with the local update value and a weight for the regularizer term, in order to transmit a local update value for , to the server 200, and to determine a local parameter value. It can be configured to use.

Processor 110 may be configured to determine a weight based on the amount of local data 120D to determine a local parameter value.

The processor 110 may be configured to determine a difference between a global parameter value and a local parameter value as a local update value in order to determine a local update value.

In one example, the local update value may be represented as a sparse matrix or sparse vector.

In one example, the regularization term may be defined as an L1-norm based on global parameter values and local parameter values for the second set of parameters.

The joint learning method by the terminal 100 will be described later in detail with reference to FIG. 4 .

3 is a block diagram of a server executing federated learning according to an embodiment.

The server 200 includes a processor 210 and a memory 220 . The configuration shown in FIG. 3 is exemplary and not limited thereto, and the server 200 may further include additional configurations.

The server 200 includes a memory 220 storing the global model 220M.

The server 200 performs learning of the global model 220M by integrating local updates received from the terminal 100 .

The global model 220M is a learning model stored in the server 200 . Here, the learning model may include various machine learning models based on artificial neural networks for learning/inference calculations. The global model 220M is updated based on the local model 120M learned in each terminal 100 during the joint learning process between the terminal 100 and the server 200 .

The memory 220 may include built-in memory and/or external memory, and may include volatile memory such as DRAM, SRAM, or SDRAM, one time programmable ROM (OTPROM), PROM, EPROM, EEPROM, mask ROM, flash ROM, and NAND. Non-volatile memory such as flash memory or NOR flash memory, flash drives such as SSD, compact flash (CF) card, SD card, Micro-SD card, Mini-SD card, Xd card, or memory stick; Alternatively, it may include a storage device such as a HDD. The memory 220 may include magnetic storage media or flash storage media, but is not limited thereto.

The memory 220 may provide instructions executable by the processor 210 . When executed in processor 210, these instructions cause processor 210 to execute a federated learning process according to an embodiment.

Server 200 includes a processor 210 .

The processor 210, as a kind of central processing unit, may execute one or more instructions stored in the memory 220 to execute the associated learning process of the server 200.

The processor 210 may include any type of device capable of processing data. The processor 110 may mean, for example, a data processing device embedded in hardware having a physically structured circuit to perform a function expressed as a code or command included in a program. As an example of such a data processing device built into hardware, a microprocessor, a central processing unit (CPU), a processor core, a multiprocessor, an application-specific integrated (ASIC) circuit), a field programmable gate array (FPGA), and a graphics processing unit (GPU), but is not limited thereto. Processor 210 may include one or more processors.

The processor 210 transmits global parameter values for the first set of parameters of the global model 220M to the plurality of terminals 100, and transmits at least one of the first set of parameters from at least some of the plurality of terminals 100. and receive local update values for the second set of parameters corresponding to the subset, and update the global model based on the local update values. wherein the local update values are local parameter values for a second set of parameters determined based on a local objective function comprising a global parameter value and a regularization term associated with the local update value and an operational term defined by a weight for the regularization term. It corresponds to the value determined by the terminal 100 based on .

The processor 210 may be configured to determine a weight based on the amount of local data 120D of the terminal 100 .

In one example, the local update value may be determined by each terminal according to a difference value between a global parameter value and a local parameter value.

In one example, the normalization term may be defined as an L1-norm based on a global parameter value and a local parameter value.

The federated learning method by the server 200 will be described later in detail with reference to FIG. 5 .

4 is a flowchart of a federated learning method according to an embodiment.

4 shows a process performed by the terminal 100 shown in FIG. 2 in the federated learning method according to the embodiment.

The federated learning method according to the embodiment includes obtaining, by the terminal 100, global parameter values for parameters of a first set of the global model 220M from the server 200 (S1), by the terminal 100 , Training the local model 120M based on the local data 120D to determine local parameter values for parameters of a second set corresponding to at least some of the parameters of the first set (S2), terminal 100 ), determining a local update value for the second set of parameters based on the global parameter value and the local parameter value (S3), and by the terminal 100, the local update value for the second set of parameters and transmitting to the server 200. Here, the step of determining the local parameter value (S2) is, by the terminal 100, a local objective function including a regularizer associated with the local update value and an operation term defined by a weight for the regularizer term. Based on the local parameter value can be determined.

In step S1 , the processor 110 may obtain global parameter values for the first set of parameters of the global model 220M from the server 200 .

Parameters of the learning model include model parameters and hyperparameters.

The model parameter refers to a parameter determined through learning of a corresponding learning model. For example, model parameters include weights of synaptic connections of artificial neural networks and biases of neurons. Hyperparameters are parameters that must be set before learning in machine learning algorithms. For example, hyperparameters include learning rate, number of iterations, mini-batch size, and initialization function.

The global parameters are parameters defining the global model 220M, and include model parameters and hyperparameters of the global model 220M.

In step S1 , at least some of the terminals 100 may receive at least some parameters of the global parameters of the global model 220M from the server 200 . That is, in step S1 , at least some of the terminals 100 may receive at least some of the global parameters of the global model 220M from the server 200 .

The processor 110 may obtain global parameter values for the first set of parameters of the global model 220M from the server 200 in step S1. Here, the first set of parameters is a subset of the model parameter set of the global model 220M. That is, the first set of parameters is a set including all or at least some of the global parameters of the global model 220M.

In step S2, the processor 110 trains the local model 120M based on the local data 120D, and obtains local parameters for a second set of parameters corresponding to at least some of the first set of parameters. value can be determined.

In step S2, the processor 110 may train the local model 120M of the terminal 100 by using local data 120D including user data collected by the terminal 100 as input data.

In the training result step S1 , local parameter values for the second set of parameters corresponding to at least some of the first set of parameters obtained from the server 200 may be determined. For example, the processor 110 may determine a model parameter value of the local model 120M obtained as a result of iteratively learning the local model 120M a predetermined number of times as the local parameter value.

In step S2, the processor 110 trains the local model 120M to minimize the local objective function.

는 다음과 같은 수학식 1로 나타낼 수 있다.Update (learning) in the t+1th round (round t+1) of the kth terminal 100

Can be represented by Equation 1 as follows.

는 k번째 단말(100)의 로컬 목적 함수(local objective function)이고,

는 정규화항을 사용하지 않았을 때의 k번째 단말(100)의 로컬 손실 함수(local loss function)이다. 또한,

는 단계(S1)에서 획득한 글로벌 모델의 제 1 세트의 파라미터의 글로벌 파라미터 값에 대응한다.

는 k번째 단말(100)의 정규화항에 대한 가중치를 의미한다.here

Is the local objective function of the k-th terminal 100,

Is a local loss function of the k-th terminal 100 when the normalization term is not used. Also,

corresponds to the global parameter value of the first set of parameters of the global model obtained in step S1.

Means a weight for the normalization term of the k-th terminal 100.

는 로컬 손실 함수

및 연산항

의 합으로 정의된다.local objective function

is the local loss function

and operands

is defined as the sum of

는 평균 제곱 오차(MSE: Mean Squared Error) 또는 교차 엔트로피 (CE, Cross Entropy)를 사용할 수 있으며, 이에 한정되지는 않는다.local loss function

Mean Squared Error (MSE) or Cross Entropy (CE) may be used, but is not limited thereto.

는 이를 최소화하기 위한 학습 최적화 알고리즘을 이용하여 학습될 수 있다. 학습 최적화 알고리즘은 예를 들어 경사 하강법(GD: Gradient Descent), 확률적 경사 하강법(SGD: Stochastic Gradient Descent), 모멘텀(Momentum), NAG(Nesterov Accelerate Gradient), Adagrad, AdaDelta, RMSProp, Adam, Nadam 등이 있다.local loss function

may be learned using a learning optimization algorithm for minimizing this. Learning optimization algorithms include, for example, Gradient Descent (GD), Stochastic Gradient Descent (SGD), Momentum, Nesterov Accelerate Gradient (NAG), Adagrad, AdaDelta, RMSProp, Adam, Nadam et al.

은 로컬 업데이트 값과 연계된 정규화항(regularizer)

및 정규화항에 대한 가중치

의 곱셈으로 정의된다.operand

is the regularizer associated with the local update value.

and weights for regularization terms

is defined as the multiplication of

및 정규화항에 대한 가중치

에 의해 정의되는 연산항을 포함하는 로컬 목적 함수

에 기반하여 로컬 파라미터 값을 결정할 수 있다.In one example, processor 110 may perform a normalization term associated with a local update value.

and weights for regularization terms

A local objective function containing an operand defined by

Based on the local parameter value can be determined.

를 최소화하는 파라미터 값

을 단말(100)의 로컬 파라미터 값

으로 결정할 수 있다.That is, the processor 110 is a local objective function

Parameter value that minimizes

the local parameter value of the terminal 100

can be determined by

은 글로벌 파라미터 값

및 제 2 세트의 파라미터에 대한 로컬 파라미터 값

에 기반한 L1-norm으로 정의된다.Here, the regularization term

is the global parameter value

and local parameter values for the second set of parameters.

It is defined as an L1-norm based on

을 정규화항으로 사용하면, 단계(S3)에서 후술할 가

가 희소(sparse)해진다. 즉, 매 라운드마다

대신에

을 보낸다면, 전송하는 데이터의 양이 더 적어진다. 매우 작은 값들을 보내는 것은 보내는 데이터의 양은 많지만 실제 모델에 미치는 영향은 적다. 이런 면에서 L1-norm을 사용하는 것이 유리하다.L1-norm

When is used as a normalization term, the

becomes sparse. i.e. every round

Instead of

, the amount of data to be transmitted becomes smaller. Sending very small values will send a lot of data but have little effect on the actual model. In this respect, it is advantageous to use the L1-norm.

가 동일하게 사용된다. 일 예에서 정규화항에 대한 가중치

를 각 로컬 모델에 따라 다르게 사용할 수 있다. 이 경우, 단계(S2)는 정규화항에 대한 가중치

를 결정하는 단계를 포함할 수 있다. 가중치

는 정규화항의 비중을 결정하는 값으로 실험적으로 결정될 수 있다.The local update value corresponds to a difference value between the global parameter value and the local parameter value, which will be described later in step S3. In one example, the weights for the regularization terms of all local models

is used identically. Weight for regularization term in one example

may be used differently depending on each local model. In this case, step S2 is the weight for the regularization term.

It may include the step of determining. weight

is a value that determines the weight of the normalization term and can be experimentally determined.

를 결정할 수 있다.In one example, processor 110 weights based on the amount of local data 120D.

can decide

를 더 크게 조정할 수 있다. 일 예에서

는 단말(100) 마다 다르게 설정할 수 있다.

가 클수록L1-norm 정규화의 영향이 커져서

가 더 희소해진다. 딘말(100)의 데이터량이 적은 기기는 후술할 수학식 3에 의해 실제 서버(200)로 전송할 로컬 업데이트 값이

배로 작아진다. 매우 작은 값들을 보내는 것이 통신 자원의 낭비이므로, 통신의 효율을 높이기 위해 사용될 수 있다. For example, the terminal 100 with a small amount of local data 120D

can be adjusted larger. in one example

may be set differently for each terminal 100.

The larger the , the greater the effect of L1-norm regularization.

becomes rarer A device with a small amount of data in the Dinmal 100 has a local update value to be transmitted to the real server 200 by Equation 3 described later

twice as small Since sending very small values is a waste of communication resources, it can be used to increase communication efficiency.

In step S3, the processor 110 may determine local update values for the second set of parameters based on the global parameter values and the local parameter values.

Step S3 includes determining, by the processor 110, a difference between the global parameter value and the local parameter value as a local update value.

The processor 110 may determine the local update value according to Equation 2 below.

은 단계(S2)에서 결정된 k번째 단말(100)의 로컬 파라미터 값이고,

는 단계(S1)에서 서버(200)로부터 획득한 글로벌 파라미터 값을 의미한다.here

Is the local parameter value of the k-th terminal 100 determined in step S2,

Means a global parameter value obtained from the server 200 in step (S1).

을 t+1 번째 라운드(round t+1)의 k번째 단말(100)의 로컬 업데이트 값으로 결정한다.That is, the processor 110 calculates the difference value according to Equation 2 in step S3.

is determined as the local update value of the k-th terminal 100 in the t+1-th round (round t+1).

을 정규화항으로 사용하므로, 차분값

이 희소(sparse)해지기 때문이다.In one example, the local update value according to Equation 2 may be expressed as a sparse matrix or sparse vector. This is the L1-norm in Equation 1

is used as a regularization term, so the difference value

because it becomes sparse.

이 희소해진다. 예를 들어, L1-norm regularizer를 적용할 경우, L2-norm regularizer를 사용하거나 정규화항을 사용하지 않았을 때 보다,

의 항들 중 0의 값에 근접하는 항이 많아지게 된다.That is, when using the L1-norm regularizer, the local update value

it becomes scarce For example, when the L1-norm regularizer is applied, the L2-norm regularizer is used or when no regularization term is used,

Among the terms of , the number of terms approaching a value of 0 increases.

Subsequently, in step S4, the processor 110 may transmit local updated values for the second set of parameters to the server 200.

For example, the processor 110 may transmit the local update value determined in step S3 or a value obtained by compressing the local update value to the server 200 . This reduces the amount of data to be transmitted to the server 200 per communication round, thereby improving the communication efficiency of federated learning.

대신에 희소한

를 전송하거나 이를 압축해서 전송할 수 있다. 희소한 벡터의 경우, 압축 효율이 더 높기 때문에 통신 효율성을 개선할 수 있다.That is, in the k-th terminal 100

instead of rare

can be transmitted, or it can be compressed and transmitted. For sparse vectors, the communication efficiency can be improved because the compression efficiency is higher.

The server 200 receiving local updated values for the second set of parameters of each terminal 100 from the terminal 100 updates the global model 220M based on these local updated values. This will be described with reference to FIG. 5 .

가 소정의 임계치(threshold)보다 작은 단말(100)에 L1-norm을 정규화 항으로 사용하고,

가 소정의 임계치보다 큰 단말(100)에는 L1-norm 대신 L2-norm을 사용하거나, 또는 정규화항을 사용하지 않을 수도 있다.On the other hand, in Equation 1 of step S2

L1-norm is used as a normalization term for the terminal 100 where is smaller than a predetermined threshold,

For the terminal 100 where is greater than a predetermined threshold, the L2-norm may be used instead of the L1-norm, or the normalization term may not be used.

5 is a flowchart of a federated learning method according to an embodiment.

5 is a diagram for explaining a process performed by the server 200 shown in FIG. 3 in a federated learning method according to an embodiment.

The federated learning method according to the embodiment includes transmitting, by the server 200, global parameter values for a first set of parameters of a global model 220M to a plurality of terminals 100 (SS1), server 200 Receiving, from at least some of the plurality of terminals 100, local update values for parameters of the second set corresponding to at least some of the parameters of the first set (SS2). and updating the global model 220M by the server 200 based on the local update value (SS3). Here, the local update value is the local parameter value for the second set of parameters determined based on a local objective function including a global parameter value and a regularization term associated with the local update value and an operational term defined by a weight for the regularization term. It is a value determined by the terminal 100 based on .

In step SS1, the processor 210 transmits global parameter values for the first set of parameters of the global model 220M to the plurality of terminals 100.

The first set of parameters is one of a subset of the full set of global parameters defining global model 220M. The global parameters are parameters defining the global model 220M, and include model parameters and hyperparameters of the global model 220M.

The plurality of terminals 100 is one of a subset of the entire set of terminals 100 belonging to the federated learning system 1000, and the processor 210 randomizes the plurality of terminals 100 in step SS1. can choose

In step SS2, the processor 210 receives local update values for parameters of the second set corresponding to at least some of the parameters of the first set from at least some of the plurality of terminals 100.

For example, in step SS2, the server 200 obtains local update values for the second set of parameters from the terminals 100 excluding the terminals 100 that have lost connectivity with the server 200 among the plurality of terminals 100. can receive

The local update value of the second set of parameters received in step SS2 corresponds to the value determined through step S3 in at least some terminals 100 among the plurality of terminals 100 with reference to FIG. 4 .

In step SS3, the processor 210 updates the global model 220M based on the local update value received in step SS2.

In step SS3, the processor 210 may update the global model 220M by Equation 3 below.

)으로부터 다음과 같이 t+1번째 라운드(round t+1)의 글로벌 모델을 결정한다.That is, the server 200 receives local update values from K terminals 100 (

), the global model of the t+1th round (round t+1) is determined as follows.

는 k번째 단말(100)이 가지고 있는 로컬 데이터(120D)의 양이다. n은 K개의 단말(100)의 로컬 데이터(120D)의 양을 합산한 전체 로컬 데이터(120D)의 양을 의미한다.here

is the amount of local data 120D that the k-th terminal 100 has. n means the total amount of local data 120D obtained by summing the amount of local data 120D of K terminals 100 .

The federated learning method according to the embodiment may further include repeating steps SS1, SS2, and SS3. For example, the server 200 may complete learning by repeating steps SS1, SS2, and SS3 a predetermined number of times, for example, T rounds.

In one example, the federated learning method according to the embodiment in round t + 2 (round t + 2) sets global parameter values for parameters of the second set of the global model updated in step (SS3) to a plurality of second terminals (100). ) can be sent to This is a process corresponding to step SS1 of round t+1, where the second set of parameters may be the same as or different from the first set of parameters, and the plurality of second terminals 200 are the plurality of first terminals. It may be the same as or different from (100).

6 is a flowchart of a federated learning method according to an embodiment.

FIG. 6 shows a mutual relationship between the federated learning process of the terminal 100 with reference to FIG. 4 and the federated learning process of the server 200 with reference to FIG. 5 .

The terminal 100 receives the global parameters transmitted by the server 200 in step SS1 in step S1.

The terminal 100 determines a local update value of the terminal 100 by performing steps S2 and S3 and transmits the local update value to the server 200 in step S4.

The server 200 receives a local update value from each terminal 100 in step SS2 and updates the global model by performing step SS3.

Until a predetermined number of iterations (round T) is reached or a predetermined end condition is satisfied, the server 200 re-executes step SS1 based on the updated global model.

7 shows exemplary pseudocode of a federated learning method according to an embodiment.

An exemplary pseudocode (FedSG) of the federated learning method according to the embodiment includes an execution code (At Server) of the server 200 and an execution code (At Client) of each terminal 100 .

The server 200 initializes global parameters, and iterates and executes the following process for T rounds.

)를 매개 인자로 전송한다.First, the server 200 selects K number of terminals 100 and sets a global parameter value (

) as a parameter.

)에 대한 로컬 파라미터 값(

)을 결정하고, 로컬 업데이트 값(

)을 계산하여 서버(200)에게 전송한다.The terminal 100 receives the global parameter value (

) for the local parameter value (

) is determined, and the local update value (

) is calculated and transmitted to the server 200.

)을 수신한 서버(200)는 글로벌 파라미터 값(

)을 집계 및 업데이트한다.Local update values from each terminal 100 (

), the server 200 receives the global parameter value (

) is aggregated and updated.

)를 다음 라운드에 참여하는 단말(100)에게 전송한다.The server 200 updates the global parameter (

) is transmitted to the terminal 100 participating in the next round.

The method according to an embodiment of the present invention described above can be implemented as computer readable code on a medium on which a program is recorded. The computer-readable medium includes all types of recording devices in which data that can be read by a computer system is stored. Examples of computer-readable media include Hard Disk Drive (HDD), Solid State Disk (SSD), Silicon Disk Drive (SDD), ROM, RAM, CD-ROM, magnetic tape, floppy disk, optical data storage device, etc. there is

The description of the embodiments of the present invention described above is for illustrative purposes, and those skilled in the art can easily modify them into other specific forms without changing the technical spirit or essential features of the present invention. you will understand that Therefore, the embodiments described above should be understood as illustrative in all respects and not limiting. For example, each component described as a single type may be implemented in a distributed manner, and similarly, components described as distributed may be implemented in a combined form.

The scope of the present invention is indicated by the following claims rather than the above detailed description, and all changes or modifications derived from the meaning and scope of the claims and equivalent concepts thereof should be construed as being included in the scope of the present invention.

100: terminal
200: server
1000: federated learning system

Claims (18)

As a federated learning method,
obtaining, by a terminal, global parameter values for parameters of a first set of global models from a server;
determining, by the terminal, a local parameter value for a second set of parameters corresponding to at least some of the first set of parameters by training a local model based on local data;
determining, by the terminal, local update values for the second set of parameters based on the global parameter values and the local parameter values; and
Transmitting, by the terminal, a local update value for the second set of parameters to the server.
including,
The step of determining the local parameter value,
Determining, by the terminal, the local parameter value based on a local objective function including a regularizer associated with the local update value and an operating term defined by a weight for the regularizer term,
federated learning method.
According to claim 1,
The step of determining the local parameter value,
Determining, by the terminal, the weight based on the amount of local data of the terminal
including,
federated learning method.
According to claim 1,
Determining the local update value,
Determining, by the terminal, a difference between the global parameter value and the local parameter value as the local update value.
including,
federated learning method.
According to claim 1,
The local update value is represented by a sparse matrix or sparse vector,
federated learning method.
According to claim 1,
The normalization term is defined as an L1-norm based on the global parameter value and the local parameter value for the second set of parameters.
federated learning method.
As a federated learning method,
transmitting, by the server, global parameter values for the first set of parameters of the global model to a plurality of terminals;
receiving, by the server, local update values for parameters of a second set corresponding to at least some of the parameters of the first set from at least some of the plurality of terminals; and
Updating, by the server, the global model based on the local update value.
including,
The local update value is,
the global parameter value and
local parameter values for the second set of parameters determined based on a local objective function comprising a regularization term associated with the local update value and an operand defined by a weight for the regularization term
A value determined by the terminal based on
federated learning method.
According to claim 6,
The weight is determined equally for all local models during federated learning or determined based on the amount of local data of the terminal.
federated learning method.
According to claim 6,
The local update value is determined according to a difference between the global parameter value and the local parameter value.
federated learning method.
According to claim 6,
The normalization term is defined as L1-norm based on the global parameter value and the local parameter value.
federated learning method.
As a terminal,
memory to store local data and local models; and
processor
including,
the processor,
obtain global parameter values for parameters of a first set of global models from a server;
train the local model based on the local data to determine local parameter values for a second set of parameters corresponding to at least some of the first set of parameters;
determine local update values for the second set of parameters based on the global parameter values and the local parameter values;
send local updated values for the second set of parameters to the server;
To determine the local parameter value,
configured to use a local objective function comprising an operand defined by a regularizer associated with the local update value and a weight for the regularizer term;
Terminal.
According to claim 10,
the processor,
To determine the local parameter value,
Configured to determine the weight equally for all local models or to determine the weight based on the amount of local data while federated learning is in progress.
Terminal.
According to claim 10,
the processor,
To determine the local update value,
Determine a difference between the global parameter value and the local parameter value as the local update value.
Terminal.
According to claim 10,
The local update value is represented by a sparse matrix or sparse vector,
Terminal.
According to claim 10,
The normalization term is defined as an L1-norm based on the global parameter value and the local parameter value for the second set of parameters.
Terminal.
As a server,
memory to store global models; and
processor
including,
the processor,
Transmitting global parameter values for a first set of parameters of the global model to a plurality of terminals;
Receiving local update values for parameters of a second set corresponding to at least some of the parameters of the first set from at least some of the plurality of terminals;
configured to update the global model based on the local update value;
The local update value is,
the global parameter value and
local parameter values for the second set of parameters determined based on a local objective function comprising a regularization term associated with the local update value and an operand defined by a weight for the regularization term
A value determined by the terminal based on
server.
According to claim 15,
the processor,
Is configured to determine the weight equally for all local models or to determine the weight based on the amount of local data of the terminal while federated learning is in progress,
server.
According to claim 15,
The local update value is determined by each terminal according to a difference between the global parameter value and the local parameter value.
server.
According to claim 15,
The normalization term is defined as L1-norm based on the global parameter value and the local parameter value.
server.

Images