Few-Round Learning for Federated Learning
Authors: Younghyun Park
Dong-Jun Han
Do-Yeon Kim
Jun Seo
Jaekyun Moon
Venue:  (2021)
Keywords: Federated Learning

Abstract: Federated learning (FL) presents an appealing opportunity for individuals who are willing to make their private data available for building a communal model without revealing their data contents to anyone else. Of central issues that may limit a widespread adoption of FL is the significant communication resources required in the exchange of updated model parameters between the server and individual clients over many communication rounds. In this work, we focus on limiting the number of model exchange rounds in FL to some small fixed number $R$, to control the communication burden. Following the spirit of meta-learning for few-shot learning, we take a meta-learning strategy to train the model so that once the meta-training phase is over, only $R$ rounds of FL would produce a model that will satisfy the needs of all participating clients. A key advantage of employing meta-training is that the main labeled dataset used in training could differ significantly (e.g., different classes of images) from the actual data sample presented at inference time. Compared to the meta-training approaches to optimize personalized local models at distributed devices, our method better handles the potential lack of data variability at individual nodes. Extensive experimental results indicate that meta-training geared to few-round learning provide large performance improvements compared to various baselines.

Under review as a conference paper at ICLR 2021
FEW-ROUND LEARNING FOR FEDERATED LEARNING
Anonymous authors Paper under double-blind review
ABSTRACT
Federated learning (FL) presents an appealing opportunity for individuals who are willing to make their private data available for building a communal model without revealing their data contents to anyone else. Of central issues that may limit a widespread adoption of FL is the significant communication resources required in the exchange of updated model parameters between the server and individual clients over many communication rounds. In this work, we focus on preparing an initial model that can limit the number of model exchange rounds in FL to some small fixed number R. We assume that the tasks the clients participating in FL are not known in the preparing stage. Following the spirit of meta- meta-learning for few-shot learning, we take a meta-learning strategy to prepare the initial model so that once this meta-training phase is over, only R rounds of FL would produce model that will satisfy the needs of all participating clients. Compared to the meta- training approaches optimize personalized local models at distributed devices, our method better handles the potential lack of data variability at individual nodes. Extensive experimental results indicate that meta-training geared to few-round learning provides large performance improvements compared to various baselines.
INTRODUCTION
Major machine learning applications including computer vision and natural language processing are currently supported by central data centers equipped with massive computing resources and ample training data. At the same time, growing amounts of valuable data also being collected at distributed edge nodes such as mobile phones, wearable client devices and smart vehicles/drones. Directly sending these local data the central server for model training raises significant privacy concerns. To address this issue, an emerging trend known as federated learning (McMahan et al.,
2017
Konecny et al.] 2016 Bonawitz et al., 2019; Li et al.; 2019 Zhao al. 2018; Sattler al,, Reisizadeh et al. 2019), where server uploading of local data is not necessary, has been
2019
actively researched.
Unfortunately, federated learning (FL. generally requires numerous communication rounds between the server and the distributed nodes (or clients) for model exchange, to achieve desired level of prediction performance. This makes the deployment of FL a significant challenge in bandwidth- limited or time-sensitive applications. Especially in real-time applications (c.g., connected vehicles or drones), where the model should quickly adapt to dynamically evolving environments, the re- quirement many communication rounds becomes major bottleneck. Moreover, the considerable amounts of time and computational resources required for training place a high burden on individ- ual clients wishing especially in light of the increased communication burden for guaranteeing full privacy via secure aggregation (Bonawitz et al., (017).
participate in FL. Excessive communication rounds in FL are major concern
To combat this limitation, we focus on preparing an initial model that can quickly obtain a high- accuracy global model within only few communication rounds between the server and the clients. Following the spirit of meta-learning for few-shot learning, we meta-train the model via episodic training to mimic and tee up for few-round FL. Meta-training enables reliable prediction even when the data sample at hand does not share the same characteristics with the dataset the given model was trained with. In contrast to existing meta-training attempts to initiate model for further personalized optimizations at local devices, our approach takes advantage of FL's ability to exploit varying data distributions across clients. A high-level description of our idea is depicted in Fig. I Given small target value R, our goal is to create an initial model that can quickly adapt, within rounds of FL., to set of clients with tasks not seen during meta-training. As long the tasks are different

---

Under review as a conference paper at ICLR 2021
Deployment (Testing)
Meta-training
Meta-trained initial model
Episodic training targeting R- R-round federated learning
Fast adaptation within R communication rounds followed by inference
Figure I: Overall procedure of the proposed few-rount learning algorithm for federated learning. By using the meta-trained initial model. a set of clients with new tasks can quickly obtain high-accuracy global model within only few rounds of FL. Meta-training based on episodic training that mimics actual inference pre- ceded by R-round FL procedure. A global prototype-assistrd learning strategy both meta-training and deployment phases further improves model accuracy.
between meta- veta-training and deployment, it is immaterial whether node that participated in the meta- training also partakes in few-round federated learning (followed by inference). In the context of image classification, different tasks mean classification involving different sets of image categories or classes (e.g., different categories of lung discases to be diagnosed using chest X-ray images). The prospect meta-training also raises an intriguing possibility that meta-training can actually be done using proxy data at the server simply mimicking the federated optimization process, although we will not be concerned with this approach in the present work.
Extensive experimental results show that our fow-round learning algorithm outperforms various baselines in both IID (independent, identically distributed) and non-IID data distribution setups. In an IID setup, for example, our algorithm achieves a 75.32% the accuracy on fiered[mageNet within only R = 3 rounds of FI., which surpasses fine-tuned federated averaging (FedAvg) by 14.63% and fine-tuned one-shot federated learning (Guha et al.
2019 by 12.88%.
2 RELATED WORKS
Few-shot learning is an instantiation of meta-learning. the context of image classification, few-shot learning typically involves episodic training where each episode of training data is arranged into a few training (support) sample images and validation (query) samples to mimic inference that uses only a few examples (Vinyals al. 2016). Through repetitive exposure to series of varying episodes with different sets of image classes, the model learns to handle new tasks (classification against unseen classes) each time. Two widely-known few-shot learning methods with different philosophical twists, which are also conceptually relevant to the present work, are model-agnostic meta-learning (MAML) of (Finn et al.) 2017) and Prototypical Networks of (Snell) et al. 2017). MAML attempts to generate an initial model from which different models targeting different tasks can be obtained quickly via just few gradient updates. The idea is that the initial model is learned via meta- meta-training to develop an internal representation that is close in some sense to a variety of unseen tasks. Prototypical Networks, on the other hand, do not rely on such fine- tuning using few examples but rather learn embedding space such that model outputs cluster around class prototypes, the class-specific centroids of the embedder outputs. With episodic training, simple Prototypical Networks appear to be effective in learning inductive bias for successful generalization to new tasks. Our work takes from both concepts: we utilize prototype representation and we also adopt fine-tuning during R-round federated learning in adapting to new tasks.
Few-shot learning.
Federated meta-learning. Recent research activity has focused on improving model personaliza- tion via federated meta-learning (Lin et al. 2020 Chen et al. 2018 8 Fallah et al., 2020 Tiang et al.) 2019). The common goal of these works is generate an initial model based on which each new client can find its own optimized model via few local gradient steps and using only its own data. In these works, meta-learning employed during federated learning intends to enable each client to handle previously unseen tasks, in the spirit of MAML of (Finn et al., 2017). User-specific next- word prediction at individual smartphones, for example, could be an application of approaches along this direction. Compared to this line of work, we focus on creating an initial model that leads to high-acc accburcyr global model, rather than personalized models, within only a few rounds of federated learning. In this way, seek to take advantage of a higher variety of data as well as the larger data volume that would be made available through collaborative learning of many distributed nodes. A clear example is the diagnosis of broader class of diseases that would be possible through collec-
2

---

Under review as a conference paper at ICLR 2021
tive training across numerous examples contributed by larger group of individuals. Personalized optimization would be especially at disadvantage in non-llD setting, where each client necessarily lacks sufficient variety of training data.
One-shot federated learning. Another line of work recently focused one-shot federated learn- ing, where the goal is to train a global model with just one communication round between the server and the clients. The authors of (Guha al. 2019) proposed an ensemble method to choose reliable client-specific models from given clients. To effectively capture global information, they proposed various criteria by which participating clients are chosen. In the work of (Shin et al. 2020), local clients send XOR-encoded MNIST image data to the server, and the server decodes it to train the global model. While the server would need certain data advance to decode the received results, XOR operation can serve as data augmentation while preserving privacy. In the fusion learning of (Kasturi et al., 2020), each local client uploads both the model parameters and the distribution pa- rameters to the server. The server generates artificial data samples from the distribution parameters to train a global model. When the data gets complex, however, it is not clear whether conversion into a simple distribution would be reliable. Compared to the existing works on one-shot federated learning that employ some randomly initialized model, the key difference of our method is the use of meta-learning to obtain an initial model which can adapt to the unseen tasks of individual clients within R rounds of FL. It is shown in Section 4 that the suggested approach yields remarkable performance gains compared to one-shot federated learning methods.
3 PROPOSED FEW-ROUND LEARNING ALGORITHM
3.1 PROBLEM SETUP
Federated learning allows each distributed node k with a dataset D; to partici- pate in iterative learning of a global model 0 without having to reveal its data to anyone else including the central server. As given round starts, each of K participating nodes downloads a global model
Federated learning,
0, from the server and updates it using its own local data Dz. The updated local models 0,+1 (k) get
all uploaded to the server, which then aggregates them to get a new model 0,+1 = > 1 Pk px0r+1 (k) [Del
according to the relative dataset sizes Pi: ΣE [Dal' As the next rounds starts, this new global
model gets downloaded to all participating nodes and the same process is repeated. Federated learn- ing generally requires a significant number of such global rounds to achieve the desired accuracy, with each round taking up substantial computing and communication resources.
Problem formulation. To enable fast federated learning, we would like prepare initial model ó in which group of clients can quickly obtain a high-performance global model within A com- munication rounds. In applying meta-learning, we wish to satisfy clients who hope to predict data that were unseen during meta-training. During It rounds of FL at deployment time, each client is also expected to make available some small number of labeled examples associated with the data she hopes to predict. To create a training environment matching the actual R-rounds of FL followed by inference at deployment, each episode, our meta-training updates the model over federated rounds using the support set (R global rounds) and then makes final adjustment (meta-update) using the query set. This process is repeated as the model is exposed to a series of episodes.
3.2 META- TRAINING
Our meta-training procedure is given in Algorithm 1. Let ón be the initial model and ør the model generated after all T episodic stages. To construct each episode the server selects a new set of K clients participating for training]] The model oe has been updated through the end of episode stage t 1. The server lets ou = Øe and sends this initial model the selected K clients. Through R rounds of local updates and global aggregations guided by the support sets, the model 6u evolves to Or- Before moving to the next episode, a loss based on the updated model On and the local query set is minimized with respect to di to get each meta-updated local model (k)) In the final server aggregation of the episode stage, the global meta-updated model Φt+1 is obtained from the local models, which then becomes the initial model for the next episode. Here, & is a parameter that is updated by meta-update process with the query sets, and / a parameter that is updated during R rounds of federated learning with the support sets.
If the server has enough data, there is no need to utilize the distributed clients for meta-training; the server can simply mimic the federated learning setup and procedure.
3

