Federated Learning Across Decentralized and Unshared Archives for Remote Sensing
Image Classification

Barış Büyüktaş,
Gencer Sumbul, Member, IEEE,
Begüm Demir, Senior Member, IEEE
Barış Büyüktaş, Gencer Sumbul and Begüm Demir are with the Faculty of Electrical Engineering and Computer Science, Technische Universität Berlin, 10623 Berlin, Germany, also with the BIFOLD - Berlin Institute for the Foundations of Learning and Data, 10623 Berlin, Germany.
Email: , , .

Federated learning (FL) enables the collaboration of multiple deep learning models to learn from decentralized data archives (i.e., clients) without accessing data on clients. Although FL offers ample opportunities in knowledge discovery from distributed image archives, it is seldom considered in remote sensing (RS). In this paper, as a first time in RS, we present a comparative study of state-of-the-art FL algorithms. To this end, we initially provide a systematic review of the FL algorithms presented in the computer vision community for image classification problems, and select several state-of-the-art FL algorithms based on their effectiveness with respect to training data heterogeneity across clients (known as non-IID data). After presenting an extensive overview of the selected algorithms, a theoretical comparison of the algorithms is conducted based on their: 1) local training complexity; 2) aggregation complexity; 3) learning efficiency; 4) communication cost; and 5) scalability in terms of number of clients. As the classification task, we consider multi-label classification (MLC) problem since RS images typically consist of multiple classes, and thus can simultaneously be associated with multi-labels. After the theoretical comparison, experimental analyses are presented to compare them under different decentralization scenarios in terms of MLC performance. Based on our comprehensive analyses, we finally derive a guideline for selecting suitable FL algorithms in RS. The code of this work will be publicly available at <https://git.tu-berlin.de/rsim/FL-RS>.

Remote sensing, federated learning, image classification.

§ INTRODUCTION

As remote sensing (RS) technology continues to advance, RS data has become increasingly vast in size and distributed across decentralized image archives (i.e., clients). For knowledge discovery from RS image archives, deep learning (DL) has been proven its success among all the data-driven approaches. The use of DL generally requires complete access to training data while learning the DL model parameters <cit.>. However, training data in some clients may not be accessible to the public (i.e., unshared) due to commercial interests, privacy concerns or legal regulations. The commercial RS data providers may consider training data as a valuable asset, and thus often restrict public access to protect their proprietary information and business interests. In RS, privacy concerns can also be crucial across various use cases (e.g., crop monitoring, damage assessment, wildlife tracking etc.) that may limit public access to training data on clients. As an example, in the context of crop monitoring through RS images, farmers might be hesitant to share detailed information about their crops <cit.>, and thus may not allow sharing crop labels. For wildlife tracking with RS images <cit.>, training data can be unshared with the public to avoid disclosing the precise locations of endangered species or sensitive ecosystems. There may also be legal restrictions (e.g., privacy laws, national security concerns etc.) in place that prevents public access to sensitive information contained within the training data on clients <cit.>.

When there is no access to training data on clients, federated learning (FL) can be utilized for training DL models on clients (i.e., local models) and finding the optimal model parameters on a central server (i.e., global model). As one of the first attempts to achieve FL, the federated averaging (FedAvg) algorithm is introduced in <cit.> to learn a global model by iterative model averaging in four consecutive steps, which are explained in the following. First, the central server sends the initial global model to all clients. Second, in each client, this model is trained on the corresponding local data of the client, leading to one local model. Third, each client sends the parameters of its local model back to the central server. Fourth, the central server updates the global model by averaging the parameters of all local models (i.e., parameter aggregation). These steps are repeated several times (i.e., rounds) until the convergence of the global model. This strategy is illustrated in Fig. <ref>.

An illustration of federated learning applied with the iterative model averaging strategy to learn a deep neural network (DNN) when there is no access to training data on decentralized RS image archives (i.e., clients). There are four main steps of iterative model averaging: 1 each client updates its DNN with the corresponding local data, leading to one set $w_k$ of local DNN parameters for the $k$th client; 2 each client sends its local DNN parameters to the central server; 3 the central server aggregates the parameters of all local models, aiming to obtain the set $w^*$ of optimum parameters of the global DNN; and 4 the central server sends the parameters of the global DNN to each client. These steps are repeated several times until the convergence of the global DNN.

When training data is distributed across clients, training data in different clients might be not independent and identically distributed (non-IID). This has been found to be one of the main factors, affecting the convergence of the considered global model <cit.>. In RS, there are three main reasons for such training data heterogeneity across clients. First, the distribution of training image labels may vary across clients <cit.>. This is more evident if multiple labels are assigned to each training image. Second, different clients can hold significantly different amounts of training data. Third, training images associated with a same class may have different data distributions across clients that is known as concept shift <cit.>. This is due to the fact that the RS images belonging to the same class are highly affected because of physical factors (e.g., soil moisture, vegetation etc.) and atmospheric conditions in RS.

When the iterative model averaging strategy is applied through the FedAvg algorithm, each local model is updated towards its local optima, which can be different among clients due to non-IID training data. This may lead to the deviation of the global model from its global optima after parameter averaging, and thus impeding the convergence of the global model and reducing its generalization capability <cit.>. To address this problem, in recent years advanced FL algorithms have been introduced mainly in the computer vision (CV) community for image classification problems (see Section <ref>). We would like to note that although FL offers ample opportunities for classification of RS images across distributed RS image archives, it is seldom considered in RS. As a first time in RS, in this paper, we present a comparative study of state-of-the-art FL algorithms. The main contributions of this paper are summarized as follows:

* We present a systematic review of the state-of-the-art FL algorithms in the CV community, and select the most effective algorithms based on their effectiveness with respect to training data heterogeneity across clients.

* Together with an extensive overview of the selected algorithms, we provide their theoretical comparison in terms of: 1) local training complexity; 2) aggregation complexity; 3) learning efficiency; 4) communication cost; and 5) scalability. As the classification task, we consider multi-label classification (MLC) of RS images since RS images typically consist of multiple classes, and thus can simultaneously be associated with multi-labels.

* We provide an extensive experimental comparison of the selected algorithms in terms of MLC performance under different decentralization scenarios.

* We derive some guidelines for selecting suitable FL algorithms in RS based on the level of non-IID training data, aggregation complexity, and local training complexity.

We would like to note that although MLC is selected as the classification task of the considered FL algorithms, they can be easily adapted to other classification tasks (e.g., pixel-based classification, single-label scene classification etc.) by using the corresponding loss functions and task heads in the considered DL model. The remaining part of this paper is organized as follows. We provide a detailed review of existing FL algorithms in Section <ref>. Among the existing algorithms, we consider several FL algorithms to present their extensive overview in the context of MLC of RS images in Section <ref>. Then, a theoretical comparison of the selected algorithms is conducted in Section <ref>. After the theoretical comparison, experimental analysis of these algorithms are carried out in Section <ref>, while Section <ref> provides the design of experiments. Section <ref> concludes our paper with some guidelines for selecting suitable FL algorithms in RS. We would like to note that we will make the code of our paper publicly available at <https://git.tu-berlin.de/rsim/FL-RS> that allows to utilize all the considered algorithms for RS images.

A Categorization of the Advanced Federated Learning Algorithms Addressing Training Data Heterogeneity Across Clients.
ERM Denotes Empirical Risk Minimization. MPA Denotes Model Parameter Averaging

2@l4*Algorithm     3cLocal Training Strategy         4cAggregation Strategy
ERM     [c]ERM with
Proximal Term     [c]Gradient
Adjustment         [c]Standard
MPA     [c]Weighted
MPA     [c]Personalized
MPA     [c]Knowledge

Focused     FedProx <cit.>

SCAFFOLD <cit.>

MOON <cit.>

FedDyn <cit.>

FedDC <cit.>

FedAlign <cit.>
Focused     FedNova <cit.>

FedMA <cit.>

FedBN <cit.>

Mlmg <cit.>

