Communication-Efficient Federated Deep Learning with Asynchronous Model Update and Temporally Weighted Aggregation

TL;DR

This paper introduces a communication-efficient federated deep learning method that employs asynchronous model updates and temporally weighted aggregation, improving accuracy and reducing communication costs.

Contribution

It proposes a novel asynchronous learning strategy with layered updates and a temporally weighted aggregation on the server, enhancing federated learning performance.

Findings

Outperforms baseline in accuracy and communication cost

Effective in training deep neural networks with limited communication

Improves convergence speed and model robustness

Abstract

Federated learning obtains a central model on the server by aggregating models trained locally on clients. As a result, federated learning does not require clients to upload their data to the server, thereby preserving the data privacy of the clients. One challenge in federated learning is to reduce the client-server communication since the end devices typically have very limited communication bandwidth. This paper presents an enhanced federated learning technique by proposing a synchronous learning strategy on the clients and a temporally weighted aggregation of the local models on the server. In the asynchronous learning strategy, different layers of the deep neural networks are categorized into shallow and deeps layers and the parameters of the deep layers are updated less frequently than those of the shallow layers. Furthermore, a temporally weighted aggregation strategy is introduced on the server to make use of the previously trained local models, thereby enhancing the accuracy and convergence of the central model. The proposed algorithm is empirically on two datasets with different deep neural networks. Our results demonstrate that the proposed asynchronous federated deep learning outperforms the baseline algorithm both in terms of communication cost and model accuracy.

Tables

Table 1. TABLE I: Parameter settings

Notion	Parameter Range
$freq$	{3/15, $5/{15}^{\ast }$, 7/15}
$a$	{$e/2^{\ast }$, e}
$K$	{10, ${20}^{\ast }$}
$m$	{1, $2^{\ast }$}

Table 2. TABLE II: Parameters settings for the CNN.

Layer	Shapes
conv2d_1	$5\times 5\times 1\times 32$
conv2d_1	$32$
conv2d_2	$5\times 5\times 32\times 64$
conv2d_2	$64$
dense_1	$1024\times 512$
dense_1	$512$
dense_2	$512\times 10$
dense_2	$10$

Table 3. TABLE III: Parameter settings for the LSTM.

Layer	Shapes
lstm_1	$9\times 100$
lstm_1	$25\times 100$
lstm_1	$100$
lstm_2	$25\times 100$
lstm_2	$25\times 100$
lstm_2	$100$
dense_1	$25\times 256$
dense_1	$256$
dense_2	$256\times 6$
dense_2	$6$

Table 4. TABLE IV: Experimental results on f ​ r ​ e ​ q 𝑓 𝑟 𝑒 𝑞 freq .

freq	Accuracy*	Round**
3/15	96.72% (0.0037)	115.74 (32.19)
5/15	97.08% (0.0037)	87.82 (20.03)
7/15	97.12% (0.0046)	95.43 (14.64)

Table 5. TABLE V: Experimental results on a 𝑎 a .

a	Accuracy*	Round**
e***	96.92% (0.0041)	75.26 (2.09)
e/2	97.08% (0.0037)	87.82 (20.03)

Table 6. TABLE VI: Experimental results on the scalability of the algorithm.

Scalability K m	FedAVG	TWAFL
20 2	96.83% (0.0097)	97.16% (0.0096)
10 1	94.26% (0.0083)	94.76% (0.0102)
10 2	96.16% (0.0167)	96.11% (0.0909)

Table 7. TABLE VII: Experiments on Performance .

