# On-the-fly Resource-Aware Model Aggregation for Federated Learning in
Heterogeneous Edge

Hung T. Nguyen1, Roberto Morabito1, Kwang Taik Kim2, and Mung Chiang2
1Princeton University, 2Purdue University
Email: 1{hn4<EMAIL_ADDRESS>2{kimkt<EMAIL_ADDRESS>
###### Abstract

Edge computing has revolutionized the world of mobile and wireless networks
world thanks to its flexible, secure, and performing characteristics. Lately,
we have witnessed the increasing use of it to make more performing the
deployment of machine learning (ML) techniques such as federated learning
(FL). FL was debuted to improve communication efficiency compared to
conventional distributed machine learning (ML). The original FL assumes a
central aggregation server to aggregate locally optimized parameters and might
bring reliability and latency issues. In this paper, we conduct an in-depth
study of strategies to replace this central server by a _flying master_ that
is dynamically selected based on the current participants and/or available
resources at every FL round of optimization. Specifically, we compare
different metrics to select this flying master and assess consensus algorithms
to perform the selection. Our results demonstrate a significant reduction of
runtime using our flying master FL framework compared to the original FL from
measurements results conducted in our EdgeAI testbed and over real 5G networks
using an operational edge testbed.

###### Index Terms:

Edge Computing, Federated Learning

##  I Introduction

In the last few years, running network services or applications at the network
edge became more demanded as it can provide easier access and help overcome
the latency, reliability, bandwidth, or privacy issues linked to a cloud-based
system. Edge computing also became a key enabler for the deployment of
performing ML services. There is an increasing demand for running ML inference
tasks at the edge, as this allows to cope with the strict latency requirements
that emerging ML applications require in the context of massive and critical
machine-type communications (MTC) and ultra-reliable low latency
communications (URLLC). The more considerable interest towards edge-based ML
services has also been boosted by the increasing availability of dedicated ML
hardware and software tools that have been specifically designed for being
suitable with the often-smaller computational capabilities of the edge. The
more extensive ML tools availability has also led to increasing interest in
the possibility of executing ML training tasks at the edge. Empowering the
edge with ML training capabilities can tailor those training techniques
initially designed to rely on cloud services.

Federated learning (FL) [1, 2, 3, 4, 5, 6] (and references therein) is
recently introduced as a prime ML framework for learning on edge, on local
devices without sharing private data, while still benefiting from the massive
and diverse available data from the federation of devices as a typical
decentralized ML. The principal design of FL includes a network of devices
capable of training an ML model on local data and a central aggregation
server, which routinely aggregates local models from a small set of devices to
form a global model. This centralized aggregation server poses some
significant issues as it is the central point of failure: _(i)_ if the server
is unavailable due to a networking problem, e.g., under cyber-attack and/or
power failure, the learning process stops and even needs to restart all over;
and _(ii)_ the communication cost may be extremely high in practical
applications on the Internet.

In this paper, we introduce a more communication-efficient FL framework to
address the cumbersome centralized server setting. Earlier efforts in this
direction, e.g., [7, 8, 9, 10], employ blockchain to remove the server
component. However, the employment of blockchain introduces extensive
communication costs and delay due to its characteristics, rendering this
approach likely unsuitable for many applications. Differently, our main idea
is to dynamically select the best master node _on the fly_ to perform model
aggregation either among the participants or the entire network at every round
of FL optimization. This flying master111In our context, the term ‘flying
master’ refers to the dynamic aggregation node and not unmanned aerial vehicle
(UAV) in the literature. node selection is optimized based on communication
cost and available computing resources with respect to the particular set of
participants in that round. Thus, it will provide a much lower delay for both
communication and aggregation.

We perform extensive experiments (Section III) on our EdgeAI testbed, which
consists of heterogeneous edge devices to quantify the computational resources
needed for running FL tasks, and real-world deployment of 5G testbeds [11] to
measure communication latency over a fully operating end-to-end commercial 5G
network. To pick the master node on the fly (Section IV-A), we investigate
consensus algorithms using a specified metric, termed _Stress_ , measuring the
suitability of each candidate node (Section IV-B). We propose to use two
algorithms based on Gossip protocol and proof-of-work consensus and perform
experiments to demonstrate the better efficiency of the approaches (Section
IV-B). Measuring the runtime it takes to perform a number of FL rounds when
each of the master node selection algorithms is used in our framework (Section
V) offers several key findings: _(i)_ because fixed servers do not consider
the locations of the participating devices, the central aggregation server
model requires much more time than other master node selection algorithms;
_(ii)_ master selection algorithms based on least stress with gossip protocols
and proof-of-work require mostly the same amount of runtime as the optimal
selections for the same number of FL rounds because the gossip algorithm and
proof-of-work puzzles are very fast compared to the local optimization time;
and _(iii)_ for a larger number of selected devices participating in an FL
round, there is no visible difference in time consumption between the group
that chooses the master among participants and the group that chooses from all
devices in the network.

##  II Preliminaries

We describe the canonical FL setting with a fixed server for aggregations of
local models. In the FL setting, we have a network of $N$ devices indexed from
1 to $N$. Device $i$ possesses a local dataset $\mathcal{D}_{i}$ that can be
used to optimize a machine learning model locally. We wish to learn a model
$M$ with parameter set $\mathbf{w}$ using the available data in all the
devices in a distributed manner without any device sharing its data. Hence,
the optimization problem is defined as follows:
$\min_{\mathbf{w}}f(\mathbf{w})=\min_{\mathbf{w}}\frac{1}{N}\sum_{k=1}^{N}f_{k}(\mathbf{w})$,
where $f(\mathbf{w})$ and $f_{i}\mathbf{w})$ are global and local cost
functions. The local cost $f_{k}(\mathbf{w})$ depends on its local dataset
$\mathcal{D}_{k}$, e.g.,
$f_{k}(\mathbf{w})=\sum_{(x,y)\in\mathcal{D}_{k}}f_{k}(\mathbf{w},(x,y))$,
where $(x,y)$ is a local data point.

In the original FL setting, there is a central server $\mathbb{S}{}$ in the
network to perform aggregation of local models, i.e., aggregating locally
updated parameters from a set of devices. A typical FL algorithm unrolls in
$T$ rounds of communication and computation as described in Algorithm 1.

Algorithm 1 FL algorithm with a central aggregation server

Input: Number of participants $K$, number of rounds $T$
Output: Optimized model parameters $\mathbf{w}^{T}$

1:Initialize $\mathbf{w}^{0}$

2:for $t=0,\dots,T-1$ do

3: $\mathbb{S}{}$ samples a set $\mathcal{S}_{t}$ of $K$ devices

4: $\mathbb{S}{}$ sends $\mathbf{w}^{t}$ to all devices $k\in\mathcal{S}_{t}$

5: $\mathbf{w}^{t+1}=$ FL_ROUND($\mathbb{S},\mathbf{w}^{t},\mathcal{S}_{t}$)

6:end for

7:procedure FL_ROUND($\mathbb{S}$, $\mathbf{w}^{t},\mathcal{S}_{t}$):

8: Each device $k\in\mathcal{S}_{t}$ performs local optimization from
$\mathbf{w}^{t}$ to obtain $\mathbf{w}^{\prime}_{k}$ using its own dataset
$\mathcal{D}_{k}$

9: Each device $k\in\mathcal{S}_{t}$ sends $\mathbf{w}^{t+1}_{k}$ back to
$\mathbb{S}{}$

10: $\mathbb{S}{}$ aggregates $\mathbf{w}^{t+1}_{k},\forall
k\in\mathcal{S}_{t}$ to form $\mathbf{w}^{t+1}$

11: return $\mathbf{w}^{t+1}$

12:end procedure

In round $t$, the central server first selects a small set $\mathcal{S}_{t}$
of $K$ devices and distributes the current model $\mathbf{w}^{t}$ to those
selected devices (Lines 3, 7). Then, each selected device performs local
optimization, e.g., commonly Stochastic Gradient Descent (SGD), starting from
the received model parameters $\mathbf{w}^{t}$ and produces an updated
parameter set $\mathbf{w}_{k}^{t+1}$. These parameters
$\mathbf{w}_{k}^{t+1},\forall k\in\mathcal{S}_{t}$ are sent back to the
central server to be aggregated and form a new model with parameter set
$\mathbf{w}^{t+1}$.

A good example of the FL algorithm is FedAvg[1], which is the first to propose
FL and creates an enormous amount of follow-up works on this problem. FedAvg
uses uniform sampling to select a set of participants in each round and
employs a small number of SGD steps for local optimization. Importantly,
FedAvg performs exceptionally well, requiring only a small number of
participants in each round, e.g., $K=10$, in a network of thousand devices, in
comparison to the case where all the data are located in a single machine. In
this work, we concentrate on these settings of random device selection at each
round and SGD as local optimizer. Other settings in federated learning (see
[4]), e.g., full participation, smart device selection in each round, or
different local optimizer, are feasible and left for future investigations.

##  III Measurement Methodology

We describe our experimental setup for computation and communication latency
evaluations in our EdgeAI testbed and over operational 5G cellular networks,
respectively.

###  III-A EdgeAI Testbed

Our EdgeAI testbed (Fig. 1) introduces edge devices’ heterogeneity by using
three distinct types of AI accelerators, such as Intel Movidius Myriad X VPU,
Google Edge TPU, and NVIDIA 128-core Maxwell GPU. The three systems-on-chip
are hosted in three different Single-Board Computers (SBCs): UP Squared AI
Edge, Coral Dev Board, and NVIDIA Jetson Nano, respectively. Fig. 2 summarizes
the other hardware characteristics of the devices. It can be noticed how the
SBCs have heterogeneous features also from CPU, memory RAM, and storage
perspectives.

Figure 1: EdgeAI testbed setup. Figure 2: EdgeAI testbed devices’ hardware
features.

###  III-B 5G Testbed

####  III-B1 Measurement Setup

We utilize a fully operational end-to-end 5G network testbed in Indy 5G Zone
[11] to measure the impact of various realistic radio propagation and wireline
backhaul in commercial 5G networks. The testbed consists of 5G gNB operating
at 39GHz sponsored by AT&T. The architecture adopts 3GPP NSA Option 3, where
UE is anchored to LTE core network via existing LTE/EPC control plane. Our
user equipment (UE) is a Samsung Galaxy S20 Ultra 5G (Qualcomm Snapdragon 865
[12]). We use a server in Utah from Cloud Lab [13] and connect it through a
public IP address for experiments. We measure a TCP congestion control
algorithm’s latency in the Linux kernel module over a 5G network by setting up
a 5G phone as a TCP receiver.

####  III-B2 Data Collection and Processing

We use iperf3 [14] to generate TCP traffic and RTT as a key communication
latency metric. The first 10 seconds of each experiment period are excluded to
reduce the starting effect when measuring RTT. We run iperf3 for 70 seconds
using a congestion control algorithm, ExLL [15]. We repeated this experiment
five times.

##  IV Flying Master FL Framework

In this section, we introduce our flying master FL framework. In a nutshell,
instead of having a fixed centralized aggregation server, the participants in
each round will pick their master node based on some criterion, which is the
most suitable regarding communication cost and computation capacity. In
effect, this will reduce the time it takes for every round since, given all
the information of current participants, we can find a much better candidate
than a predefined server in the original FL setting.

In the following subsections, we describe our general framework, discuss
criteria to select the most suitable master node, and then investigate
algorithms to perform the selection in different scenarios of security/privacy
concerns.

###  IV-A General Framework

Our general flying master FL framework is described in detail in Algorithm 2.

Algorithm 2 Flying master FL General Framework

Input: $K$, $T$
Output: Optimized model parameters $\mathbf{w}^{T}$

1:Initialize $\mathbf{w}^{0}$

2:Set $\mathbb{S}_{0}$ to an initial master node

3:for $t=0,\dots,T-1$ do

4: $\mathbb{S}_{t}$ samples a set $\mathcal{S}_{t}$ of $K$ devices

5: $\mathbb{S}_{t}$ sends $\mathbf{w}^{t}$ to all devices
$k\in\mathcal{S}_{t}$

6: A new flying master $\mathbb{S}_{t+1}$ is selected based on
$\mathcal{S}_{t}$ $\triangleright$ by a master selection algorithm discussed
in the next subsection

7: $\mathbf{w}^{t+1}=$
FL_ROUND($\mathbb{S}_{t+1},\mathbf{w}^{t},\mathcal{S}_{t}$) $\triangleright$
as in Alg. 1

8:end for

Here a new master node is dynamically selected at every round of optimization
with respect to the particular set $\mathcal{S}_{t}$ of participants (Line 5).
This master node selection algorithm may depend on different criteria and will
be discussed in the subsequent subsection. In round $t$, given a new master
node $\mathbb{S}_{t+1}$, the following steps are similar to the FL algorithm
with a central server (Line 6). The initial master node $\mathbb{S}_{0}$ can
be one initiating the learning process (Line 2).

Our framework’s special case is the original FL algorithm with a central
aggregation server when the master node selection algorithm is to return a
predefined $\mathbb{S}$. Thus, the flying master FL framework is a strict
generalization of the original FL algorithms and provides more flexibility to
improve its performance in latency or convergence time.

###  IV-B Master Selection Algorithms

The selection of a flying master node in each round can be based on different
criteria to minimize latency. Each criterion may also be implemented by
different algorithms when security/privacy is of paramount concern. We
investigate and compare the following criteria:

  * •

Random selection: This selects a node uniformly at random among the $K$
participants or all $N$ devices, denoted by Random_K and Random_N,
respectively.

  * •

Least distance: This criterion finds the node with the smallest sum of
distances between $K$ participants and that node. Intuitively, this smallest
distance node has the least communication delay to the participants. Here
distances can be estimated based on coordinates of devices or communication
latency. We also have two versions, Least_distance_K and Least_distance_N, to
represent considerations among $K$ participants and all $N$ devices.

  * •

Least stress: Taking into account how much resources are available at the
nodes or their stress levels, we consider criteria based on the device’s
stress, namely Least_stress_K and Least_stress_N, with the philosophy that the
less stress a device has, the more suitable the device is to serve as flying
master. This stress metric reflects the amount of used resources, including
CPU, memory, network bandwidth, and is calculated as follows:

$\displaystyle\mathsf{Stress}=\frac{1}{\mathsf{CPU}}\times\frac{1}{\mathsf{MEM}}\times\frac{1}{\mathsf{NET}},$
(1)

where $\mathsf{CPU}$ measures CPU speed (GHz), $\mathsf{MEM}$ is for available
memory (GB), and $\mathsf{NET}$ assesses available network bandwidth (MB/s).

The last two criteria require computation at all the candidate nodes and
possibly private information exchanges between them to pick the most suitable
node to be the flying master. Thus, this selection leads to a consensus
problem that involves all the candidate nodes to agree on a master with the
smallest metric. We discuss two approaches to deal with our consensus problem:
Gossip protocol and Proof-of-work.

####  IV-B1 Gossip Protocol based Flying Master Selection

Gossip protocols can be typically used for different purposes, including
cluster membership identification, cluster’s node failure detection, and event
broadcast [16], with minimal bandwidth and latency overhead [17]. Their
characteristics and peer-to-peer design make them very suitable for
distributed systems that require high scalability and reliability for system
information sharing. We take advantage of this gossip-based approach for
sharing the stress metric associated with each candidate for master selection
during each FL round. In particular, benefiting from the event-based broadcast
nature of this protocol, similarly to the Max-consensus approach in [18], the
Flying Master Selection is performed in the following steps:

  * •

After a gossip interval, e.g., 10ms, a node k wakes up.

  * •

Node k broadcasts its current least stress value to all the nodes in the
candidate set ($\mathcal{S}^{t}$ at round $t$ or all $N$ nodes).

  * •

Each node updates the least stress by taking minimum.

In the end, every node knows which node has the least stress.

####  IV-B2 Proof-of-Work-based Flying Master Selection

The issue with using gossip protocol is that the devices have to share
information about their resources, which may not be desirable given growing
concerns about unforeseeable security and privacy problems. We describe the
second approach of using proof-of-work to perform consensus and indirectly
evaluating the least distance and least stress criteria mentioned previously.
It offers a nice property that devices do not share private information and
fits the FL’s privacy-preserving requirement. However, solving proof-of-work
puzzles requires more energy from participating devices; thus, there is a
trade-off between these approaches’ security and energy usage.

Proof-of-work[19, 20, 21] involves a moderately hard but not intractable
puzzle, e.g., hash inversion, usually with a parameter to control the hardness
translating to the time it takes to solve the puzzle. A certain amount of
computation is required to find a solution to the puzzle; however, it is
effortless to verify that a solution is valid [22]. Thus, the more
computational resources a device has, the faster it will be able to find a
solution. In our framework, we use this property to determine which device has
the most computational resources available. Thus, it is more suitable to
become the flying master for the current round. Additionally, to account for
the communication capacity, a device needs to send the solution to every
participant to verify after solving the puzzle. Once all these are done, the
node will finally become the new master node. As a result, this proof-of-work
approach quantifies both computation and communication resources as a
combination of least distance and least stress criteria.

Algorithm 3 Proof-of-work based flying master selection

Input: A set of devices $\mathcal{S}$, proof-of-work puzzle $\mathfrak{p}$
Output: Flying master node $\mathbb{S}$

1:for all $k\in\mathcal{S}$ in parallel do

2: $k$ runs Solve($\mathfrak{p}$) and Verify($\mathfrak{p}$) in parallel

3:end for

4:procedure Solve($\mathfrak{p}$)

5: $k$ attempts to find a solution $\mathfrak{s}$ of $\mathfrak{p}$

6: $k$ sends its’ id and solution $\mathfrak{s}$ to other devices

7: if $k$ receives verified from all other devices then

8: $k$ declares to be the new flying master

9: end if

10:end procedure

11:procedure Verify($\mathfrak{p}$)

12: if received id and solution $\mathfrak{s}$ from device $k^{\prime}$ then

13: Verify $\mathfrak{s}$ along with id of $k^{\prime}$ is valid

14: if Verification is successful then

15: $k$ sends message Verified back to $k^{\prime}$

16: end if

17: end if

18: if Observe master declaration from a verified $k^{\prime}$ then

19: Halt both Solve($\mathfrak{p}$) and Verify($\mathfrak{p}$) threads

20: end if

21:end procedure

The details of our proof-of-work-based master selection algorithm are provided
in Algorithm 3 and performed in every FL round. A puzzle $\mathfrak{p}$ is
created uniquely for each round and each device and can be constructed from
the information of current model parameters, round index, and device’s id.
Each device $k$ in parallel attempts to find a solution and verifies solutions
from other devices (Line 2). If $k$ finds a solution $\mathfrak{s}$ before the
master node has been declared, it will send the solution along with its id to
all others to verify (Lines 5, 6). Then, if all other devices verify its
solution and send back all verified messages, $k$ declares to be the new
master node (Lines 7, 8). During solving the puzzle, each device $k$ also
engages in verifying other solutions if it receives a request (Lines 12-17).
All the devices will stop both finding and verifying whenever a device
declares to be the new master (Lines 18-20). Note that this new master node
must be already verified by every node (Line 18). Depending on the set
$\mathcal{S}$ to include only current participants or all devices in the
network, we term the respective selection algorithms POW_K and POW_N in the
following evaluations.

##  V Numerical Evaluations

We evaluate our framework with different settings of master node selection
criteria and algorithms, including the original central aggregation server
setting, using our Edge AI and 5G testbeds described in Section III.

Figure 3: The PDF of measured latencies over a 5G network between a 5G device
and a cloud server, shown with the best-fitting distributions. In many cases
we examine, the Generalized Extreme Value distribution is the best fit out of
20 common statistical distributions.

(a) $K=1$

(b) $K=5$

(c) $K=10$

(d) $K=50$

Figure 4: Wall-clock time vs. number of rounds for $N=100$ and 2 types of
devices in the network.

(a) $K=1$

(b) $K=5$

(c) $K=10$

(d) $K=50$

Figure 5: Wall-clock time vs. number of rounds for $N=1000$ and 2 types of
devices in the network.

(a) $K=1$

(b) $K=5$

(c) $K=10$

(d) $K=50$

Figure 6: Wall-clock time vs. number of rounds for $N=100$ and 4 types of
devices in the network.

(a) $K=1$

(b) $K=5$

(c) $K=10$

(d) $K=50$

Figure 7: Wall-clock time vs. number of rounds for $N=1000$ and 4 types of
devices in the network.

###  V-A Settings

ML Model settings. For the learning task, we choose the textbook handwritten
digit recognition task on the MNIST dataset [23] with 60K training images of
$28\times 28$ pixels and ten labels from 0 to 9. We consider a 2-layer neural
network with a sigmoid activation function in each layer and the hidden layer
having a size of 64. The common multi-class cross-entropy loss is applied. For
local optimization, we use mini-batch SGD with a batch size of 128. Since our
framework is general, the model choices and optimization method are
representatives, and the results apply straightforwardly to other settings of
ML models and local optimizations.

Network settings. We examine various aspects of the network in use:

  * •

Network size ranges from 100 to 1000, resembling small to moderately sized
networks. The number of participants in each round is in a typical range
$[1:50]$.

  * •

Device heterogeneity: Since we have five different devices operating in our
EdgeAI testbed (Fig.1), we consider two scenarios with, respectively, two and
four different types of devices running concurrently. Each device is randomly
assigned to one of the available types. We also simulate different stress
levels for each device by putting workloads to occupy 25%, 50%, and 75% of
total resources, i.e., CPU, memory, and network bandwidth. When a device
participates in a round of optimization, a stress level is randomly drawn
uniformly.

  * •

Communication latency: Since all of our devices in the EdgeAI testbed are
placed in the same location, we need to simulate the latency of sending model
parameters between devices. We first embed all of them in a 2d plane with
coordinates randomly generated in the range $[0,1000]$ and use the distance
between two devices to measure the expected latency. An individual
transmission’s actual latency is drawn from a distribution with the mean value
being the expected latency. To determine which distribution to use, we measure
latency between a 5G device and a cloud server over the 5G commercial network
described in Section III-B and find the best-fitting distributions to
experimental latency values. We observe the best fit of a Generalized Extreme
Value distribution with parameters of shape $0.7367$ and scale $2.0676$ to
communication latencies, as shown in Figure 3. In our experiments, we use the
same values of shape and scale but different location values depending on the
distances. Note that the network is fully connected.

###  V-B Results

We measure the time it takes to perform a number of FL rounds when each of the
master node selection algorithms is used in our framework. Time is wall-clock
and includes both communication and computation times. Here we only measure
the time and not the performance because, with the same number of rounds, the
performance would be precisely the same for all master node selection
algorithms. We also include the time it takes for the optimal master node
selections, denoted by Optimal_K and Optimal_N, respectively, which
essentially try every candidate node and pick the one with the least amount of
time at each FL round. Our results are demonstrated in Figures 4, 5, 6, and 7.
The Fixed curves refer to the central server setting where the fixed server is
randomly chosen within the network only for aggregation.

Comparison to the (fixed) central server setting: Our first observation is
that the central aggregation server setting requires substantially more time
than other master node selection algorithms. For example, it takes up to 4
times more than the Optimal_N, Least_stress_N, and POW_N. This difference gets
more prominent as the number of participants in an FL round becomes smaller as
the fixed server does not consider the locations of participating devices. The
group of random master node selections requires marginally less time than the
fixed server setting. However, they are still far from optimal for the same
reason as for the fixed server.

Comparison to the optimal selections: The second important observation is that
master selection algorithms based on least stress with gossip protocol and
proof-of-work require mostly the same amount of runtime as the optimal
selections for the same number of FL rounds. Particularly, time of
Least_stress_K and POW_K are similar to that of Optimal_K. Least_stress_N and
POW_N are similar to Optimal_N. This is because both the gossip algorithm and
proof-of-work puzzle are swift, i.e., a few seconds for a run [17, 22],
compared to the local optimization time. Furthermore, for $K\geq 5$, there is
no visible difference in time consumption between the group that selects
master among $K$ participants and the group that selects among all $N$ devices
in the network.

Comparison between different experimental settings: We also observe an
interesting pattern that, as the number of participants $K$ becomes larger,
the difference gap between the least and most time-consuming approaches gets
smaller. This pattern is intuitive following the law of large numbers since
participants are drawn randomly in the network. On another dimension, as the
size of network $N$ grows from 100 to 1000, the time each approach takes to
perform the same number of FL rounds gets smaller, possibly due to denser
network and, thus, the distance between two random devices is lesser. One last
thing to note is when the number of device types increases from two (Figures
4, 5) to four - more diverse environments (Figures 6, 7), all the curves
exhibit smooth increment of time as the optimization progresses.

##  VI Concluding Remarks

We proposed to select an aggregation server dynamically, termed _flying
master_ , at each round of optimization in federated learning, compared
different metrics to determine the master node, and assessed algorithms to
perform the selections. Our experiments on real-world EdgeAI and 5G Testbeds
show a significant reduction in runtime when our algorithms are employed,
compared to the original FL setting.

## References

  * [1] B. McMahan and et al., “Communication-efficient learning of deep networks from decentralized data,” in _Artificial Intelligence and Statistics_. PMLR, 2017, pp. 1273–1282.
  * [2] T. Li and et al., “Federated learning: Challenges, methods, and future directions,” _IEEE Signal Processing Magazine_ , vol. 37, no. 3, pp. 50–60, 2020.
  * [3] S. Wang and et al., “Adaptive federated learning in resource constrained edge computing systems,” _IEEE Journal on Selected Areas in Communications_ , vol. 37, no. 6, pp. 1205–1221, 2019.
  * [4] H. B. McMahan and et al., “Advances and open problems in federated learning,” _Foundations and Trends® in Machine Learning_ , vol. 14, no. 1, 2021.
  * [5] S. Niknam and et al., “Federated learning for wireless communications: Motivation, opportunities, and challenges,” _IEEE Communications Magazine_ , vol. 58, no. 6, pp. 46–51, 2020.
  * [6] H. T. Nguyen and et al., “Fast-convergent federated learning,” _IEEE Journal on Selected Areas in Communications_ , vol. 39, no. 1, pp. 201–218, 2020\.
  * [7] H. Kim and et al., “Blockchained on-device federated learning,” _IEEE Communications Letters_ , vol. 24, no. 6, pp. 1279–1283, 2019.
  * [8] Y. Qu and et al., “Decentralized privacy using blockchain-enabled federated learning in fog computing,” _IEEE Internet of Things Journal_ , vol. 7, no. 6, pp. 5171–5183, 2020.
  * [9] S. R. Pokhrel and et al., “Federated learning with blockchain for autonomous vehicles: Analysis and design challenges,” _IEEE Transactions on Communications_ , vol. 68, no. 8, pp. 4734–4746, 2020.
  * [10] Y. Li and et al., “A blockchain-based decentralized federated learning framework with committee consensus,” _IEEE Network_ , vol. 35, no. 1, pp. 234–241, 2020.
  * [11] Indiana 5G Zone. https://indiana5gzone.com.
  * [12] Qualcomm. (2019, December) Snapdragon 865 5G Mobile Platform. https://www.qualcomm.com/products/snapdragon-865-5g-mobile-platform.
  * [13] D. Duplyakin and et al., “The design and operation of CloudLab,” in _Proceedings of USENIX ATC_ , 2019.
  * [14] J. Dugan and et al., “iperf3: A TCP, UDP, and SCTP network bandwidth measurement tool,” 2019.
  * [15] S. Park and et al., “ExLL: An Extremely Low-latency Congestion Control for Mobile Cellular Networks,” in _ACM CoNEXT_ , 2018.
  * [16] A. Dadgar and et al., “Lifeguard: Local health awareness for more accurate failure detection,” in _IEEE/IFIP International Conference on Dependable Systems and Networks Workshops_ , 2018, pp. 22–25.
  * [17] F. Rossi and et al., “Distributed consensus with mixed time/communication bandwidth performance metrics,” in _Proceedings of the Allerton_. IEEE, 2014, pp. 286–293.
  * [18] F. Iutzeler and et al., “Analysis of max-consensus algorithms in wireless channels,” _IEEE Transactions on Signal Processing_ , vol. 60, no. 11, pp. 6103–6107, 2012.
  * [19] C. Dwork and et al., “Pricing via processing or combatting junk mail,” in _CRYPTO_. Springer, 1992, pp. 139–147.
  * [20] M. Jakobsson and et al., “Proofs of work and bread pudding protocols,” in _Secure information networks_. Springer, 1999, pp. 258–272.
  * [21] X. Wang and et al., “Defending against denial-of-service attacks with puzzle auctions,” in _Symposium on Security and Privacy_. IEEE, 2003, pp. 78–92.
  * [22] A. Gervais and et al., “On the security and performance of proof of work blockchains,” in _Proceedings of the ACM CCS_ , 2016, pp. 3–16.
  * [23] Y. LeCun and et al., “Gradient-based learning applied to document recognition,” _Proceedings of the IEEE_ , vol. 86, no. 11, pp. 2278–2324, 1998.