Fed-PHC <cit.>

pFedLA <cit.>

FedDF <cit.>

FedBE <cit.>

FedAUX <cit.>

FedGen <cit.>

§ RECENT ADVANCES IN FEDERATED LEARNING ADDRESSING TRAINING DATA HETEROGENEITY
ACROSS CLIENTS

In this section, we survey the advanced FL algorithms in the CV community, aiming to alleviate the effects of training data heterogeneity across clients during FL training. We categorize the existing algorithms into two groups: 1) local training focused algorithms <cit.>; and 2) model aggregation focused algorithms <cit.> based on their advanced local training and aggregation strategies during FL that is summarized in Table <ref>.

Under the first category, FL algorithms enhance standard empirical risk minimization of local client training by: i) adding auxiliary loss functions (i.e., proximal terms) <cit.>; and ii) utilizing gradient adjustment techniques <cit.>. In FL, adding proximal terms to the local training of clients is found to be successful to limit local models deviating from the global model. As an example, in <cit.> a federated optimization algorithm (denoted as FedProx) is introduced to include a proximal term in each local training based on the $l_2$ distance between the parameters of the global model and each local model. In <cit.>, a model-contrastive federated learning algorithm (denoted as MOON) is introduced to utilize NT-Xent loss function for reducing the distance of feature distributions among clients while increasing that of among different local rounds. In <cit.>, the federated dynamic regularizer (FedDyn) algorithm is proposed to include a regularization term in local client training for aligning the model parameters between the central server and each client. It is worth noting that proximal terms may impede the convergence of local models as they constrain local updates. As an alternative, gradient adjustment techniques are also employed in FL for limiting local models deviating from the global model. For example, in <cit.>, the stochastic controlled averaging algorithm (denoted as SCAFFOLD) is introduced to adjust the local gradient updates in clients based on the differences between the update directions of the global model and each local model. In <cit.>, a distillation-based regularization method (denoted as FedAlign) is proposed to enhance the generalization capability of local models rather than forcing them to be closer to the global model as in the above-mentioned algorithms. To this end, it regularizes the Liptschitz constants of the considered neural network blocks through a proximal term. In <cit.>, a federated learning algorithm with local drift decoupling and correction (FedDC) is introduced to combine both strategies, adding proximal terms and utilizing gradient adjustment techniques. To this end, in local client training, it defines a proximal term based on an auxiliary local drift variable (which tracks the gap between the model parameters of the client and the global model) in addition to applying gradient correction similar to the SCAFFOLD algorithm.

Under the second category of FL algorithms, existing studies mainly aim to improve the standard parameter aggregation of iterative model averaging through: i) weighted model averaging; ii) personalized model averaging; and iii) knowledge distillation. As an example of weighted model averaging, in <cit.>, the federated normalized averaging (FedNova) algorithm is proposed to reduce inconsistencies among local models due to training data heterogeneity across clients. To achieve this, it normalizes the parameters of local models before applying aggregation on the central server. In <cit.>, the federated matched averaging (FedMA) algorithm is proposed for layer-wise weighting the parameters of local models during aggregation, while parameter weights are found through a bipartite matching optimization problem. In <cit.>, the federated averaging with server momentum (denoted as FedAvgM) algorithm is proposed to mitigate the differences among local models by averaging local model parameters based on the momentum of their changes throughout FL rounds. A federated learning algorithm (denoted as FedBN) is introduced in <cit.> to alleviate concept shift between clients by excluding batch normalization parameters from the aggregation stage of FL. It is noted that in FedNova, FedMA and FedBN algorithms, a single global model is exploited on the central server. However, obtaining a single global model may not be sufficient for accurate FL when data heterogeneity across clients is high. To address this, personalized model averaging is found to be successful for enhancing cooperation among comparable clients when training data is non-IID among clients. As an example for such strategy, clustering clients and then employing one global model for each cluster is proposed in: i) the multi-local and multi-global model aggregation (Mlmg) algorithm <cit.>; and ii) the FL algorithm combined with prototype-based hierarchical clustering (Fed-PHC) <cit.> for semantic segmentation of aerial images. In <cit.>, the layer-wised personalized federated learning algorithm (denoted as pFedLA) is introduced to characterize the importance of each layer from different clients, and thus to optimize the personalized model aggregation for clients with heterogeneous data by using hypernetworks. Most of the FL algorithms, which are based on both weighted and personalized model averaging, require clients and the central server to employ a same DL model. To overcome this limitation, knowledge distillation based aggregation strategies have been recently proposed in FL. These strategies aim to obtain the global model by utilizing aggregated knowledge from clients rather than directly aggregating their model parameters. It is achieved by training a global model (which generally has a less number of parameters than local models) on the outputs of local models that requires clients to send their outputs rather than parameters. Main advantage of such strategies is to reduce the communication cost of FL compared to the parameter averaging based aggregation strategies. They also indirectly enhance the effectiveness of the global model towards training data heterogeneity due to the elimination of direct parameter averaging of local models. As an example for such algorithms, in <cit.> the federated distillation fusion (FedDF) algorithm is proposed to learn the global model as a student model by distilling the ensemble of clients as teacher models based on the average of their model outputs. Differently than FedDF, the federated bayesian ensemble (FedBE) algorithm is introduced in <cit.> to employ different importances of clients for knowledge distilation through Bayesian model ensemble. Sattler et al. <cit.> proposes a FL algorithm (denoted as FedAUX) to define a certainity score of each client based on the pre-training of local models for weighting ensemble predictions during knowledge distillation. FedDF, FedBE and FedAUX algorithms require the availability of an unlabeled auxiliary training set or synthetically generated data, which is accessible to all clients during training. This may not be always feasible. To eliminate this requirement for knowledge distillation based parameter aggreation, in <cit.> an algorithm for federated distillation via generative learning (FedGen) is proposed. In this algorithm, a lightweight generator is learned in the central server to aggregate information from clients without the need for using an auxiliary data.

§ AN OVERVIEW OF THE SELECTED
FEDERATED LEARNING ALGORITHMS

In this section, we focus our attention on FedProx <cit.>, SCAFFOLD <cit.>, MOON <cit.>, FedDC <cit.>, FedNova <cit.>, pFedLA <cit.>, and FedBN <cit.> algorithms due to their proven success in FL and present their extensive overview. In detail, based on the effectiveness of these algorithms towards training data heterogeneity across clients, we categorize them into two main groups: 1) the local training focused algorithms; and 2) the model aggregation focused algorithms. It is worth noting that we consider multi-label classification (MLC) problem for the overview of these algorithms since RS images typically consist of multiple classes, and thus can simultaneously be associated with multi-labels.

Let $K$ be the total number of clients and $C_i$ denotes the $i$th client for $1\leq i\leq K$. Let $D_i = \{(\boldsymbol{x}_{i}^z, \boldsymbol{y}_{i}^z)\}_{z=1}^{M_i}$ be the corresponding local training set of $C_i$, where $M_i$ is the number of images in $D_i$ and $\boldsymbol{x}_{i}^z$ is the $z$th RS image in $D_i$. $\boldsymbol{y}_{i}^z =[{y}_{i}^{z,1},\ldots, {y}_{i}^{z,P}]\in \{ 0, 1 \}^P$ denotes the multi-labels of $\boldsymbol{x}_{i}^z$, where ${y}_{i}^{z,p}$ states the presence or absence of the $p$th class out of $P$ unique classes. Let $\phi_i$ be the local DL model of $C_i$ and $w_i$ be the set of its parameters. $\phi_i$ provides the multiple class probabilities $\boldsymbol{r}_{i}^{z} = [r_{i}^{z,1},\ldots,r_{i}^{z,P}]$ associated with $\boldsymbol{x}_{i}^z$ (i.e., $\phi_i(\boldsymbol{x}_{i}^{z};w_i)=\boldsymbol{r}_{i}^{z}$) while $z\in\{1,\ldots,M_i\}$. $\phi_i$ is locally trained on $D_i$ for $E$ epochs by using the binary cross entropy (BCE) loss function, which is written as follows for $\boldsymbol{x}_{i}^{z}$:

\begin{equation}
\mathcal{L}_{\text{BCE}}(\boldsymbol{r}_{i}^z, \boldsymbol{y}_{i}^z) \!=\!- \!\!\sum^P_{p=1}\!{y}_{i}^{z,p} \log( r_{i}^{z,p}) + (1\!-\!{y}_{i}^{z,p}) \log(1\!-\!r_{i}^{z,p}).
\end{equation}

Then, for $C_i$ finding the optimum local model parameters $w_i^*$ by minimizing the corresponding local objective $\mathcal{O}_i$ (i.e., empirical risk minimization) can be formulated as follows:

\begin{equation}
\begin{aligned}
\mathcal{O}_i (\mathcal{B};w_i) &=\!\!\!\!\!\!\! \sum_{(\boldsymbol{x}_i^z,\boldsymbol{y}_i^z)\in \mathcal{B}}\!\!\!\!\mathcal{L}_{\text{BCE}}(\phi_i(\boldsymbol{x}_{i}^z;w_i), \boldsymbol{y}_{i}^{z}),\\
w_i^* &= \arg \min_{w_i} \mathcal{O}_i(D_i;w_i).
\end{aligned}
\end{equation}

On decentralized and unshared training sets of the all clients $D=\bigcup_ {i \in \{ 1, 2,..., K \} } D_i$, FL algorithms aim to obtain the optimum parameters $w^*$ of a global model that minimizes all the local objectives as follows:

\begin{equation}
w^* = \arg \min_{w} \sum_{i=1}^{K} \frac{\lvert D_i \rvert}{\lvert D \rvert} \mathcal{O}_{i}(D_i;w).
\label{minimization}
\end{equation}

To this end, the parameters of the global model are updated through the aggregation of local model parameters at each FL round as follows:

\begin{equation}
w = \sum_{i=1}^{K} \alpha_i w_i,
\label{fedavg}
\end{equation}

where $\alpha_i$ is a hyperparameter that adjusts the importance of the parameters of the client $C_i$ for aggregation. After updating the global model parameters, the parameters of each local model are updated based on $w$. Local training and parameter aggregation are consecutively repeated several times until the convergence of the global model (which is generally defined by the number of communication rounds $R$).

When the standard iterative model averaging strategy (e.g., FedAvg algorithm) is applied in FL, each local model is updated towards its local optima based on the standard empirical risk minimization. The local optima of each client can be different from each other when training data is heterogeneous across clients (i.e., non-IID training data). This may lead to the deviation of the global model from its global optima after parameter averaging, since equal importance is given to each client in the FedAvg algorithm ($\alpha_i$ = $\lvert D_i \rvert / \lvert D \rvert $).

$\bigcup_ {i \in \{ 1, 2,..., K \} } D_i$, $R$, $E$, $\eta$, $K$

$w_i \leftarrow w$
(*[f]$E$ epochs)$e\gets1$ $E$
$\mathcal{B} \in D_i$
$\mathcal{O}_i (\mathcal{B};w_i) =\sum_{ \mathcal{B}} \mathcal{L}_{\text{BCE}}(\boldsymbol{r}_{i}^z, \boldsymbol{y}_{i}^{z})$
$\mathcal{L}_{\text{MC}}(\mathcal{B};w_i)\!=\!\!-\!\!\sum_{\mathcal{B}}\text{log}(\!\frac{e^ { S( \boldsymbol{f}_i^z, \boldsymbol{f}_{i,g}^z ) \!/\! \tau  } }  {  e^ { S( \boldsymbol{f}_i^z, \boldsymbol{f}_{i,g}^z ) \!/\! \tau  } \!\!+ e^ { S( \boldsymbol{f}_{i,p}^z, \boldsymbol{f}_{i,g}^z) \!/\! \tau  }}\!)$
$P_i(h_i, w_i, w) = {\lVert h_i + w_i - w \rVert}^2$
$R_i(w,w_i)=\frac{\gamma}{2} \lvert\lvert w-w_i \rvert\rvert^2$
$\nabla_{w_i} \gets \nabla_{w_i} (\mathcal{O}_{i} + \textcolor{FedDC_c}{P_i} +  \textcolor{MOON_c}{\mathcal{L}_{\text{MC}}} + \textcolor{FedProx_c} {R} )$
$w_i\leftarrow  w_i - \eta\left(\nabla_{w_i}+ \textcolor{SCAFFOLD_c}  {v-v_i}\right)$

$v_i \leftarrow v_i-v + \frac{w-w_i}{U\eta}$

$h_i \leftarrow h_i + \Delta w_i$
$w_i$, $h_i$, $v_i$

$w^* \leftarrow w_0$ *$w$ initialization
$v, v_1,\ldots,v_K \leftarrow 0$
$h_1,\ldots,h_K \leftarrow 0$
(*[f]$R$ rounds)$r\gets1$ $R$
(*[f]$K$ clients)$i\gets1$ $K$
$w_i$, $h_i$, $v_i$ $\leftarrow \FLocal(D_i,w^*,\textcolor{SCAFFOLD_c}{v},\textcolor{SCAFFOLD_c}{v_i},\textcolor{FedDC_c}{h_i})$

$w^* \leftarrow \sum_{i=1}^{K} \frac{\lvert D_i \rvert} {\lvert D \rvert} (w_i + \textcolor{FedDC_c}{h_i})$
$v \leftarrow v + \frac{1}{K} \sum_{i=1}^{K} \Delta v_i$

The local training focused FL algorithms. The parts marked in brown, purple, cyan and orange represent changes only to FedProx, SCAFFOLD, MOON and FedDC, respectively.

§.§ The Local Training Focused Algorithms

This subsection presents the FedProx, MOON, FedDC and SCAFFOLD algorithms that aim to address the challenges of training data heterogeneity across clients by enhancing the standard empirical risk minimization during local training of FL. To this end, proximal terms are added to local objectives in the FedProx, MOON and FedDC algorithms, while gradient adjustment techniques are utilized during the update of local model parameters in the SCAFFOLD and FedDC algorithms. These FL algorithms are summarized in Algorithm <ref>, while their details are given below.

§.§.§ FedProx <cit.>
This algorithm aims at limiting local models to excessively deviate from the global model that is one of the main effects of training data heterogeneity across clients during federated training of the global model. This is achieved by adding a $L_2$ regularization term $R_i(w,w_i)=\frac{\gamma}{2} \lvert\lvert w-w_i \rvert\rvert^2$ to each local objective. The weight of the $L_2$ regularization term is adjusted with the $\gamma$ parameter. A high value of $\gamma$ allows to restrict local parameter updates based on local objectives, leading the parameters of local models to be closer to the global model parameters. A small value of $\gamma$ allows the local model parameters to be updated more based on the local objectives. Since FedProx reduces the difference of local model parameters between clients by restricting each local model with respect to the global model, it increases the generalization capacity of the local models. Due to this, the convergence of the local models does not significantly deviate from each other depending on $\gamma$ even though the data distribution differences between the clients are large.

§.§.§ MOON <cit.>
This algorithm aims to overcome the effects of training data heterogeneity across clients by preventing the image feature spaces of local models to deviate from that of the global model. This is achieved by increasing the similarity of the image features obtained from the global model and the local model, while decreasing the similarity of the features obtained from the local models of the consecutive FL rounds. To this end, for a given mini-batch $\mathcal{B}$, it adds the model-contrastive loss function $\mathcal{L}_{\text{MC}}$ to each local objective that is defined as follows:

\begin{equation}
\mathcal{L}_{\text{MC}}(\mathcal{B};w_i)\!=-\!\!\!\sum_{\boldsymbol{x}_i\in \mathcal{B}}\!\! \text{log}\left(\!\frac{e^ { S( \boldsymbol{f}_i^z, \boldsymbol{f}_{i,g}^z ) / \tau  } }  {  e^ { S( \boldsymbol{f}_i^z, \boldsymbol{f}_{i,g}^z ) / \tau  } \!\!+\! e^ { S( \boldsymbol{f}_{i,p}^z, \boldsymbol{f}_{i,g}^z) / \tau  }}\!\right),
\label{moon}
\end{equation}