Dataset_ID@Task	FedAVG Round (Accuracy)$\star$ C. Cost$\star \star$	TEFL Round (Accuracy)$\star$ C. Cost$\star \star$	TWAFL Round (Accuracy)$\star$ C. Cost$\star \star$	AFL Round (Accuracy)$\star$ C. Cost$\star \star$
1@MNIST*	75 (97.2%) 6.16	31 (97.9%) 0.74	106 (97.7%) 1	175 (95.4%) 2.46
2@MNIST*	85 (97.2%) 6.76	32 (98.5%) 1.33	61 (98.1%) 1	—(94.8%)$†$ —$†$
3@MNIST*	73 (97.7%) 5.99	31 (98.7%) 1.13	70 (97.9%) 1	—(94.9%)$†$ —$†$
4@MNIST*	196 (95.2%) 8.18	61 (98.0%) 1.14	136 (96.1%) 1	—(93.1%)$†$ —$†$
5@MNIST*	98 (97.1%) 3.28	76 (97.8%) 3.17	61 (96.1%) 1	109 (96.7%) 2.66
1@HAR**	526 (92.3%) 4.72	166 (94.0%) 0.69	358 (94.6%) 1	—(89.2%) $‡$ —$‡$
2@HAR**	451 (94.7%) 5.65	119 (95.4%) 0.57	313 (95.9%) 1	—(82.9%) $‡$ —$‡$
3@HAR**	—(87.3%) $‡$ —$‡$	174 (94.4%) 0.69	376 (93.2%) 1	—(88.5%) $‡$ —$‡$
4@HAR**	856 (90.2%) 7.05	181 (95.1%) 1.28	211 (94.1%) 1	751 (91.2%) 5.30
5@HAR**	571 (92.6%) 5.49	155 (93.6%) 0.57	404 (93.1%) 1	646 (92.5%) 2.38

Equations

$${\omega }_{t+1}\leftarrow \sum _{k=1}^K\frac{n_k}{n}\ast (e/2{)}^{-(t-timestam{p}^k)}\ast {\omega }^k$$

Full text

I INTRODUCTION

Smart phones, wearable gadgets, and distributed wireless sensors usually generate huge volumes of privacy sensitive data. In many cases, service providers are interested in mining information from these data to provide personalized services, for example, to make more relevant recommendations to clients. However, the clients are usually not willing to allow the service provider to access the data for privacy reasons.

Federated learning is a recently proposed privacy-preserving machine learning framework [1]. The main idea is to train local models on the clients, send the model parameters to the server, and then aggregate the local models on the server. Since all local models are trained upon data that are locally stored in clients, the data privacy can be perserved. The whole process of the typical federated learning is divided into communication rounds, in which the local models on the clients are trained on the local datasets. For the $k$-th client, where $k\in S$, and $S$ refers to the participating subset of $m$ clients, its training samples are denoted as $\mathcal{P}_{k}$ and the trained local model is represented by the model parameter vector $\omega^{k}$. In each communication round, only models of the clients belonging to the subset $S$ will download the parameters of the central model from the server ans use them as the initial values of the local models. Once the local training is completed, the participating clients send the updated parameters back to the server. Consequently, the central model can be updated by aggregating the updated local models, i.e. $\omega=Agg(\omega^{k})$ [2, 3, 1].

In this setting, the local models of each client can be any type of machine learning models, which can be chosen according to the task to be accomplished. In most existing work on federated learning [1], deep neural networks (DNNs), e.g., long short-term memory (LSTM), are employed to conduct text-word/text-character prediction tasks. In recent years, DNNs have been successfully applied to many complex problem-solvings, including text classification, image classification, and speech recognition [4, 5, 6]. Therefore, DNNs are widely adopted as the local model in federated learning, and the stochastic gradient descent (SGD) is the most popular learning algorithm for training the local models.

As aforementioned, one communication round includes parameter download (on clients), local training (on clients), trained parameter upload (on clients), and model aggregation (on the server). Such a framework appears to be similar to distributed machine learning algorithm [7, 8, 9, 10, 11, 12]. In federated learning, however, only the models’ parameters are uploaded and downloaded between the clients and server, and the data of local clients are not uploaded to the server or exchanged between the clients. Accordingly, the data privacy of each client can be preserved.

Compared with other machine leanring paradiagms, federated learning are subject to the following challenges [1, 13]:

Unbalanced data: The data amount on different clients may be highly imbalanced because there are light and heavy users. 2. 2.

Non-IID data: The data on the clients may be strongly non-IID because of different preferences of different users. As a result, local datasets are not able to represent the overall data distribution, and the local distributions are different from each other, too. The IID assumption in distributed learning that training data are distributed over local clients uniformly at random [14] usually does not hold in federated learning. 3. 3.

Massively distributed data: The number of clients is large. For example, the clients may be mobile phone users [2], which can be enormous. 4. 4.

Unreliable participating clients: It is common that a large portion of participating clients are often offline or on unreliable connections. Again in case the clients are mobile phone users, their communication state can vary a lot and thus cannot ensure their participation in each round of learning [1].