---

Under review as a conference paper at ICLR 2021
Specifically, given K clients in each episode, we first split D3 (the local dataset of client k) into support set S₃ and query set Qk such that they are disjoint. Starting from the initial model 8ys each client & utilizes its support set S5 to update the local model during R global rounds. The local update in Line 16 involves a loss function that depends on class prototypes, as to be clarified shortly. In our method, the server aggregates not only the local models (Line 18) but also the local prototypes (Line 20), After It rounds of local updates and global aggregations, the server obtains the global model Or and sends it the K clients while still in the current episode stage. Based on the downloaded On and prototypes, each client & utilizes query set Qs to compute the query loss I 2 and meta- updates oe to obtain 0 (k) in Line 24. Note that the local loss L obviously depends on OR. which in turn depends Og tbe; in principle 'local is minimized with respect to de in this step.
At last, the server finds the final output Φ1+1 of the episode by aggregating the meta-updated local models Φ (K) for & E {1,2,... ..., K). In the meta-learning point of view, the initial model first adapts to the local support sets for R global rounds in the first step, and then is meta-updated based on the losses computed from the adapted model OR and the local query sets, in the second step. This two-step training procedure mimics the deployment phase where the initial model is updated for R communication rounds before making predictions. In the following, we provide some missing details on the description of loss functions and prototype processing.
Algorithm Meta- Sata-Tranning procedure for Proposed Few-Round Learning
Input: Initialized model Φp Output: Model Φv after 7 training episodes
1: for each training episode = 0, 1...., T - -1 do
2: The server constructs an episode with clients
3: Each client l E (1, K...KK splits Dr into support set Sg and query set Q
4:
Og + di
5:
for each communication round 0, 1. R do for each client & in parallel do if 0 then
6:
7:
8:
Download 6, from the server
9:
else
10:
Download 0, and P,-1 from the server
11:
end if
12:
for each class c E C2 do (k) [Stte] (xeS((e) (x)
13:
>
Local prototype calculation with support set Sa
14:
15:
end for
16:
8 (k:) 0, VV, S (0,)
Local update of 0 with Sa
17:
end for
18:
0,+1 = EK (k4r+1(k)
Server aggregation of local models 0; A relative support set size
P. - --=(< (k)f( 1,2, .... No}
20:
Server aggregation of local prototypes
21:
end for
22:
for each client i in parallel do
23:
Download OR and PR-1 from the server
24:
1 Φ:- VV o. Re (0n, Pn-1).
b Local meta-update of & with query set Q+
end for
26: Φ1+1 ΣK Ck=l PR
> Server aggregation of meta-updated models; Ps is relative data size
27:
end for
3.2.1 ROUNDS OF LOCAL UPDATES AND AGGREGATIONS
In defining the loss function, we utilize the class prototypes and associated distance metric of (nelll al. 2017). For each communication round 0, 1.., 1, we not only aggregate the global model 6,44 but also the set of global prototypes P, = [P]cc = 1, 2.., Ne} for all classes e e (1, (..,2...N) N.), where N₂ the number of classes in the current episode over clients.
Model and global prototype download. In the beginning of round r > 1, the server has the global model 0r and the set of global prototypes P,-1 {Pp_ 1,2, ..., .,, N.) which are the outputs of
4

---

Under review as a conference paper at ICLR 2021
the previous round r - 1. Each client & E (1.2.... K} first downloads 8, and P,-1 from the server. Since there is no global prototype in the first round, the clients only download the model 8g from the server when 0.
Local prototype calculation. Based on the downloaded model 0,. each client computes the local prototype (k) for each class E Ck using its support set Sk as
(k)
Σ (a) xE)((c)
(1)
[sx(c]
where C₁ is set that contains all classes in client &t and Sx(c) is a set of all data samples in Sp labeled with class c. For given input data sample 2, fe(x) represents the output of function f with model parameters 9. This local prototype (k) can be viewed representative of class calculated based on the local data (support set) of client k.
Loss calculation from local prototype. Let P. (k: be the set that contains all types of prototypes in client k. defined as P. (A) {PF (R)]cc Cs Now using Sk. 0, and P, (k),, each client i computes
the local loss L L (O,, P. (k:) according to
L (0, (t)))) E.ec, |sx(o)
Σ E CECr xESE(C)
(d(fo()),PP(())) Σ ctylc
(k)))
(2)
which is based on the squared euclidean distance d(-)) between (k) and fo(x) for x E S (c). We would like to minimize this local loss during local update at each client.
Auxiliary loss from global prototype. we only consider the loss function of (2) each client would have biased models after local updates, especially when the data distributions across different clients are non-IID. This generally leads to performance degradation of the global model. Hence, learning (GPAL) strategy where a global prototype helps to train the local models in the right direction; the set of global prototypes P,-1 can encourage local models to maintain stability during optimization because the global prototype contains all the information in local data from the entire set of clients. We adopt the dense classification loss of [Lifchitz al. 2019) construct the auxiliary loss. Let go()) be the output of the last convolutional neural network (CNN) layer of model 6, immediately before average pooling. Let go (x), be its feature vector at position i. For each local update, client & compares global prototype P 1P-_1e- 1,2, .... No} with go (I:;; and calculates auxiliary loss L (0r, Pr-1) similar to
propose global prototype-assisee
S P+) = LeEc, (c)
Σ
Σ
Σ (dd(go()); Pf)) + log Σ (x)((-d(o(z)), P: 1))}
oEC =ESu(c)
c'
We also wish to minimize this auxiliary loss, to make the local clients not overly biased and to learn general embedding space.
Local model update. Based on the loss functions 2 and for r 2 1, the objective function for local optimization becomes
5sk (0.) St (0r, Pr(k) L5 (Or, Pr-1)
where y is a balancing factor. For r = O, we have 8 (0,) = (0,, since the global prototype is not defined in the first global round. Now based on the the objective function & (0,), each client i performs local update according to Line 16 of Algorithm[1 where is the learning rate. In federated learning, the clients generally performs multiple local updates, say E times. Hence, the process of local prototype computation (T. loss computations (2) 3 and local model update of Line 16 of Algorithm is repeated E times to obtain 0p+1 (k).
Model and prototype aggregation at the server. After performing local updates at the clients, each client & sends its updated local model ( and the computed local prototypes P, (k) to the server. Then the server aggregates the local models and the local prototypes according to Lines 18
and 20 in Algorithm respectively, where the weighting factor d Σ |Sy] support set sizes.
[S reflects the relative
The above local update and global aggregation processes are repeated for R. global rounds (r = 0, 1,.... R - 1), and the server finally obtains On and PR-1-
5

---

Under review as a conference paper at ICLR 2021
3.2.2 ONE-ROUND LOCAL PUTAAUP AND AGGREGATION
Towards the end of each episode processing stage, the clients download On and Px-1 from the server. At each client k, the local query loss Ligeal (OR: PR-1) is calculated similar to ② based on Qs. lR. and PR-I- Taking derivative of L with respect to o, in Line 24 can easily be done through the chain rule, yielding (dropping super/subseripts and terms not critical for now): ((. = Ven [(RR) x 30, 0R = ((0R) x (II-00
À J0. (0, - aVa, F5x
where Og oe and the loss function F* is the local loss seen in Line 16. We notice that the prod- uct term here involves double derivatives, which can be safely ignored according to our empirical observation (which is consistent with what was observed in a parallel setting in MAML of (Finn et al. 2017)) Thus, we simply use first-order approximation Ve, [(On) ~ Vog [(On) to perform the local meta-update in Line 24. The server finally aggregates the meta-updated models from all clients and moves on to the next episode.
3.3 DEPLOYMENT (TESTING)
In the actual deployment or test phase, given a set of clients with unseen classes, the server sets Oo = ΦT and then performs It rounds of federated learning to obtain OR and PR-1- Now, given a test sample, we make prediction based on f and PR-1: we first compute the output of model Rn with the new test sample, and then compare the distances with all global prototypes in PR-1 to make the decision.
4 EXPERIMENTAL RESULTS
We validate our proposed algorithm on two benchmark datasets for meta-learning, mindmageNeet /Vinyals et al. 2016) and tieredImageNet (Ren et al. 2018). which have significantly larger num- bers of classes than MNIST or CIFAR-10 commonly used in federated learning studies. Following the data splits introduced in (Ravi & Larochelle 2017), 100 classes are divided into 64 training, 20 test and 16 validation classes for minilmageNet. For tieredImageNet, the dataset is divided into 351/160/97 classes for train/test/validation,, respectively. Experimental results CIFAR-100 dataset can be found in the Supplementary Materials.
Comparison schemes. We compare our algorithm with the following schemes. First, as a simplest baseline, we consider FedAvg (McMahan et (017). where a randomly initialized model is trained for R communication rounds. Preparing stage is not utilized for this scheme. Second, we consider a FedAvg-based fine-tuning method, where the overall model is first pre-trained on the training set in the preparing stage, and then fine-tuned to the unseen test set for R communication rounds via FedAvg in the deployment phase. For example, in minilmageNet, a 64-way classifier model is pre-trained first. Next, the last linear layer is replaced and newly initialized, and then the overall model is fine-tuned during testing. Finally, we consider fine-tuning based on one-shot FL (Guha eet al., 2019), where the local models are sampled and aggregated by the ensemble cross-validation (CV) method. We allow a larger number of available clients for this scheme to accommodate user sampling. The model is first pre-trained on the training set in the preparing stage, and then fine- tuned to the unseen classes with the scheme of (Guha et al.) 2019) for R rounds. For our few-round learning (FRL) algorithm, we utilize both linear classifier and distance-based classifier (Snell et al. 2017) for comparison. For the linear classifier case, we connect additional linear layer behind CNN layers, as in other baselines. The distance- based classifier utilizes the output of CÑN layers, e.g., build prototypes, instead of using the linear layer. For the distance-based classifier, we observe the effect of global prosotype-asiisted learning (GPAL) using the auxiliary loss.
Experimental setup. We meta-train as well as test our model in federated learning setups. We typ- ically set the target number of communication rounds R- 3. Hence, in the meta-training phase, each episode of our scheme requires 4 global rounds: 3 rounds of local updates and aggregation, and 1 round of local meta-update and aggregation. For a fair comparison, we let all baselines to consume the same amount of communication resources in the meta-training or pre-training phase: 3.2 x 10t communication rounds between the server and clients. Hence, our scheme is meta-trained over 8.0 x 10x episodes, taking 4 rounds in each episode. To construct each episode, the server selects K = 10 clients in the system for participation. We first consider a 5-way setup where classes randomly sampled from the train/test sets to construct the datasets of clients in each episode. This type of modeling reflects the practical federated learning setup where a large number of clients having different local data coexist in the system. 120 images are sampled from each class

---

Under review as a conference paper at ICLR 2021
Table I: Test accuracies after R = 3 communication rounds in a 5-way setup.
minilmageNNet
tiered
Methods
IID
Non-IID
IID
Non-11
FedAvg
35.44%
29.79%
40.98%
34.26%
Fine-tuning via FedAvg
57.93%
38.21%
60.69%
50.52%
Fine-tuning via one-shot FL (Guaa et al. 2019)
60.59%
36.75%
62.44%
50.26%
FRL: Linear classifier (Ours)
68.33%
58.18%
69.71%
61.56%
FRI: Distance-basee classifier (Ours)
72.37%
66.42%
74.51 %
68. 68.12%
FRI: Distance-haan basee classifier + GPAL (Ours)
73.71%
67.33%
75.32 %
68.81 %
75
Test accuracy
Test socuracy
65
Distanie,,,, GPAL
Fine-tuning one-shot Fire-tuning Feddvg
65
FRL: Distanca
Distance, GPAL
Fine-turing via one-shot Fine turing via FodAAg
50
45
FRL: Lirear
Distanco
-5
FRL: Linear
35
0.5
1.5
2.5
3
0.5
1.5
2
2.5
Communication rounds (metalpre-training phase)
x10*
Communication rounds (mstavpre-training) phase) x100
(a) IID scenario, minilmageNet
(b) NoD-IID scenario, minilmgeeeet
Figure 2: Test accuracy after R = 3 global rounds in the testing phase, with varying numbers of communication rounds in the meta-trainn phase (or pre-training phase).
and distributed to K = 10 clients depending on two data distribution setups: IID and non-IID. In the IID setup, the data samples from each class are equally distributed K 10 clients; each client has 12 samples for 5 classes, a total of 60 samples. In the non-Ill) setup, following the procedure of (McMahan et al., 2017), we first sort the 600 training samples of each episode by its category. We then divide the sorted data into 20 shards of size 30 and randomly allocate 2 shards to each client. Hence, no client would be given data corresponding to more than 2 distinct classes. For both IID and non-IID setups, each client uses one half of its data from each class as support samples, and the remaining half as query samples. In other words, in an IID setup, each client has 6 support samples and 6 query samples for each class. In the non- setup. the clients with 2 classes have 15 support samples and 15 query samples for each class, while the clients with 1 class have 30 support samples and 30 query samples for that class. For the one-shot FL method described above, we allow 20 clients and the server samples K = 10 of them to aggregate. In the actual deployment (testing) phase, the support set is utilized for R rounds of local updates and the server calculates the test accuracy with the global model/prototype and the gathered query sets of all clients. We averaged the test accuracies over 5.0 10 randomly sampled episodes in the testing phase.
Implementation details. For fair comparison, our method and other baselines share the same neural network architecture. The model follows the settings of (Vinyals et al.] (016), which contains consecutive x convolutional layers with 32 filters. Successively, each CNN output goes through ReL.U activation, batch normalization and 2 x 2 max pooling. We adopt the Adam optimizer as the meta-learner with a learning rate of 3 = 0.01 and an SGD optimizer as the learner with a learning rate of a 0.1. The meta-learning rate reduces by one-tenth after 2.0 x 10a rounds. We set the number of local epochs to E = 1. As mentioned, we do not see advantages in using the second derivatives in computing the gradient in Line 24 of Algorithm [ in the meta-updating process. Given the memory and computational overhead issues as well, we naturally disregard the second derivatives and apply first-order approximation.
Experimental results in 5-way setup. Table [ shows the test accuracies in 5-way setup. The model is meta-trained targeting R = 3 and tested after It = 3 rounds in the test phase. First, for both IID and non-IID scenarios, it can be seen that FedAvg yields significantly lower accuracy compared to others, since it uses a randomly initialized model for training. By pre-training the model for 3.2 10 communication rounds, we observe that FedAvg-based fine-tuning gives significant performance gains compared to naive application of FedAvg. The fine-tuning scheme based on one-shot federated learning shows further performance improvements in the IID setup. However, since K 10 clients are sampled from 20 clients for this ensemble method, there possibly exist some unseen classes when building the global model/prototype in the non-lID setup, which lowers the performance compared to fine-tuned FedAvg. Our few-round learning algorithm performs the best, with the distance-based classifier showing better accuracy compared to the linear classifier. It can be also seen that the performance of the global model can be further improved by global
7

---

Under review as a conference paper at ICLR 2021
Table 2: Test accuracies after A communication rounds in random-way (3~7) setup.
minilmageNet
Iaare
Methods
ITI
Non-IID
||
ITD
Non-IID
FedAvg
36.98%
31.32%
41 1155
35.34%
Fine-tuning via FedAvg
62.27%
53.04%
63.62%
51.11%
Fine-tuning via one-shot FL. Guua et al. 2019)
63.52%
51.92%
64.36%
49.49%
FRL: Linear classifier (Ours)
65.06%
53.51%
63.48%
54.87%
FRL:
Distance-based classifier (Ours)
73.06%
66.97%
72.36%
69.07%
FRL: Distance-based classifier GPAL (Ours)
74.32%
67.94%
73.41%
69.86%
Table 3: Test accuracies after I
communication round in 5-way setup.
minilmageNet
tieredImageNNtt
Methods
III
Non-IID
||
IID
Non-IID
FedAvg
31.64%
28.86%
36.14%
32.56%
Fine-tuning via FedAvg
50.58%
36.76%
51.42%
41.16%
Fine-tuning via one-shot FL (Guaa et al. 2019)
52.07%
32.05%
52.40%
40.74%
FRL: Linear classifier (Ours)
62.61% %
51.09%
64.52%
55.78%
FRL: Distance-based classifier (Ours)
72.10%
66.13%
74.37%
67.95%
FRL: Distance-based classifier GPAL (Ours)
72.58%
66.63%
74.69%
68.15%
prototype-assisted learning with the auxiliary loss. Fig. shows how the final test accuracy (after 3 fixed rounds) in the deployment phase increases the number of communication rounds in the meta-training (or pre- pre-training) phase grows. The overall results in Table ] and Fig. 2 confirm the advantage of exploiting meta-learning and global prototype-assie assisted learning ideas facilitate few- round federated learning.
Experimental results in a random-way setup. In Table 2 we provide test accuracies in a more general random-way setup. To construct each episode in the meta-training phase, 7 classes randomly and independently sampled from the train sets, where T follows a discrete uniform distri- bution in the range [3, 7]. The same procedure of random 7 sampling also applied during the test phase. As in the 5-way setup, we sample 120 images from each class to construct an episode, having a total of 1207 samples. In the IID setup, each client has 12 samples for classes. In the non-III setup, we again divide the sorted data into 20 shards of size 67 and randomly allocate 2 shards to each client. To meta-train the linear classifiers in this random-way setup, we fix the output size of last linear layer to 7 and exploit perceptron from the beginning, according to the selected value. The results are consistent with the one in the 5-way setup, confirming significant advantages of our few-round learning algorithm even in a more general setup.
Experimental results with mismatch on R. In Table 3 we show the results for mismatched R. The model is meta-trained targeting Rt = 3 as in Tables [ and 2 but the actual test accuracies are evaluated after R communication round in the test phase. Since the global model is obtained after only one global round, the accuracies are lower than in Table Overall, it can be seen that our few-round learning algorithm still powerful this mismatch scenario. Testing on mismatch with R = 2, as provided in Supplementary Materials, also shows consistent results.
Comparison with personalization scheme. We note that formulation targets creating global model while the previous works on federated meta-learning (Lin et al. 2020; Chen et al. 2018) aim at personalized local models. Given these different goals, non IID setup, our method can generally handle broader classes of data than existing personalization approaches. However, there is a simple way obtain global model based on these personalization models, in case need arises for globalized model -fter-the-fact. just run rounds of local updates and aggregations starting from the local models but using data now collected across interested clients. We were curious about how this globalized model would fare. In Supplementary Materials, we added experimental results for this scheme. A quick conclusion that the performance comparable to the best fine-tuning methods but lags well behind our methods targeting global model from the get-go.
CONCLUSION
We proposed a meta-learning strategy that enables few-round learning. Given set of clients with new tasks, our meta-trained model generalizes well, within only few communication rounds be-
8

---

Under review as a conference paper at ICLR 2021
tween the server and the clients. Extensive experimental results confirm the significant advantages of our method over different baselines both IID and non-lID data distribution setups.
REFERENCES
Keith Bonawitz, Vladimir Ivanov, Ben Kreuter, Antonio Marcedone, H Brendan McMahan, Sarvar Patel, Daniel Ramage, Aaron Segal, and Karn Seth. Practical secure aggregation for privacy- preserving machine learning. In Proceedings of the 2017 ACM SIGSAC Conference on Computer and Communications Security, pp. 1175-1191, 2017.
Keith Bonawitz, Hubert Eichner, Wolfgang Grieskamp, Dzmitry Huba, Alex Ingerman, Vladimir Ivanov, Chloe Kiddon, Jakub Konecny, Stefano Mazzocchi, H Brendan McMahan, et al. Towards federated learning at scale: System design. arXiv preprint arXiv:1902.01046, 2019.
Fei Chen, Mi Luo, Zhenhua Dong, Zhenguo Li, and Xiugiang He. Federated meta-learning with fast convergence and efficient communication. arXiv preprint arXiv:1802.07877, 2018.
Alireza Fallah, Aryan Mokhtari, and Asuman Ozdaglar. Personalized federated learning: A meta- learning approach. arXiv preprint arXiv:2002.07948. 2020.
Chelsea Finn, Pieter Abbeel, and Sergey Levine. Model-agnostic meta-leaming for fast adaptation of deep networks. In ICML, 2017.
Neel Guha, Ameet Talwalkar, and Virginia Smith. One-shot federated learning. WwXiv:1902.11172 2019.
arXiv preprint
Yihan Jiang, Jakub Konečný, Keith Rush, and Sreeram Kannan. Improving federated learning per- sonalization via model agnostic meta learning. arXiv preprint arXiv: /90::/9999//00000 /2488, 2019.
Anirudh Kasturi, Anish Reddy Ellore, and Chittaranjan Hota. Fusion learning: A one shot federated learning. In International Conference Computational Science, pp. 424 436. Springer, 2020.
Jakub Konecny, H. Brendan McMahan, Felix X. Yu, Ananda Theertha Suresh, and Dave Bacon. Federated learning: strategies for improving communication efficiency. In NIPS Workshop on Private Multi- Party Machine Learning, 2016.
Tian Li, Anit Kumar Sahu, Ameet Talwalkar, and Virginia Smith. Federated learning: Challenges, methods, and future directions. arXiv preprint arXiv: arXiv:1908. 11908.00877 2019.
Yann Lifchitz, Yannis Avrithis, Sylvaine Picard, and Andrei Bursuc. Dense classification and im- planting for few-shot learning. In Proceedings of the IEEE Conference on Computer Vision and Patlern Recognition, pp. 9258-9267, 2019.
Sen Lin, Guang Yang. and Junshan Zhang. A collaborative learning framework via federated meta- learning. arXiv preprint arXiv:2001.03229, 2020.
Brendan McMahan, Eider Moore, Daniel Ramage, Seth Hampson, and Blaise Aguera y Arcas. Communication--ffccienn learning of deep networks from decentralized data. In Artificial Intelli- gence and Statistics, pp. 1273-1282, 2017.
Sachin Ravi and Hugo Larochelle. Optimization as a model for few-shot learning. 2017.
Amirhossein Reisizadeh, Aryan Mokhtari, Hamed Hassani, Ali Jadbabaic, and Ramtin Pedarsani. Fedpaq: A communication--effiiiii federated learning method with periodic averaging and quan- tization. arXiv preprint arXiv: 1909. 13014, 2019.
Mengye Ren, Eleni Triantafillou, Sachin Ravi, Jake Snell, Kevin Swersky, Joshua B Tenenbaum, Hugo Larochelle, and Richard S Zemel. Meta-learning for semi superviid few-shot classifica- tion. In International Conference on Learning Representations, 2018.
Felix Sattler, Simon Wiedemann, Klaus-Robert Müller, and Wojeiech Samek. Robust and communication eeficiinnefi federated learning from non-iid data. JEEE transactions on neural ner- works and learning systems, 2019.

---

Under review as a conference paper at ICLR 2021
MyungJae Shin, Chihoon Hwang, Joongheon Kim, Jihong Park, Mehdi Bennis, and Seong-Lyum Kim. Xor mixup: Privacy- preseering data augmentation for one-shot federated learning. arXiv preprint arXhv:2006.05148, 2020.
Jake Snell, Kevin Swersky, and Richard Zemel. Prototypical networks for few-shot learning. In Advances in neural information processing systems, pp. 4077-4087, 2017.
Oriol Vinyals, Charles Blundell, Timothy Lillicrap, Daan Wierstra, et. Matching networks for one shot learning. Advances in neural information processing systems, pp. 3630-3638, 2016.
Yue Zhao, Meng Li, Liangzhen Lai, Naveen Suda, Damon Civin, and Vikas Chandra. Federated learning with non-iid data, arXiv preprint /86v:/806600082, 2018.
10

---

Under review as a conference paper at ICLR 2021
A ADDITIONAL EXPERIMENTS UNDER MISMATCH ON R
show additional experimental results mismatch scenario in the 5-way setup, where the model is meta- veta-trained targeting R = 3 but tested after only R = communication rounds in the deployment phase. Our few-round learning algorithm consistently achieves higher accuracies compared to other baselines in this mismatch scenario.
In Table A.
Table A.I: Meta-trained targeting R 3. Accuracy evaluated after 2 rounds a 5-way setup.
minilmmgeNee
tieredImageNeet
Methods
IDD
Non-III
IID Non-III>
FedAvg
33.93%
30.35%
39.14%
34.49%
Fine-tuning via FedAvg
55.37%
34.43%
57 57.80%
48.05%
Fine-tuning one-shot
57.71%
34.35%
59. 59.76%
46.97%
FRL: Linear classifier (Ours)
67.08%
54.70%
68.59%
60.38%
FRL: Distance- based classifier (Ours)
72.33%
66.28%
74.34%
68.04%
FRL: Distance-base classifier + GPAL (Ours)
73.51%
66.86%
74.97%
68.63%
B ADDITIONAL EXPERIMENTS WITH TARGET R =
While the results shown in the main manuscript utilized the model targeting = 3, here show results with target I = 2, in the same 5-way setup. The model is meta-trained with R = 2. The accuracies evaluated after R 2 communication rounds in Table and evaluated after R communication round in Table B.2 Overall results show that our few-round learning algorithm outperforms other baselines in this R case well.
Note that Table B. below and Table A.I above evaluate accuracies after R = 2 global rounds, while the models are meta-trained targeting R and results, we can say that meta-trann training using higher R does not provide performance advantage in the deployment (lesting) phase. Hence, given a constraint on the deployment time, there no need to perform "higher-round training", which saves the communication resources utilized in the meta-traini meta-training phase.
respectively. Comparing these
Table B.1: Meta-trained largeting Accuracy evaluated after 2 rounds in 5-way setup.
minilmageNet
tieredImageNet
Methods
IID
Non-IID
IID
Non-IID
FedAvg
33.93%
30.35%
39.14%
34.49%
Fine-tuning via FedAvg
57.83%
37.15%
58.61%
42.61%
Fine-tuning via one-shot FL
58.44%
37.05%
58.97%
40.81%
FRL: Linear classifier (Ours)
63.45%
57.11%
66.39%
61.29%
FRL: Distance- based classifier (Ours)
72.31%
66.39%
74.44%
68.02%
FRL:
Distance- based classifier + GPAL (Ours)
73.22%
67.11%
74.82%
68.53%
Table B.2: Meta-trained targeting I 2. Accuracy evaluated after R 1 round in 5-way setup.
minilmageNet
tieredlmageNet
Methods
IID
Non-
IID
Non-Ill
FedAvg
31.66 21.64%
28.86%
36.14%
32.56%
Fine-tuning via FedAvg
08.60%
36.44%
47.58%
35.89%
Fine-tuning via one-shot FL
48.69%
36.52%
48.16%
35.71%
FRI: Linear classifier (Ours)
60.71%
55.75%
63.99%
59.61%
FRL:: Distance- hassdd classifier (Ours)
72.25%
66.38%
74.33%
68.31%
FRL:: Distance- based classifier + GPAL (Ours)
72.63%
67.09%
74.56%
68.93%

---

Under review as a conference paper at ICLR 2021
Table C.I: Comparison with personalization scheme in 5-way setup. Meta-trained targeting ft 3, and tested after 3 rounds.
minilmageNet
tieredImageNet
Methods
IID
Non-IID
IID
Non-IID
Personalization: Linear Classifier
54.05%
54.05%
60.87%
50.21%
Personalization: Distance-bag based Classifier
61.69%
53.66%
64.78%
55.98%
FRL: Linear classifier (Qurs)
68.33%
58.18%
69.71 %
61.56%
FRT: Distance-based classifier (Ours)
72.37%
66.42%
74.51%
68. 12%
FRL: Distance-based classifier + GPAL (Ours)
73.71
67.33%
75.32
68.81 %
Table C.2: Comparison with personalization scheme in a random-way (3~7) setup. Meta-trained targeting
R 3, and tested after R = 3 rounds.
minilmageNet
tieredlmageNeet
Methods
Non-IID
IID
Non-IID
Personalization: Linear Classifier
53.51%
46.16%
59.89%
49.83%
Personalization: Distance-basse Classifier
62.44%
53.93%
62.28%
53.45%
FRL: Linear classifier (Ours)
65.06%
53.51%
63.48%
54.87%
FRL: Distance based classifier (Ours)
73.06%
66.97%
72.36%
69.07%
FRL: Distance-basee classifier + GPAL (Ours)
74.32%
67.94%
73.41 %
69.86%
C COMPARISON WITH THE PERSONALIZAATON SCHEME
In this section, we provide additional experimental results to compare our few-round learning algo- rithm with the personalization schemes (Lin et al.) 2020; Chen et al. 2018 For the personalization scheme, the clients perform local meta-updates with their query sets right after the local updates with the support sets, in the meta-training phase. For testing, local updates and aggregations are repeated for It global rounds to construct global model after-the-fact. Tables and |anddC.2 compare our scheme with the personalization scheme combined with global aggregation, and random- way (3~7) setup, respectively. The detailed settings exactly the same in the main manuscript. The personalization scheme combined with global aggregation achieves compa- rable performance with best fine-tune tnn-tuning methods in the main manuscript, but falls well below schemes geared to few-round FI..
a 5-way setup
D ADDITIONAL EXPERIMENTS WITH LESS DATA SAMPLES AT EACH CLIENT
So far, we sampled 120 images from each class to construct an episode. this section, we observe the effect of reducing the number of data samples in each client. Instead of sampling 120 images, we now sample 60 images from each class to construct an episode. In a 5-way setup, 60-5/1 5/10 30 samples allocated to each client. In the IID setup. the data samples from each class equally distributed to K = 10 clients; each client has samples for each classes, having a total of 30 samples. For each class, 3 samples as query samples. the non-lII setup, we again divide the sorted data into 20 shards of size 15 and randomly allocate 2 shards to each client.
utilized support samples and other 3 samples are utilized
Table D.I shows the test accuracies in this setup. Again we consider a 5-way setup, and the model meta-trained targeting R 3. The accuracies are evaluated after 3 rounds of federated learning. Since we utilize less data samples for training, the performances are degraded compared the results in the main manuscript. But, overall, the trend is consistent with the results we observed so far, confirming the advantage of our few-round learning algorithm utilizing meta-learning.
ADDITIONAL. EXPERIMENTS ON CIFAR-100
To confirm the applicability of our proposed scheme further, we provide additional experiments on CIFAR-106 100 in Table E.1 Similar minilmageNNt, we split 100 classes in CIFAR-100 into 64
12

---

Under review as a conference paper at ICLR 2021
Table D.I: Performance with less data samples at each client shots per class per client for IID compared our usual setup of shots this work) a 5- way setup. Meta-trained targeting 3, and tested after R rounds.
minilmageNee
tieredImageNet
Methods
ITD
Non-IID
IID
Non-IID
FedAvg
34.39%
29,00 29.08%
39.61% %
33.48%
Fine-tuning via FedAvg
57.70%
38.09%
60.08%
48.61%
Fine-tuning via one-shot FI.
60.36%
38.18%
61.63%
47.79%
FRL: Linear classifier (Ours)
65.46%
55.78%
67.32%
59.61%
FRL: Distance- based classifier (Ours)
70.04%
63.08%
71.96%
65.25%
FRL: Distance-based classifier + GPAL (Ours)
70.81%
63.48%
72.54%
65.67%
Table E.1: Test accuracies after R = 3 communication rounds in 5-way setup on CIFAR-100
CIFAR-100
Methods
IID
Non-IID
FedAvg
45.13%
37.50%
Fine-tuning via FedAvg
65.92%
41.02%
Fine-tuning one-shot FL
66.22%
36.53%
FRL: Linear classifier (Ours)
70.96%
58.09%
FRL: Distance-basse classifier (Ours)
80.14%
72.54%
FRL: Distance-based classifier GPAL (Ours)
80.35%
72.66%
training. 16 validation and 20 test classes. The results are consistent with the tables on other datasets, confirming the advantage of our approach.
ADDITIONAL EXPERIMENTS WITH A LARGER NUMBER OF CLIENTS
To demonstrate the scalability of our proposed method, we performed additional experiments with
K = 50 clients. Table F.1 shows the details, which indicates that our scheme outperforms other baselines in larger scale federated learning system.
Table F.1: Performance with K 50 clients. Accuracies obtained after R communication rounds in
5-way setup.
minilmageNet
Methods
IID
Non-IID
FedAvg
36.85%
30.75%
Fine-tuning via FedAvg
63.20%
36.09%
FRL: I Linear classifier (Ours)
70.01 %
63.88
FRL::
Distance-hased classifier (Ours)
73.89%
73.02%
FRL:: Distance-hased classifier + GPAL (Ours)
74.03%
73.22%
13


Reviews:
[{"review_id": "yMS551gAQQJ", "reviewer": "AnonReviewer4", "summary": "", "questions": "", "limitations": "", "rating": 4, "confidence": 4, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "\nThis paper studied the combination of federated learning tasks in a meta-learning setting. In particular, with the assistance of the pre-trained meta-model, the new FL model's training can be completed within limited communication rounds. It was inspired by the meta-learning method used in few-shot learning scenario. This paper proposed a few-round learning (FRL) algorithm and designed global prototype-assisted learning (GPAL) scheme to assist training. It is an interesting topic to combine meta-learning with federated learning. \n\nThe weaknesses of this paper are summarized below.\n\n1. The proposed method updates meta-model in each client. However, the meta-learning task consumes lots of computation resources and highly relies on the large number of classes. These make it hard to train a meta-model in a local client in a federated system. Although the setting sounds useful, it is hard to realize in real-world applications.\n\n2. This paper is relevant to two widely-known few-shot learning methods, MAML, and prototypical network. So, it is better to consider MAML+FL and/or ProtoNet+FL as baselines to make the proposed methods more convincing and prove the efficacy of the proposed loss functions.\n\n3. Given the complexity of the proposed algorithm and associated hyperparameters, the authors could anonymously release the source code in the reviewing stage. More details about the experimental platform used in this paper should be given. \n\n4. As illustrated in the Experimental setup on page 6, the meta/pre-training phase needs a large number of communication rounds. Is it appropriate for the bandwidth-limited or time-sensitive applications? Will this be a distracter in few-round learning scenarios?\n\n5. For the 5-way setup in Table 1, there are 5 classes are randomly sampled from the dataset in each episode, which means that all the clients contain all the training classes, 64 classes for miniImageNet and 351 classes for tieredImageNet, locally. This is impractical because most local clients only have limited information to share.\n\n6. The representation of trainable parameters in Algorithm 1 is a little bit confusing. For example, \\theta and \\phi are actually the same parameters. The only difference between them is that \\theta is updated during local update using the support set, while \\phi is updated during local meta-update using query set. Since the algorithm is an important part of this paper, the definition and use of these parameters should be much clearer. If possible, the authors can add a detailed interpretation of these two parameters.\n\n", "extra_scores": {}, "extra_text": {}}, {"review_id": "oAD9a8mmDe0", "reviewer": "AnonReviewer1", "summary": "", "questions": "", "limitations": "", "rating": 5, "confidence": 4, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "## Summary\n\nThis paper proposes a new paradigm to train federated learning models. In particular, following the spirit of meta-learning for few-shot learning, the authors propose to meta-train an initial model so that starting from this point, only $R$ (eg, 3) rounds of FL are needed to produce a satisfying test accuracy.\n\n## Pros\n1. The authors made significant efforts in designing the meta-learning strategy for few-round FL.\n2. The proposed algorithm has the potential to redefine FL training paradigm. But there should be more validations. My questions and concerns are stated in the next section.\n\n## Cons\nThe major concern I have is about the way they construct the dataset and evaluate the algorithm. The training task the authors selected is more like a meta-learning standard setting and is not common in federated learning. So I doubt its performance in realistic FL settings. It would be great if the authors can evaluate their algorithm in a standard FL dataset, otherwise it is not convincing.\n1. When constructing the meta-learning datasets for each episode, the authors sample several classes from the whole dataset  and then simulate 10 clients based on the selected samples. However, in FL setting, this is infeasible, as the server cannot access the whole dataset. The authors should describe how to construct the meta-learning procedure given hundreds or even thousands of clients without accessing their local data. For example, Shakespeare dataset has 715 train clients and 715 test clients. How to construct the meta-learning procedure from this decentralized data and how the algorithm performs are unclear.\n2. The scale of FL is relatively small. At each episode, there is only 10 clients. However, in practical on-device FL, there can be thousands of clients for training and testing. For example, in [1], StackOverflow has 342,477 training clients and 204,088 test clients. Even EMNIST dataset has 3400 test clients. The performance of the proposed algorithm is unclear in these realistic large-scale FL problems.\n3. The meta-train algorithm require the computation of full-batch loss at each round, which consumes more computational resources than vanilla FedAvg. The authors are supposed to discuss this additional overhead.\n\n## Post-rebuttal comments\nThanks the authors for the response! I've read it and other reviewers' comments. I feel the authors didn't directly answer my questions and just reiterate what they have in the paper. Unfortunately, it is still unclear to me how to perform meta-training on standard FL training tasks, for example, shakespeare in [1]. In this training task, there're total 700+ clients. Does that mean in the meta-training phase, we need to sample 700+ clients for each episode? How to construct this meta-train dataset from a standard federated dataset?\n\n[1] Reddi et al. Adaptive Federated Optimization. 2020", "extra_scores": {}, "extra_text": {}}, {"review_id": "bttQv-2-lq", "reviewer": "AnonReviewer3", "summary": "", "questions": "", "limitations": "", "rating": 4, "confidence": 5, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "1. Strength:\n\nTargeting an important problem of FL: reducing the communication cost.\n\n\n2. Weakness:\n\nThis work simply applies the meta-learning method into the federated learning setting. I can’t see any technical contribution, either in the meta-learning perspective or the federated perspective. The experimental results are not convincing because the data partition is not for federated learning. Reusing data partition in a meta-learning context is unrealistic for a federated learning setting. \n\nThe title is misleading or over-claimed. Only the adaptation phase costs a few rounds, but the communication cost of the meta-training phase is still high.\n\nThe non-IID partition is unrealistic. The authors simply reuse the dataset partitions used in the meta-learning context, which is not a real federated setting. Or in other words, the proposed method can only work in the distribution which is similar to the meta-learning setting.\n\nSome meta earning-related benefits are intertwined with reducing communication costs. For example, the author claimed the proposed method has better generalization ability, however, this is from the contribution of the meta-learning. More importantly, this property can only be obvious when the data distribution cross-clients meet the assumption in the context of meta-learning.\n\nThe comparison is unfair to FedAvg. At least, we should let FedAvg use the same clients and dataset resources as those used in Meta-Training and Few-Rounds adaptation.\n\n“Episodic training” is a term from meta-learning. I suggest the authors introduce meta-learning and its advantage first in the Introduction.\n\nFew-shot FL-related works are not fully covered. Several recent published knowledge distillation-based few-shot FL should be discussed. \n\n\n\n3. Overall Rating\n\nI tend to clearly reject this paper because: 1) the proposed framework is a simple combination of meta-learning and federated learning. I cannot see any technical contribution. 2) Claiming the few round adaptations can reduce communication costs for federated learning is misleading, since the meta-training phase is also expensive. 3) the data partition is directly borrowed from meta-learning, which is unrealistic in federated learning.\n\n---------after rebuttal--------\n\nThe rebuttal does not convince me with evidence, thus I keep my overall rating. I hope the author can obviously compare the total cost of meta-learning phase plus FL fine-tuning phase with other baselines. \n\n", "extra_scores": {}, "extra_text": {}}, {"review_id": "M38KbGZ4WZw", "reviewer": "AnonReviewer2", "summary": "", "questions": "", "limitations": "", "rating": 3, "confidence": 5, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "The paper is to train a meta-model in a small number of selected nodes in a federated learning environment, and then use the meta-model to assist the federated learning in reducing the communication rounds. It is basically a federated version of a prototypical network.\n\nThe proposed method relies on a strong assumption that there is a meta-training environment in federated learning. It is not a standard FL setting. Moreover, given the assistance of the meta-model, there is no guarantee that the federated learning environment will converge in a few-round.\n\nThe major technique contribution of the proposed method is how to meta-train a global model in a federated setting. In particular, it adapts the prototypical network to fit the federated setting. It is unclear how the proposed method provides any theoretical contribution rather than applied research. \n\nIn the experiment, one dataset is not enough to support the effectiveness of the proposed method. \nMore federated learning-related benchmark datasets should be discussed, e.g., FeMNIST, Shakespeare texts, CIFAR, and FeCelebA. \n\nIn particular, the proposed two-stage procedure is equivalent to: learn a global model in a standard FL setting, and then conduct personalized deployment for each device or a specific group of devices. Therefore, in the experiment part, the authors need to add more baseline methods, for example, some personalized federated learning method should be selected as baseline methods.\n\nTHE MAJOR CONCERN: In Algorithm 1, lines 16 and 18 are a federated aggregation-based updating, and line 24 is a prototypical-based meta learner updating. These two updating methods are inconsistent which are to optimize different objectives, and the authors should give an overall loss to unify the updating steps rather than force two kinds of updating into one framework.\n\nTypo: \n“Metra-training” in Figure 1.", "extra_scores": {}, "extra_text": {}}]

Author rebuttal:

Meta-review: This paper proposes a meta-learning based few-shot federated learning approach to reduce the communication overhead incurred in aggregating model updates. The use of meta-learning also gives some generalization benefits. The reviewers think that the paper has the following main issues (see reviews for more details):
* Limited technical novelty - the paper seems to simply combine meta-learning with federated learning
* Not clear whether the communication overhead is actually reduced because the meta-learning phase can require significant communication and computation.
* The experimental evaluation, in particular, the data distribution, could have been more realistic.

I hope that the authors can use the reviewers' feedback to improve the paper and resubmit to a future venue.


Decision: Reject