where $S(.,.)$ measures the cosine similarity, $\tau$ is a temperature parameter. $\boldsymbol{f}_i^z$, $\boldsymbol{f}_{i,p}^z$ and $\boldsymbol{f}_{i,g}^z$ are the image features of $\boldsymbol{x}_i^z$ obtained by using: i) the parameters of the local model; ii) the local model parameters from the previous FL round; and iii) the global model parameters, respectively.

§.§.§ SCAFFOLD <cit.>
This algorithm aims to alleviate the deviation in the updates of each local model that results in slow and unstable convergence (i.e., client-drift) when training data is distributed across heterogeneous clients. To this end, this algorithm defines one variable for each local and global model to estimate the change in the parameter updates of these models. Then, the defined parameters are utilized for adjusting gradients during local training. In detail, SCAFFOLD estimates the update direction of each client with a set of local parameters $v_i$ (i.e., the local control variate of $C_i$) and that of the global model with a set of global parameters $v$ (i.e., global control variate) based on the gradients of model parameters. Then, for a given mini-batch $\mathcal{B}$ the difference between $v_i$ and $v$ is added to the update rule of $w_i$ to adjust the corresponding gradients $\nabla_{w_i}$ as follows:

\begin{equation}
w_i\leftarrow  w_i - \eta\left(\nabla_{w_i}\mathcal{O}_{i}(\mathcal{B};w_i)+v-v_i\right),
\label{scaffold}
\end{equation}

where $\eta$ is the learning rate. $\{v_i\}_{i=1}^K$ and $v$ are initially set to zero and updated after each FL round. For SCAFFOLD, two different options are defined to update the local control variate of each client. In the first option, for the $i$th client $v_i$ is updated based on the gradients of the global model parameters on the corresponding local training data as follows:

\begin{equation}
v_i \leftarrow \nabla_{w}\mathcal{O}_{i}(D_i;w).
\label{updates1}
\end{equation}

In the second option, the gradients of the previous FL rounds are utilized as follows:

\begin{equation}
v_i \leftarrow v_i-v + \frac{w-w_i}{U\eta},
\label{updates2}
\end{equation}

where $U$ is the number of local update steps. Since there is an additional forward pass over the local data in the first option, it is computationally more demanding than the second option. Thus, the second option is considered for the rest of our paper. After each local control variate is updated, $\{v_i\}_{i=1}^K$ is sent to the central server. The global control variate is updated at the central server as follows:

\begin{equation}
v \leftarrow v + \frac{1}{K} \sum_{i=1}^{K} \Delta v_i,
\label{updates3}
\end{equation}

where $\Delta v_i$ is the change of $v_i$ between two consecutive FL rounds.

§.§.§ FedDC <cit.>
This algorithm aims at preventing the effects of client-drift on FL of a global model by: i) adjusting gradients during local training through control variables as in the SCAFFOLD algorithm; and also ii) including a proximal term to the local objective. To this end, this algorithm defines a local drift variable $h_i$ for each client to estimate the change of local model parameters. $h_i$ is initially set to zero and updated after each local training of $C_i$ as follows:

\begin{equation}
h_i \leftarrow h_i + \Delta w_i,
\label{driftt}
\end{equation}

where $\Delta w_i$ is the change of $w_i$ during local training. Then, in FedDC $h_i$ is exploited in the corresponding proximal term $P_i$ to control the change in the parameter updates of the global and local models. For given parameters of local and global models and the local drift variable, $P_i$ is defined as follows:

\begin{equation}
P_i (h_i, w_i, w) = {\lVert h_i + w_i - w \rVert}^2.
\label{penalized11}
\end{equation}

In addition to adding $P_i$ to the corresponding local objective of $C_i$, the local control variate $v_i$ and the global control variate $v$ are utilized for this algorithm as in SCAFFOLD. Accordingly, the update rule of $w_i$ is written as follows:

\begin{equation}
w_i\gets  w_i - \eta\left(\nabla_{w_i} [ \mathcal{O}_{i}(\mathcal{B};w_i)\! + \! P_i (h_i, w_i, w) ]\!+\!v\!-\!v_i\right),
\label{feddc11}
\end{equation}

where $v_i$ and $v$ are updated by using (<ref>) and (<ref>), respectively. After local training of each client is completed, the global model parameters are updated in the FedDC algorithm as follows:

\begin{equation}
w = \sum_{i=1}^{K} \frac{\lvert D_i \rvert}{\lvert D \rvert} (w_i + h_i).
\label{update13}
\end{equation}

$\bigcup_ {i \in \{ 1, 2,..., K \} } D_i$, $R$, $E$, $\eta$, $K$

$w_i \leftarrow w$
(*[f]$E$ epochs)$e\gets1$ $E$
$\mathcal{B} \in D_i$
$\mathcal{O}_i (\mathcal{B};w_i) =\sum_{ \mathcal{B}} \mathcal{L}_{\text{BCE}}(\boldsymbol{r}_{i}^z, \boldsymbol{y}_{i}^{z})$
$w_i\leftarrow  w_i - \eta\left(\nabla_{w_i}\mathcal{O}_{i}\right)$

$w^*\!,\textcolor{pFedLA_c}{w_1^*,\ldots,w_K^*,w_{\lambda_1},\ldots,w_{\lambda_K}} \!\!\leftarrow\! w_0$ *$w$ initialization
$\boldsymbol{t}_1,\ldots, \boldsymbol{t}_K \leftarrow \vec{\boldsymbol{0}}$
(*[f]$R$ rounds)$r\gets1$ $R$
(*[f]$K$ clients)$i\gets1$ $K$
$\textcolor{pFedLA_c}{\boldsymbol{\alpha}_i = \lambda_i(\boldsymbol{t}_i;w_{\lambda_i})}$
$w_i^* = \bigcup_{l} \sum_{j=1}^K w_j^l \boldsymbol{\alpha}_{i,j}^l$
$w^* \leftarrow w_i^*$
$w_i \leftarrow \FLocal(D_i,w^*)$
$\boldsymbol{t}_i\leftarrow  \boldsymbol{t}_i - \eta(\nabla_{\boldsymbol{t}_i}w_i^*)^T\Delta w_i$
$w_{\lambda_i}\leftarrow  w_{\lambda_i} - \eta(\nabla_{w_{\lambda_i}}w_i^*)^T\Delta w_i$

$w^* \leftarrow \sum_{i=1}^{K} \frac{\lvert D_i \rvert} {\lvert D \rvert}(w_i \textcolor{FedBN_c}{\setminus \varphi_i})\textcolor{FedNova_c}{\frac{1}{E|D_i|/|\mathcal{B}|}}$

$w^* \leftarrow w_1^*,\ldots,w_K^*$
The model aggregation focused FL algorithms. The parts marked in pink, magenta and blue represent changes only to FedNova, FedBN and pFedLA, respectively.

§.§ The Model Aggregation Focused Algorithms

This subsection presents the FedNova, FedBN, and pFedLA algorithms that aim at alleviating the effects of training data
heterogeneity across clients by improving the standard parameter aggregation of iterative model averaging. To achieve this, the FedNova and FedBN algorithms utilize weighted parameter model averaging strategies, while the personalized global model aggregation of each client is exploited with hypernetworks in the pFedLA algorithm. These FL algorithms are summarized in Algorithm <ref>, while their details are given below.