Apart from the above challenges, the total communication cost is often used as an overall performance indicator of federated learning due to the limited bandwidth and battery capacity of mobile phones. Of course, like other learning algorithms, the learning accuracy, which is mainly determined by the local training and the aggregation strategy, is also of great importance. Accordingly, the motivation of our work is to reduce the communication cost and improve the accuracy of the central model, assuming that DNNs are used as the local learning models. Inspired by interesting observations in fine-tuning of DNNs [15], an asynchronous strategy for local model updating and aggregation is proposed to improve the communication efficiency in each round.

The main contributions of the present work are as follows. First, an asynchronous strategy that aggregates and updates the parameters in the shallow and deep layers of DNNs at different frequencies is proposed to reduce the number of parameters to be communicated between the server and clients. Second, a temporally weighted aggregation strategy is suggested to more efficiently integrate information of the previously trained local models in model aggregation to enhance the learning performance.

The remainder of the paper is organized as follows. In Section II, related work is briefly reviewed. The detail of the proposed algorithm, especially the asynchronous strategy, the temporally weighted aggregation and the overall framework are described in Section III. Section IV presents the experimental results and discussions. Finally, conclusions are drawn in Section V.

II Related Work

Konečný et al. developed the first framework of federated learning and also experimentally proved that existing machine learning algorithms are not suited for this setting [2]. In [3], Konečný et al. proposed two ways to reduce the uplink communication costs, i.e., structured updates and sketched updates, using data compression/reconstruction techniques. A more recent version of federated learning, FedAVG for short, was reported in [1], which was developed for obtaining a central prediction model of Google’s Gboard APP and can be embedded in a mobile phone to protect the user’s privacy. The pseudo code of FedAVG is provided in Algorithm 1.

In the following, we briefly explain the main components of FedAVG:

Server Execution consists of the initialization and communication rounds.

1. (a)

Initialization: Line 2 initializes parameter $\omega_{0}$. 2. (b)

Communication Rounds: Line 4 obtains $m$, the number of participating clients; $K$ indicates the number of local clients, and $C$ corresponds to the fraction of participating clients per round, according to which line 5 randomly selects participating subset $S_{t}$. In lines 6-8, sub-function $ClientUpdate$ is called in parallel to get $\omega_{t+1}^{k}$. Line 9 executes aggregation to update $\omega_{t+1}$. 2. 2.

Client Update The sub-function gets $k$ and $\omega$. $B$ and $E$ are the local mini-batch size and the number of local epochs, respectively.

Line 14 splits data into batches. Lines 15-19 execute the local SGD on batches. Line 20 returns the local parameters.

The equation in line 9, $\omega_{t+1}\leftarrow\sum_{k=1}^{K}\frac{n_{k}}{n}*\omega_{t+1}^{k}$ described the aggregation strategy, where $n_{k}$ is the sample size of the $k$-th client and $n$ is the total number of training samples. $\omega_{t+1}^{k}$ comes from client $k$ in round $t+1$; however, it is not always updated in the current communication round. For clients that do not participate, their models remain unchanged until they are chosen to participate. In model aggregation, the parameters uploaded from clients in the current round and those in previous ones contribute equally to the central model.

Apart from reducing communication costs, other studies of federated learning have focused on protocol security. To tackle differential attacks, for example, Gayer et al. [16] proposed an algorithm incorporating a preserving mechanism into federated learning for client sided differential privacy. In [17], Bonawitz et al. designed an efficient and robust transfer protocol for secure aggregation of high-dimensional data.

While privacy preserving and reduction of communication costs are two important aspects to take into account in federated learning, the main concern remains to be the enhancement of learning performance of the central model on all data. The loss function of federated learning is defined as $F\left(\omega\right){\text{ = }}\sum\limits_{k=1}^{K}{\frac{{{n_{k}}}}{n}{f_{k}}\left(\omega\right)}$, where ${f_{k}}\left(\omega\right)$ is the loss function of the $k$-th client model. Clearly, the performance of federated learning heavily depends on the model aggregation strategy.

Not much work has been reported on reducing the communication cost by reducing the number of parameters to be uploaded and downloaded between clients and the server except for some recent work reported most recently [18]. In this work, we present an asynchronous model learning mode that updates only part of the model parameters to reduce communication and a temporally weighted aggregation strategy that gives a higher weight on more recent models in aggregation to enhance learning performance.

III Asynchronous Model Update and Temporally Weighted Aggregation

III-A Asynchronous Model Update

The most intrinsic requirement for decreasing the communication cost of federated learning is to upload/download as little data as possible without deteriorating the performance of the central model. To this end, we present in this work an asynchronous model update strategy that updates only part of the local model parameters to reduce the amount of data to be uploaded or downloaded.

Our idea was primarily inspired from the following interesting observations made in fine tuning deep neural networks [19, 15]:

Shallow layers in a DNN learn the general features that are applicable to different tasks and datasets, meaning that a relatively small part of the parameters in DNNs (those in the shallow layers) represent features general to different data sets. 2. 2.

By contrast, deep layers in a deep neural network learn ad hoc features related to specific data sets and a large number of parameters focus on learning features in specific data.

These above observations indicate that the relatively smaller number of parameters of in the shallow layers are more pivotal for the performance of the central model in federated learning. Accordingly, parameters of the shallow layers should be updated more frequently than those parameters in the deep layers. Therefore, the parameters in the shallow and deep layers in the models can be updated asynchronously, thereby reducing the amount of data to be sent between the server and clients. We term this asynchronous model update.

The DNN employed for the local models on the clients is shown in Fig. 1. As illustrated in the figure, it can be separated into shallow layers for learning general features and deep layers for learning specific-feature layers features, which are denoted as $\omega_{\text{g}}$ and $\omega_{\text{s}}$, respectively. The sizes of $\omega_{\text{g}}$ and $\omega_{\text{s}}$ are denoted as $S_{\text{g}}$ and $S_{\text{s}}$, respectively, and typically, $S_{\text{g}}\ll S_{\text{s}}$. In the proposed asynchronous learning strategy, $\omega_{\text{g}}$ will be updated and uploaded/downloaded more frequently than $\omega_{\text{s}}$. Assume that the whole federated process is divided into loops and each loop has $T$ rounds of model updates. In each loop, $\omega_{\text{g}}$ will be updated and communicated in every round, while $\omega_{\text{s}}$ will be updated and communicated in only $fe$ rounds, where $fe<T$. As a result, the number of parameters to be exchanged between the server and clients will be $(T-fe)*S_{\text{s}}$. This way, the communication cost can be significantly reduced, since $S_{\text{s}}$ is usually very large in DNNs.

An example is given in Fig. 2 to illustrate the asynchronous learning strategy. The abscissa and ordinate denote the communication round and the local client, respectively. In this example, there are five local devices, i.e., $\{A,B,C,D,E\}$ and a server. Point ($A,t$) indicates that client $A$ is participating in updating the global model in round $t$.

Fig. 2 (a) provides an illustration of a conventional synchronous aggregation strategy, where both $\omega_{{\text{g}}}$ and $\omega_{{\text{s}}}$ are uploaded/downloaded in each round. The grey rounded rectangles in the bottom represent the aggregation, in which both shallow and deep layers participate in all rounds. By contrast, Fig. 2 (b) illustrates the proposed asynchronous learning strategy. In this example, there are six computing rounds ($t-5,t-4,...,t$) in the loop, and the parameters of deep layers are exchanged in rounds $t-1$ and $t$ only. As a result, the number of reduced parameters to be communicated is $2/3*S_{\text{s}}$.

III-B Temporally Weighted Aggregation

In federated learning, the aggregation strategy (Line 9 in Algorithm 1) usually weights the importance of each local model based on the size of the training data on the corresponding client. That is, the larger $n_{k}$ is, the more the local on client $k$ will contribute to the central model, as illustrated in Fig. 3. In that example, the blue diamonds represent the previously trained local models, which do not take part in the $t+1$-th update of the central model and only the orange dots are the most recently updated local model on each client and will participate in the current round of aggregation. All participating local models (orange dots in Fig. 3) will be weighted by their data size only regardless the computing round in which these models are updated. In other words, local models updated in round $t-p$ are as important as those updated in round $t$, which might not be reasonable.

In federated learning, however, the training data on each participating client are changing in each round and therefore, the most recently updated model should have a higher weight in the aggregation. Accordingly, the following model aggregation method taking into account of timeliness of the local models is proposed.

[TABLE]