§.§.§ FedNova <cit.>
During local training of FL, the considered clients may include different numbers of training samples (i.e., quantity skew) that is considered as one of the main reasons of training data heterogeneity across clients in FL. Quantity skew may lead the clients with higher numbers of training samples to have more impact on the global model update since the local update steps of these clients are higher than those of other clients. To eliminate this, the FedNova algorithm normalizes the parameters of local models according to the numbers of local updates before applying aggregation. Accordingly, at the end of each FL round it first weights the local model parameters of $C_i$ with the multiplicative inverse of the number of local updates (i.e., $ \frac{w_i}{E|D_i|/|\mathcal{B}|}$), and then sends the weighted local model parameters to the central server for parameter aggregation.

The Theoretical Comparison of the Selected FL Algorithms. Three Marks "H" (High), "M" (Medium), or “L” (Low) Are Given for the Considered Criteria.

Algorithm         [c]Local Training
Complexity     [c]Aggregation
Complexity     [c]Learning
Efficiency     [c]Communication
Cost     Scalability
FedAvg <cit.>            L       L        M          L              L
Focused     FedProx <cit.>             M      L       M       L           H

SCAFFOLD <cit.>               M             L             H           H            M

MOON <cit.>                H         L       H      L              H

FedDC <cit.>                  M        L         M        H                H
FedNova <cit.>                 L        M         L        L            L

pFedLA <cit.>               L       H          L        L                   L

FedBN <cit.>                 L          M       L         L               L

§.§.§ FedBN <cit.>
This algorithm aims at preventing the effects of concept shift between clients by excluding batch normalization (BN) parameters from the aggregation stage of FL. To this end, BN parameters of each local model are not shared with the central server, and thus not included in parameter averaging of local models in the central server. Let $\varphi_i \in w_i$ be the set of BN parameters of the local model in $C_i$. The aggregation of local model parameters is achieved in the FedBN algorithm as follows:

\begin{equation}
w = \sum_{i=1}^{K} \frac{\lvert D_i \rvert}{\lvert D \rvert} (w_i \setminus \varphi_i). %, w_i^l \not\in \varphi,
\label{fedbn}
\end{equation}

§.§.§ pFedLA <cit.>
This algorithm aims at mitigating the effects of non-IID training data during FL by employing personalized global model aggregation for each client. This leads to learning one global model for each client (i.e., the set $\{w_1^*,\ldots,w_K^*\}$ of global models) instead of exploiting a single global model as in the other FL algorithms. Accordingly, the objective function of FL can be rewritten as follows:

\begin{equation}
w_1^*,w_2^*,...,w_K^* = \underset{\bigcup_{i}w_i}{\mathrm{argmin}} \sum_{i=1}^{K} \frac{\lvert D_i \rvert}{\lvert D \rvert} \mathcal{O}_{i}(D_i;w_i).
\label{minimization_p}
\end{equation}

To learn one global model for each client, the pFedLA algorithm aggregates the parameters of local models by considering the importance of each parameter differently for each client. To this end, it defines the aggregation weights $\boldsymbol{\alpha}_i =[\boldsymbol{\alpha}_i^{1},\boldsymbol{\alpha}_i^{2},...,\boldsymbol{\alpha}_i^{l}]$ of $C_i$, where $\boldsymbol{\alpha}_i^l$ is the aggregation weight vector of the $l$th parameter and $\boldsymbol{\alpha}_{i,j}^l$ is the corresponding aggregation weight associated with $C_j$ (i.e., $w_i^l$). To learn the aggregation weights of all the clients, in this algorithm hypernetworks <cit.> are utilized at the central server. Let $\lambda_i$ be a hypernetwork of $C_i$ that takes the learnable embedding vector $\boldsymbol{t}_i$ and estimates $\boldsymbol{\alpha}_i$ as follows:

\begin{equation}
\label{hypernetwork1}
\boldsymbol{\alpha}_i = \lambda_i(\boldsymbol{t}_i;w_{\lambda_i}),
\end{equation}

where $w_{\lambda_i}$ is the parameters of the hypernetwork associated with $C_i$. Once the hypernetworks are included in (<ref>), the overall objective function of the pFedLA algorithm is written as follows:

\begin{equation}
\label{pfedla1}
% T, \Psi
% \arg \min
\underset{\bigcup\limits_{i}\{\boldsymbol{t}_i, w_{\lambda_i}\!\}}{\mathrm{argmin}} \sum_{i=1}^{K} \frac{\lvert D_i \rvert}{\lvert D \rvert} \mathcal{O}_i\left(D_i; \bigcup_{l} \sum_{j=1}^K w_j^l \boldsymbol{\alpha}_{i,j}^l\right),
%\{w^{1},w^{2},.....,w^{l}\}  * a_i
\end{equation}

where $\bigcup_{i}\{\boldsymbol{t}_i, w_{\lambda_i}\}$ are the parameters of hypernetworks and the embedding vectors for all the clients that are updated in the central server by minimizing (<ref>). Accordingly, for $C_i$ their update rules can be written as follows:

\begin{equation}
\label{pfedla2}
\begin{aligned}
\boldsymbol{t}_i &\leftarrow  \boldsymbol{t}_i - \eta(\nabla_{\boldsymbol{t}_i}w_i^*)^T\Delta w_i,\\
w_{\lambda_i} &\leftarrow  w_{\lambda_i} - \eta(\nabla_{w_{\lambda_i}}w_i^*)^T\Delta w_i.
\end{aligned}
\end{equation}

The reader is referred to <cit.> for the derivation of (<ref>).

It is worth noting that although MLC is selected as the classification task of the considered FL algorithms, they can be easily adapted to other classification tasks (e.g., pixel-based classification, single-label scene classification etc.). This can be achieved by using the corresponding loss functions instead of $\mathcal{L}_{\text{BCE}}$ and the corresponding task heads in the considered DL model $\phi_i$ for $\forall i \in \{1,\ldots,K\}$.

§ A THEORETICAL COMPARISON OF THE SELECTED
FEDERATED LEARNING ALGORITHMS

In this section, the selected FL algorithms are theoretically compared based on their: i) local training complexity; ii) aggregation complexity; iii) learning efficiency; iv) communication cost; and v) scalability in terms of number of clients. The comparison of the algorithms under each criterion is given in a separate subsection below, while their overall comparison is summarized in Table <ref>.

§.§ Local Training Complexity

The local training complexity of a FL algorithm is associated to the computational cost of training a local DL model per client <cit.>. Since the FedAvg algorithm employs only the standard empirical risk minimization (ERM) with stochastic gradient descent (SGD) during local FL training, it has the lowest local training complexity. The model aggregation focused FL algorithms (pFedLA, FedNova and FedBN) also utilize the same local training procedure with FedAvg, and thus are associated with the lowest local training complexity. However, the local training focused FL algorithms (FedProx, SCAFFOLD, MOON and FedDC) exploit either proximal terms or gradient adjustment techniques that increases local training complexity compared to other algorithms due to additional calculations of loss functions and gradient terms. In particular, the MOON algorithm is the most computationally complex algorithm since it requires additional forward passes to extract image feature vectors using the global model as well as the local model parameters from the previous FL rounds.

§.§ Aggregation Complexity

The aggregation complexity of a FL algorithm refers to the computational cost of aggregating local model parameters from multiple clients to obtain a global model <cit.>. Since the local training focused FL algorithms exploit the standard iterative model averaging during parameter aggregation as in the FedAvg algorithm, these algorithms are associated with the lowest aggregation complexity. Among the other algorithms, FedNova and FedBN does not significantly increase the computational cost of aggregation as they either normalize or sort out local model parameters during aggregation (which are not costly operations). Thus, they are also associated with the lowest aggregation complexity.
However, the pFedLA algorithm requires to train multiple hypernetworks on the central server for the aggregation stage. This significantly increases the aggregation complexity of pFedLA in proportion to the depth of the considered hypernetworks.

§.§ Learning Efficiency

The learning efficiency of a FL algorithm is defined as the minimum number of communication rounds, which is required to achieve a high inference performance of the resulting global model.