where $e$ is the natural logarithm used to depict the time effect, $t$ means the current round, and $timestamp^{k}$ is the round in which the newest $\omega^{k}$ was updated. The proposed temporally weighted aggregation is illustrated in Fig. 4. Similar to the setting used in Fig. 3, all clients participating in the aggregation are denoted by an orange dot, while others are represented by blue diamonds. Furthermore, the depth of the brown color indicates the timeliness and the deeper the color, the higher weight this local model will have in aggregation.

III-C Framework

The framework of the proposed federated learning with an asynchronous model update and temporally weighted aggregation is illustrated in Fig. 5. A detailed description of the main components will be given in the following subsection.

III-D Temporally Weighted Asynchronous Federated Learning

The pseudo code for the two main components of the proposed temporally weighted aggregation asynchronous federated learning (TWAFL in short), one implemented on the server and the other on the clients is given in Algorithm 2 and Algorithm 3, respectively.

The part to be implemented on the server consists of an initialization step followed by a number of communication rounds. In initialization (Algorithm 2, Lines 2-6 ), the central model $\omega_{0}$, timestamps $timestamp_{\text{g}}$ and $timestamp_{\text{s}}$ are initialized. Timestamps are stored and to be used to weight the timeliness of corresponding parameters in aggregation.

The training process is divided into loops. Lines 8-12 in Algorithm 2 set $flag$ to be true in the last $1/freq$ rounds in each loop. Assume there are $rounds\_in\_loop$ rounds in each loop. Lines 13-14 randomly select a participating subset $S_{t}$ of the clients according to $C$, which is the fraction of participating clients per round. In lines 15-24, sub-function $ClientUpdate$ is called in parallel to get $\omega^{k}$/$\omega_{\text{g}}^{k}$, and the corresponding timestamps are updated. $flag$specified whether all layers or the shallow layers only will be updated and communicated. Then in lines 25-28, the aggregation is performed to update $\omega_{\text{g}}$. Note that compared with Equation 1, a parameter $a$ is introduced into the weighting function in line 25 or line 27 to examine the influence of different weightings in the experiments. In this work, $a$ is set to $e$ or $e/2$.

The implementation of the local model update (Algorithm 3) is controlled by three parameters, $k$, $\omega$, and $flag$, where $k$ is the index of the selected client, $flag$ indicates whether all layers or the shallow layers will be updated. $B$ and $E$ denote the local mini-batch size and the local epoch, respectively. In Algorithm 3, Line 2 splits data into batches, whereas Lines 3-7 set all layers or shallow layers of the local model to be downloaded according to $flag$. In lines 8-12, local SGD is performed. Lines 13-17 return local parameters.

IV Experimental Results and Analyses

IV-A Experimental Design

We perform a set of experiments using two popular deep neural network models, i.e., convolution neural networks (CNNs) for image processing and long short-term memory (LSTM) for human activity recognition, respectively, to empirically examine the learning peformance and communication cost of the prposed TWAFL. A CNN with two stacked convolution layers and one fully connected layer [20, 21] is applied on the MNIST handwritten digit recognition data set, and a LSTM with two stacked LSTM layers and one fully connected layer is chosen to accomplish the human activity recognition task [22, 23]. Both MNIST and the human activity recognition datasets are adapted to test the performance of the proposed federated learning framework for different real-world scenarios, e.g., non-IID distribution, unbalanced amount, and massively decentralized datasets, which will be discussed in detail in the next subsection.

The federated averaging (FedAVG) [1] is selected as the baseline algorithm since it is the state-of-the-art approach. The proposed TWAFL is also compared with two variants, namely, TWFL that adopts temporally weighted aggregation without asynchronous model update, and AFL that employs the asynchronous model update without using temporally weighted aggregation. Thus, four algorithms, i.e., FedAVG, TWAFL, TEFL and AFL will be compared in the following experiments.

The most important parameters in the proposed algorithm are listed in Table I. Parameter $freq$ controls the frequency for updating and exchanging the parameters in the deep layers $\omega_{\text{s}}$ between the server and the local clients in a loop. For instance, $freq=5/15$ means that only in the last five of the 15 rounds, the parameters in the deep layers $\omega_{\text{s}}$ will be uploaded/downloaded between the server and clients. $a$ is a parameter for adjusting the time effect in model aggregation. $K$ and $m$ are environmental parameters controlling the scale or complexity of the experiments, $K$ denotes the number of local clients, and $m$ is the number of participating clients per round.

IV-B Settings on Datasets

As discussed in Section I, the federated learning framework has its particular challenges, such as non-IID, unbalanced, and massively decentralized datasets. Therefore, the datasets used in our experiments should be designed to reflect these challenges. The generation of the client dataset is described in detail in Algorithm 4, which is controlled by four parameters $Labels$, $N_{c}$, $S_{min}$, and $S_{max}$, where $N_{c}$ controls the number of classes in each local dataset, $S_{min}$ and $S_{max}$ specify the range of the size of the local data, and $Labels$ indicates the names of classes involved in the corresponding tasks.

IV-B1 Handwritten Digit Recognition Using CNN

The MNIST dataset has ten different kinds of digits and one digit is a 28*28-pixel gray-scale image. To partition the data over local clients, we first sort them by their digit labels and divide them into ten shards, i.e., 0, 1, …, 9. Then, Algorithm 4 is performed to compute $\mathcal{P}_{k}$, which is the $k$-th client’s partition coefficient corresponding to these shards. In this task, $Labels=\{0,1,2,...,9\}$; $N_{c}$ is randomly chosen from $\{2,3\}$, given $K=20$, $S_{min}=1000$ and $S_{max}=1600$. For the sake of easy analyses, five partitions/local datasets, namely 1@MNIST, 2@MNIST, …, 5@MNIST are predefined. Their corresponding 3-D column charts are plotted in Fig. 6.

The architecture of the CNN used for the MNIST task has two $5\times 5$ convolution layers (the first one has 32 channels and the other has 64) and $2\times 2$ max pooling layers. Then a fully connected layer with 512 units and ReLu activation is followed. The output layer is a softmax unit. The parameter settings for the CNN are listed in Table II.

IV-B2 Human Activity Recognition using LSTM

In the Human Activity Recognition (HAR) dataset, each data is a sequence of images with a label out of six activities. Similar operations are applied on the HAR dataset to divide the dataset over local clients. Here, $Labels=\{0,1,2,...,5\}$; $N_{c}$ is randomly chosen from $\{2,3\}$, given $K=20$, $S_{min}=250$ and $S_{max}=500$.

The architecture of the LSTM used in this study has two $5\times 5$ LSTM layers (the first one with $cell\_size=20$ and $time\_steps=128$ and the other with $cell\_size=10$ and the same $time\_steps$), a fully connected layer with 128 units and the ReLu activation, and a softmax output layer. The corresponding parameters of the LSTM is given in Table III.

IV-C Results and analysis

Two sets of experiments are performed in this subsection. The first set of experiments examines the influence of the most important parameters, $freq$, $a$, $K$ and $m$, on the performance of the two strategies using the CNN for the 1@MNIST dataset. The second set of experiments compares four algorithms in terms of the communication cost and learning accuracy using the LSTM on the HAR dataset, since the HAR is believed to be more challenging than the MNIST dataset.

IV-C1 Effect of the Parameters

The experiments here are not meant for a detailed sensitivity analysis. These experiments and related discussions aim to offer a basic understanding of parameter settings that may be helpful in practice. We mainly conduct research on the parameters listed in Table I.

In investigating the influence of a particular parameter, all others are set to be their default value. Experiment on $freq$ are carried out for $freq=\{3/15,5/15,7/15\}$, given $a=e/2$, $K=20$, and $m=2$.

Two metrics are adopted in this work for measuring the performance of the compared algorithms. One is the best accuracy of the central model within 200 rounds and the other is to the required rounds before the central model’s accuracy reaches 95.0%. Note that the same computing rounds means the same communication cost. All experiments are independently run for ten times, and their average (AVG) and standard deviation (STDEV) values are presented in Tables IV, V, and VI. In the tables, the average value is listed before the standard deviation in parenthesis.

Based on the results in Tables IV, V, and VI, the following observations can be made.

• •

Analysis on freq: From the results presented in Table IV, we can conclude that the lower the exchange frequency is, the less communication costs will be required, which is very much expected. However, a too low $freq$ will deteriorate the accuracy of the central model.

• •

Analysis on a: $a$ is a parameter that controls the influence of time effect on the model aggregation. When $a$ is set as $e$, the more recently updated local models are more heavily weighted in the aggregated model, and $a$ takes the value $e/2$, the previously updated local models will have a greater impact on the central model. The results in Table V indicate that $e/2$ is a better option for the CNN on the 1@MNIST dataset. When $a=1$, the algorithm is reduced to AFL, meaning that the parameters uploaded in different rounds will be of equal importance in the aggregation.