We would like to remark that the local models do not converge in the early communication rounds. Accordingly, weighting the local model parameters for model parameter aggregation as in the FedNova and pFedLA algorithms reduces the global model performance on the early rounds of FL training. In detail, during the initial rounds using the BN parameters of each local model during the aggregation increases the alignment of the global model with local data characteristics, and thus leads to higher learning efficiency. However, the FedBN algorithm excludes BN parameters during the aggregation. Thus, it reduces the learning efficiency of the global model if the level of training data heterogeneity is not significantly high. Accordingly, the learning efficiency of the local training focused algorithms (FedProx, SCAFFOLD, MOON, FedDC) is expected to be higher than that of model aggregation focused algorithms (FedNova, FedBN, pFedLA). In particular, the learning efficiency of the FedProx algorithm depends on its $\gamma$ hyperparameter. A high value of $\gamma$ leads to minor updates in local training, which reduces the convergence speed. The convergence rate of the MOON algorithm is very similar to the standard iterative model averaging <cit.>. However, it performs better in later communication rounds as it is less affected by training data heterogeneity. The learning efficiency of the SCAFFOLD and FedDC algorithms is similar since they both utilize gradient adjustment techniques in the same way. In greater details, FedDC slows down the local convergence in the later communication rounds by adding a proximal term to the local objective functions. We would like to note that the capability of the these algorithms in terms of learning efficiency is highly affected by the training data heterogeneity across clients that may lead the algorithms to show different characteristics under different heterogeneity levels <cit.>.

§.§ Communication Cost

The communication cost of a FL algorithm is defined as the amount of parameters required to be transmitted between the considered clients and a central server <cit.>. Thus, it increases with the total number of parameters, which include DL model parameters as well as additional parameters (e.g., hyperparameters, gradients etc.) required to be shared with the central server. The FedAvg, FedProx, MOON, pFedLA, FedNova and FedBN algorithms transmit only the DL model parameters between the central server and the clients. Thus, these algorithms are associated with the lowest communication cost. However, the SCAFFOLD and FedDC algorithms require to also transmit the control variate parameters in addition to the model parameters that leads to higher communication cost than the other algorithms.

§.§ Scalability

The scalability of a FL algorithm is defined as its ability to efficiently handle a large number of participating clients and the corresponding distributed training data while accurately learning a global model <cit.>. As the total number of clients increases, there is a higher chance of increase in the variation among the parameters of local models. This may lead to more deviation of the global model from its global optima compared to when there is less number of participating clients to FL. The model aggregation focused FL algorithms do not address the deviation among the local models of clients during the local training stage. Thus, among all the investigated FL algorithms, they are associated with the lowest scalability towards the number of clients. As the FedProx, MOON and FedDC algorithms add proximal terms to local objectives to directly prevent the deviation between the model parameters, their ability to handle a high number of clients is higher than the other algorithms. Since the SCAFFOLD algorithm employs control variate parameters for preventing the client-drift problem that can also limit the deviation of model parameters, it has moderate ability in terms of scalability.

§ DATA SET DESCRIPTION AND DESIGN OF EXPERIMENTS

§.§ Data Set Description

The experiments were conducted on the BigEarthNet-S2 benchmark archive <cit.>. It includes 590,326 Sentinel-2 images acquired over 10 European countries. For the experiments, we employed a subset of BigEarthNet-S2 that includes images acquired over Austria, Belgium, Finland, Ireland, Lithuania, Serbia and Switzerland. Each image in BigEarthNet-S2 is made up of 120$\times$120 pixels for 10m bands, 60$\times$60 pixels for 20m bands, and 20$\times$20 pixels for 60m bands. 60m bands were not considered in the experiments, while bicubic interpolation was applied to 20m bands. This leads to 120$\times$120 pixels for each of 10 bands. Each image was annotated with multi-labels from the CORINE Land Cover Map (CLC) database of the year 2018. In the
experiments, we utilized the 19 class nomenclature presented
in <cit.>.

Decentralization Scenarios Designed for the BigEarthNet-S2 Benchmark Archive

Scenario     [c]Acquisition Conditions of Each Client             [c]Training Data
DS1         Summer season on all countries         Low

DS2         Summer season on a specific country       Medium

DS3         All seasons on a specific country     High

In the experiments, we used the official train and test splits of BigEarthNet-S2. To perform FL on decentralized and unshared training sets, we defined clients by designing three different decentralization scenarios on the official train split of BigEarthNet-S2 as follows:

* Decentralization Scenario 1 (DS1): The images acquired in summer only were randomly distributed to different clients.

* Decentralization Scenario 2 (DS2): The images acquired in summer only were distributed in a country specific way (i.e., each client holds the images acquired over only one country).

* Decentralization Scenario 3 (DS3): The images acquired in all the seasons were distributed in a country specific way (i.e., each client holds the images acquired over only one country.

Due to the design of decentralization scenarios, each scenario is associated with a different level of training data heterogeneity across clients. The lowest level of heterogeneity is present in DS1, because the images in the same season are randomly distributed to clients. The highest level of heterogeneity is present in DS3, because the training data is decentralized based on the countries, while each client can include images acquired on the same area in different seasons. All the scenarios are summarized in Table <ref>.

§.§ Design of Experiments

In the experiments, we employed the ResNet-50 CNN architecture <cit.> as the backbone of the global model, which is followed by the fully connected layer of 19 neurons to perform multi-label classification (MLC) of RS images. For the training of the global model on decentralized and unshared RS image archives by using each selected FL algorithm, we employed the same FL training procedure. Thus, the number $R$ of communication rounds for FL training was set to $40$. For each decentralization scenario, the number $K$ of clients was varied as $K=7,14,28$. For each client, the same DL architecture with the global model was utilized for the corresponding local model. In one communication round, each local model is trained for $E$ epochs with the mini-batch size of $1024$, while $E$ was varied in the range of $[1,7]$ with the step size $2$. For local model training, we used the Adam variant of stochastic gradient descent with the initial learning rate of $10^{-3}$ and the weight decay of $0.9$. All the experiments were performed on NVIDIA A100 80GB GPUs.

We carried out various experiments to: 1) conduct a sensitivity analysis of the selected FL algorithms in terms of the number $E$ of local epochs and the number $K$ of clients; 2) compare the FL algorithms in terms of MLC accuracy, local training complexity and learning efficiency. The results are provided in terms of $F_1$ score on the official test split of BigEarthNet-S2 for MLC of RS images. The local training complexity of each algorithm is evaluated in terms of its computation time in seconds to complete one communication round of local training. For all the selected FL algorithms, we used the same DL architecture for a fair comparison. For the hyperparameter selection of each algorithm, we followed the same procedure suggested in the corresponding paper. To this end, the hyperparameters $\gamma$ of the FedProx algorithm and $\tau$ of the MOON algorithm were set to $0.01$ and $1$, respectively. The weight of the model-contrastive loss function $\mathcal{L}_{\text{MC}}$ in the MOON algorithm was set to $0.1$.

$F_1$ Scores (%) Obtained by the Selected FL Algorithms Under
Different Number $K$ of Clients and the Decentralization Scenarios

2*Algorithm         3c$K$=7         3c$K$=14                                              3c$K$=28
DS1     DS2     DS3         DS1     DS2     DS3         DS1     DS2     DS3
FedAvg <cit.>                 79.2        52.2        47.5           79.6        51.3        48.7           77.3        48.5        47.6
Focused     FedProx <cit.>             79.5        56.3        53.3           79.7        56.2        55.6           77.4        57.8        54.5

SCAFFOLD <cit.>            78.6        57.2        54.4           80.0        56.9        53.3           78.7          54.2            51.3

MOON <cit.>              81.7        59.5        55.2           81.2        56.5        54.7           80.1        55.3        54.9

FedDC <cit.>              78.8        58.4        57.4           81.3        57.2        53.9           80.2          55.4            54.1
Focused     FedNova <cit.>             80.6        53.7        48.6           80.4        52.2        47.7           79.4        50.4        46.1

pFedLA <cit.>             81.3        56.8        53.6           81.4          55.9          53.2             79.5          54.1            50.9