Both parameters $K$ and $m$ leverage the scalability of federated learning. The AVG and STDEV values are calculated based on the recognition accuracy of the CNN on the five predefined datasets. Different combinations of $K$ and $m$ are separately assessed. Based on the results presented in Table VI, the following three conclusions can be made. First, a larger number of involved clients (a larger $m$) leads to a higher recognition accuracy. Second, TWAFL outperforms FedAVG when the active client fraction is $C=0.1$, as indicated in the results in rows one and two in the table. Third, FedAVG is slightly better when the total number of clients is smaller and $C$ is higher, as shown by the results listed in the last row of the table. This implies that the advantage of the proposed algorithm over the traditional federated learning will become more apparent as the number of clients increases. This is encouraging since in most real-world problems, the number of clients is typically very large.

IV-C2 Comparison on Accuracy and Communication Cost

The following experiments are conducted for testing the overall performance of the algorithms under comparison using the default values of the parameters. Five local datasets are predefined for MNIST and HAR, respectively. For instance, local dataset 1 of task MNIST are termed as 1@MNIST. The importance of the temporal weighting is first demonstrated by comparing the changes of the accuracy over the computing rounds. The baseline FedAVG and TEFL without the asynchronous update are compared and the results on the MNIST and HAR datasets are shown in Fig.7 and Fig. 8, respectively.

The following conclusions can be reached from the results in the two figures. First, the proposed temporally weighted aggregation helps the central model to converge to an acceptable accuracy. On the 1@MNIST and 2@MNIST datasets, TEFL needs about 30 communication rounds to achieve an accuracy reaches to 95.0%, while the traditional FedAVG needs about 75 rounds to achieve a similar accuracy, leading to a reduce of 40% communication cost. Similar conclusions can also be drawn on datasets 3@MNIST, 4@MNIST and 5@MNIST, although the accuracy of TEFL becomes more fluctuating. Second, on the HAR dataset, a more difficult task, TEFL can mostly achieve a higher accuracy than FedAVG except on 5@HAR. Notably, TEFL only needs about 75 communication rounds to achieve an accuracy of 90%, while FedAVG requires about 750 rounds, resulting in a nearly 90% reduction of the communication cost. Even on 5@HAR, TEFL shows a much faster convergence than FedAVG in the early stage. Finally, the temporally weighted aggregation may result in some fluctuations on the learning performance, which may be attributed to the fact that the contributions of some high-quality local models are less weighted in some communication rounds.

Finally, the comparative results of the four algorithms on ten test cases generated from MNIST and HAR tasks are given in Table VII. The listed metrics include the number of rounds needed, the classification accuracy (listed in parenthesis), and total communication cost (C. Cost for short). From these results, the following observations can be made:

• •

Both TWAFL and TEFL outperform FedAVG on most cases in terms of the total number of rounds, the best accuracy, and the total communication cost.

• •

TEFL achieves the best performance on most tasks in terms of the total number of rounds and the best accuracy. The temporally weighted aggregation strategy accelerates the convergence of the learning and improved the learning performance.

• •

TWAFL performs slightly better than TEFL on MNIST in terms of the total communication cost, while TEFL works better than TWAFL on the HAR datasets. The asynchronous model update strategy significantly contributes to reducing the communication cost per round.

• •

AFL performs the worst among the four compared algorithms. When comparing the performance of the AFL only adopting the asynchronous strategy and the TWAFL using both of them, the asynchronous one always needs the help of the other strategy.

V CONCLUSIONS AND FUTURE WORK

This paper aims to reduce the communication costs and improve the learning performance of federated learning by suggesting an synchronous model update strategy and a temporally weighted aggregation method. Empirical studies comparing the performance and communication costs of the canonical federated learning and the proposed federated learning on the MNIST and human action recognition datasets demonstrate that the proposed asynchronous federated learning with temporally weighted aggregation outperforms the canonical one in terms of both learning performance and communication costs.

This study follows the assumption that all local models adopt the same neural networks architecture and share same hyper parameters such as the learning rate of SGD. In future research, we are going to develop new federated learning algorithms allowing clients to evolve their local models to further improve the learning performance and reduce the communication costs.

Acknowledgment

This work is supported by the National Natural Science Foundation of China with Grant No.61473298 and 61876184.