FedBN <cit.>              78.4        62.3        57.1           78.3          61.2          57.2             77.2          60.4            56.3

§ EXPERIMENTAL RESULTS

We performed experiments in order to:
1) conduct a sensitivity analysis; and 2) compare the effectiveness of the investigated FL algorithms (FedAvg <cit.>, FedProx <cit.>, SCAFFOLD <cit.>, MOON <cit.>, FedDC <cit.>, FedNova <cit.>, pFedLA <cit.>, and FedBN <cit.>).

§.§ Sensitivity Analysis of the Selected FL Algorithms

In the first set of trials, we analyzed the effectiveness of the FL algorithms in terms of the number $E$ of local epochs. Fig. <ref> shows the $F_1$ scores under the decentralization scenario 1 when different numbers $E$ of local epochs are used in the FedProx algorithm. Once can observe from the figure that when $E=3$, the FedProx algorithm achieves the highest $F_1$ scores in the latest rounds of the FL training. From the figure, one can also see that when each local training data is fed to the corresponding local model only once within each communication round (i.e., $E=1$), the FedProx algorithm obtains the lowest $F_1$ scores compared to the higher numbers of local epochs. This is due to the fact that when $E=1$, the change in the local model parameter updates decreases throughout communication rounds compared to higher numbers of epochs. This leads to a slow convergence of the global model. When $E>3$ (i.e., $E=5$ or $E=7$), the divergence among local model parameters increases. This leads to deviation of the global model from its global optima after parameter averaging, and thus ineffective MLC performance. We would like to note that the results of the sensitivity analysis for the number of local epochs were also confirmed through the experiments for the FedAvg, SCAFFOLD, MOON, FedDC, pFedLA, FedNova and FedBN algorithms under all the scenarios (not reported for space constraints). Thus, we set $E$ to $3$ for the rest of experiments.

In the second set of trials, we assessed the effectiveness of the FL algorithms in terms of the number $K$ of clients. Table <ref> shows the $F_1$ scores of FL algorithms when different numbers $K$ of clients are considered under all the scenarios. One can observe from the table that as $K$ increases, most of the algorithms lead to slightly lower $F_1$ scores. This is due to the increase in the variation of the local model parameters when $K$ increases. The effect of the number of clients on the performances of the algorithms is more evident when the number of clients is increased to $28$ from $14$ (i.e., $K=14\rightarrow K=28$). As an example, under DS1, the $F_1$ score of the FedNova algorithm decreases $0.2\%$ when $K=7\rightarrow K=14$, while it decreases $1\%$ when $K=14\rightarrow K=28$. This is due to the fact that the variation among the local models increases more than the increase in the number of clients. In greater details, when the training data heterogeneity across clients increases (i.e., DS1$\rightarrow$DS3), the ability of the algorithms to overcome the higher number of clients (i.e., scalability) generally decreases. As an example, when $K=7\rightarrow K=28$, the $F_1$ score of the MOON algorithm decreases $1.6\%$ and $4.2\%$ under DS1 and DS2, respectively. This is due to fact that as the number of clients increases when training data is distributed across more heterogeneous clients, the variation among the local models further increases. When the FL algorithms are compared among each other in terms of their scalability towards the number of clients, the decrease on $F_1$ scores obtained by the local training focused algorithms are generally lower than the other algorithms. However, the ability of these algorithms towards $K$ is highly affected by the training data heterogeneity across clients, as it can be seen from the table. This is inline with our theoretical analysis in the Section <ref>. We would like to note that for the rest of experiments, we set the number $K$ of clients as $K=7$ for the sake of simplicity.

$F_1$ Scores (%) Obtained by the FL Algorithms Under Decentralization Scenarios

Algorithm         DS1     DS2     DS3
FedAvg <cit.>         79.2        52.2        47.5
Focused     FedProx <cit.>     79.5        56.3      53.3

SCAFFOLD <cit.>    78.6        57.2        54.4

MOON <cit.>      81.7        59.5        55.2

FedDC <cit.>      78.8        58.4        57.4
Focused      FedNova <cit.>     80.6        53.7      48.6

pFedLA <cit.>     81.3        56.8        53.6

FedBN <cit.>      78.4        62.3        57.1

§.§ Comparison of the Selected FL Algorithms

In the first set of trials, we compared the effectiveness of the selected FL algorithms in the context of MLC of RS images. Table <ref> shows the corresponding $F_1$ scores under decentralization scenarios 1 (DS1), 2 (DS2) and 3 (DS3). One can assess from the table that as training data heterogeneity across clients increases through our decentralization scenarios, each algorithm leads to lower $F_1$ scores. As an example, the FedNova algorithm achieves more than $25\%$ and $30\%$ higher scores under DS1 compared to those under DS2 and DS3, respectively. In greater details, under DS1, the $F_1$ scores obtained by the algorithms are close to each other. This is due to the low training data heterogeneity level in DS1, for which the considered FL algorithms do not significantly increase the MLC performance. The algorithms that add proximal terms to the local objective function (i.e., FedProx and MOON) achieve slightly higher results than those obtained by the algorithms based on gradient adjustment techniques (i.e., SCAFFOLD and FedDC) under DS1. As an example, the FedProx algorithm outperforms the FedDC algorithm by 0.4% higher $F_1$ score under DS1. In particular, the highest $F_1$ score was obtained by the MOON algorithm, which is $3.3\%$ higher than that obtained by the worst performing algorithm (i.e., FedBN) under DS1. This indicates that the elimination of batch normalization parameters from model parameter aggregation at the central server decreases MLC performance when the level of data heterogeneity is not significantly high. However, as the training data heterogeneity increases, the differences in $F_1$ scores obtained by the algorithms significantly increases. As the worst performing algorithm under DS1, the FedBN algorithm achieves the highest $F_1$ score under DS2. This shows that FedBN provides more accurate MLC results compared the other algorithms when the concept shift is high. We would like to note that the FedAvg algorithm leads to the lowest scores under both DS2 and DS3 as its learning process is highly interfered by non-IID training data. While comparing the algorithms under DS3, the FedDC algorithm achieves the highest $F_1$ score of $57.4\%$, which is only $1\%$ lower than its performance under DS2. This indicates that the FedDC algorithm is more robust to training data heterogeneity across clients than the other algorithms.

Computation Times (in seconds) Required by the FL Algorithms to Complete One Communication Round of Local Training

Algorithm         [c]Computation Time
(Local Training)
FedAvg <cit.>         184
Focused     FedProx <cit.>     189

SCAFFOLD <cit.>     199

MOON <cit.>     258

FedDC <cit.>     199
FedNova <cit.>     3*184

pFedLA <cit.>

FedBN <cit.>

In the second set of trials, we compared the effectiveness of the considered FL algorithms in terms of their local training complexity. Table <ref> shows the computation times (in seconds) required by all the algorithms to complete one communication round of local training. As one can observe from the table that the computation time required by the FedAvg, FedNova, FedBN and pFedLA algorithms is the same and equal to $184$ seconds, which is lower than those required by other algorithms. This is due to the fact that FedNova, FedBN and pFedLA are model aggregation focused algorithms and apply the same local training strategy with the FedAvg algorithm. The computation time required by the FedProx algorithm is $189$ seconds, which is slightly higher than those required by the model aggregation focused algorithms. This is due to calculating the $L_2$ distance between global and local models in FedProx. The computation time required by the SCAFFOLD and FedDC algorithms is slightly increased compared to that by the FedProx algorithm due to the calculation of the control variate parameters. Since the MOON algorithm extracts the feature vectors of an RS image using three different models, its local training complexity is the highest among other algorithms with the computation time of $258$ seconds.

We would like to note that overall FL training time is also affected by the number $R$ of communication rounds in addition to the computation time per round. The FL algorithms, which are capable of efficiently learning global models, can achieve a high MLC performance under a small number of communication rounds. In the third set of trials, we compared the effectiveness of the FL algorithms in terms of learning efficiency. Fig <ref> shows the $F_1$ scores of the algorithms for the first ten communication rounds under DS1. One can observe from the figure that the local training focused algorithms (FedProx, SCAFFOLD, MOON and FedDC) achieve higher $F_1$ scores at earlier communication rounds compared the model aggregation focused algorithms. As an example, the MOON reaches almost $70\%$ $F_1$ score at the 3rd communication round, while FedNova, FedBN and pFedLA require 5, 10 and 6 communication rounds, respectively, to achieve the same performance. In greater details, after 4 communication rounds the performance of the FedAvg algorithm reaches to that of MOON. This shows that the learning efficiency of FedAvg is also high. Although the selected algorithms that restrict local training by adding proximal terms to the objective function (i.e., FedProx, MOON, FedDC) alleviate the effects of training data heterogeneity, these algorithms slow down the local convergence and limit learning efficiency. Since DS1 is associated with the lowest training data heterogeneity compared to other scenarios, the FedAvg algorithm achieves higher scores in the initial communication rounds than these algorithms. Among the algorithms that utilize gradient adjustment techniques during local training SCAFFOLD shows the highest learning efficiency. This proves that the gradient adjustment using control variates speeds up the convergence.

§ CONCLUSION

In this paper, as a first time in RS, we have presented a comparative study of advanced FL algorithms. To this end, we initially provided the systematic review of the FL algorithms, which are presented in the computer vision community. In accordance with this review, we have selected the state-of-the-art FL algorithms FedProx <cit.>, SCAFFOLD <cit.>, MOON <cit.>, FedDC <cit.>, FedNova <cit.>, pFedLA <cit.>, and FedBN <cit.> based on their effectiveness with respect to training data heterogeneity accross clients. We have provided the extensive overview of the selected algorithms in the framework of multi-label classification (MLC) of RS images, while analyzing their capability to address the challenges of non-IID training data. The considered algorithms have been theoretically compared in terms of their: 1) local training complexity; 2) aggregation complexity; 3) learning efficiency; 4) communication cost; and 5) scalability in terms of number of clients. In addition to the theoretical analyses of these algorithms, we have also experimentally compared them under different decentralization scenarios in terms of MLC performance. We would like to note that all the selected FL algorithms have been considered for the first time in RS. Based on our theoretical and experimental comparison among these algorithms, we have derived a guideline for selecting suitable algorithms in RS as follows:

* The algorithms achieve similar performances when the level of training data heterogeneity is low. Thus, the algorithms associated with lower local training complexity (FedAvg, FedNova, FedBN and pFedLA) can be selected if the training data is not highly non-IID among clients.

* As the training data heterogeneity increases, there is a significant drop in the performance of all the algorithms. However, the MOON, FedDC and FedBN algorithms are more effective towards non-IID training data than the other algorithms. Thus, these algorithms can be selected when the training data is highly non-IID among clients.

* Although MOON performs better than most of the algorithms, its training complexity is the highest among the considered algorithms. Thus, as an alternative, FedBN and FedDC can be selected if the local training complexity needs to be limited.

* The aggregation focused algorithms provide comparable results with the local training focused algorithms. Although their local training complexity is lower, their aggregation complexity is higher than the local training focused algorithms. In particular, the pFedLA algorithm significantly increases the aggregation complexity when the number of clients is high. Thus, FedBN and FedNova can be be selected among the aggregation focused algorithms when the aggregation complexity needs to be limited.

We would like to point out that MLC is selected as the classification task of the considered FL algorithms. Moreover, these algorithms can also be adapted to other classification tasks (e.g., pixel-based classification, single-label classification etc.). This can be easily achieved by utilizing the corresponding loss functions and task heads in the considered DL model. Accordingly, as a future development of this work, we plan to compare the selected algorithms under different classification problems. Moreover, we plan to investigate different client selection strategies during FL training that can reduce the communication cost of the considered FL algorithm for RS images. As a final remark, we would like to note that the considered FL algorithms embody a significant potential for knowledge discovery from distributed RS image archives. We believe that FL will attract more attention for RS images in the upcoming years, and we hope this study will open new promising directions.

§ ACKNOWLEDGMENT

This work is supported by the European Research Council (ERC) through the ERC-2017-STG BigEarth Project under Grant 759764. Furthermore, we gratefully acknowledge funding from the German Federal Ministry of Education and Research under the grant BIFOLD23B.

[]Barış Büyüktaş received the B.S. and M.S. degrees in electrical and electronics engineering from Ozyegin University, Istanbul, Turkey in 2018 and 2020, respectively. He is currently pursuing a Ph.D. degree at the Faculty of Electrical Engineering and Computer Science, Technische Universität Berlin, Germany. He is currently a research associate in the Remote Sensing Image Analysis (RSiM) group, Technische Universität Berlin. His research interests include federated learning, computer vision, pattern recognition, machine learning, and remote sensing.

[]Gencer Sumbul received his B.S. degree in computer engineering from Bilkent University, Ankara, Turkey in 2015, the M.S. degree in computer engineering from Bilkent University in 2018, and the Ph.D. degree from the Faculty of Electrical Engineering and Computer Science, Technische Universität Berlin, Germany in 2023. He is currently a postdoctoral research associate in the Remote Sensing Image Analysis (RSiM) group, Technische Universität Berlin. His research interests include computer vision, pattern recognition and machine learning, with special interest in deep learning, large-scale image understanding and remote sensing. He is a referee for journals such as the IEEE Transactions on Image Processing, IEEE Transactions on Geoscience and Remote Sensing, the IEEE Access, the IEEE Geoscience and Remote Sensing Letters, the ISPRS Journal of Photogrammetry and Remote Sensing and international conferences such as European Conference on Computer Vision and IEEE International Geoscience and Remote Sensing Symposium.

[]Begüm Demir (S'06-M'11-SM'16) received the B.S., M.Sc., and Ph.D. degrees in electronic and telecommunication engineering from Kocaeli University, Kocaeli, Turkey, in 2005, 2007, and 2010, respectively.

She is currently a Full Professor and the founder head of the Remote Sensing Image Analysis (RSiM) group at the Faculty of Electrical Engineering and Computer Science, TU Berlin and the head of the Big Data Analytics for Earth Observation research group at the Berlin Institute for the Foundations of Learning and Data (BIFOLD). Her research activities lie at the intersection of machine learning, remote sensing and signal processing. Specifically, she performs research in the field of processing and analysis of large-scale Earth observation data acquired by airborne and satellite-borne systems. She was awarded by the prestigious ‘2018 Early Career Award’ by the IEEE Geoscience and Remote Sensing Society for her research contributions in machine learning for information retrieval in remote sensing. In 2018, she received a Starting Grant from the European Research Council (ERC) for her project “BigEarth: Accurate and Scalable Processing of Big Data in Earth Observation”. She is an IEEE Senior Member and Fellow of European Lab for Learning and Intelligent Systems (ELLIS).

Dr. Demir is a Scientific Committee member of several international conferences and workshops, such as: Conference on Content-Based Multimedia Indexing, Conference on Big Data from Space, Living Planet Symposium, International Joint Urban Remote Sensing Event, SPIE International Conference on Signal and Image Processing for Remote Sensing, Machine Learning for Earth Observation Workshop organized within the ECML/PKDD. She is a referee for several journals such as the PROCEEDINGS OF THE IEEE, the IEEE TRANSACTIONS ON GEOSCIENCE AND REMOTE SENSING, the IEEE GEOSCIENCE AND REMOTE SENSING LETTERS, the IEEE TRANSACTIONS ON IMAGE PROCESSING, Pattern Recognition, the IEEE TRANSACTIONS ON CIRCUITS AND SYSTEMS FOR VIDEO TECHNOLOGY, the IEEE JOURNAL OF SELECTED TOPICS IN SIGNAL PROCESSING, the International Journal of Remote Sensing), and several international conferences. Currently she is an Associate Editor for the IEEE GEOSCIENCE AND REMOTE SENSING LETTERS, MDPI Remote Sensing and International Journal of Remote Sensing.