1 Introduction↩︎

Federated Learning (FL) is a machine learning framework that enables multiple clients to collaboratively learn a global model in a distributed manner. Each client trains the model on their local data, and then sends only the updated model parameters to a central server for aggregation. Mathematically, FL aims to solve the following optimization problem: \[\label{eq:obj} \min_{x \in \mathbb{R}^d} f(x) := \frac{1}{m} \sum_{i=1}^m f_i(x),\tag{1}\] where \(f_i(x) := \mathbb{E}_{z \sim \mathcal{D}_i} [F_i (x, z)]\) is the loss function of the \(i\)-th client, and \(m\) is the number of clients.

A key property of FL its flexibility in how various clients participate in the overall training procedure. The number of clients, their participation rates, and computing power available to each client can vary and change at any time during the training. Additionally, the local data of each client is not shared with others, resulting in better data privacy [2], [3].

While advantageous, such flexibility also introduces a plethora of new challenges, notably: \(i)\) how the server aggregates the local information coming from each client, and \(ii)\) how to make sure each client meaningfully “learns” using their local data and computing device. The first challenge was partially addressed in [4], where adaptive optimization methods such as Adam [5] was utilized in the aggregation step. Yet, the second challenge remains largely unaddressed.

Local data of each client is not shared, which intrinsically introduces heterogeneity in terms of the size and the distribution of local datasets. That is, \(\mathcal{D}_i\) differs for each client \(i\), as well as the number of samples \(z \sim \mathcal{D}_i\). Consequently, \(f_i(x)\) can vastly differ from client to client, making the problem in 1 hard to optimize. Moreover, the sheer amount of local updates is far larger than the number of aggregation steps, due to the high communication cost—typically 3-4\(\times\) orders of magnitude more expensive than local computation—in distributed settings [6].

As a result, extensive fine-tuning of the client optimizers is often required to achieve good performance in FL scenarios. For instance, experimental results of the well-known FedAvg algorithm were obtained after performing a grid-search of typically 11-13 step sizes of the clients’ SGD [2], as SGD (and its variants) are highly sensitive to the step size [7]–[9]. Similarly, in [4], 6 different client step sizes were grid-searched for different tasks, and not surprisingly, each task requires a different client step size to obtain the best result, regardless of the server-side adaptivity [4]. Importantly, even these “fine-tunings” are done under the setting that all clients use the same step size, which is sub-optimal, given that \(f_i\) can be vastly different per client; we analyze this further in Section [sec:adaptive-stepsize].

Initial examination as motivation. The implication of not properly tuning the client optimizer is highlighted in Figure 1. We plot the progress of test accuracies for different client optimizers, where, for all the other test cases, we intentionally use the same step size rules that were fine-tuned for the task in Figure 1 (A). There, we train a ResNet-18 for CIFAR-10 dataset classification within an FL setting, where the best step sizes for each (client) optimizer was used after grid-search; we defer the experimental details to Section 4. Hence, all methods perform reasonably well, although \(\Delta\)-SGD, our proposed method, achieves noticeably better test accuracy when compared to non-adaptive SGD variants –e.g., a 5% difference in final classification accuracy from SGDM– and comparable final accuracy only with adaptive SGD variants, like Adam and Adagrad.

In Figure 1 (B), we train a shallow CNN for MNIST classification, using the same step sizes from (A). MNIST classification is now considered an “easy” task, and therefore SGD with the same constant and decaying step sizes from Figure 1 (A) works well. However, with momentum, SGDM exhibits highly oscillating behavior, which results in slow progress and poor final accuracy, especially without decaying the step size. Adaptive optimizers, like Adam and Adagrad, show similar behavior, falling short in achieving good final accuracy, compared to their performance in the case of Figure 1 (A).

Similarly, in Figure 1 (C), we plot the test accuracy progress for CIFAR-100 classification trained on a ResNet-50, again using the same step size rules as before. Contrary to Figure 1 (B), SGD with momentum (SGDM) works better than SGD, both with the constant and the decaying step sizes. Adam becomes a “good optimizer” again, but its “sibling,” Adagrad, performs worse than SGDM. On the contrary, our proposed method, \(\Delta\)-SGD, which we introduce in Section 3, achieves superior performance in all cases without any additional tuning.

The above empirical observations beg answers to important and non-trivial questions in training FL tasks using variants of SGD methods as the client optimizer: Should the momentum be used? Should the step size be decayed? If so, when? Unfortunately, Figure 1 indicates that the answers to these questions highly vary depending on the setting; once the dataset itself or how the dataset is distributed among different clients changes, or once the model architecture changes, the client optimizers have to be properly re-tuned to ensure good performance. Perhaps surprisingly, the same holds for adaptive methods like Adagrad [10] and Adam [5].

Our hypothesis and contributions. Our paper takes a stab in this direction: we propose DELTA-SGD (DistributEd LocaliTy Adaptive SGD), a simple adaptive distributed SGD scheme, that can automatically tune its step size based on the available local data. We will refer to our algorithm as \(\Delta\)-SGD in the rest of the text. Our contributions can be summarized as follows:

• We propose \(\Delta\)-SGD, which has two implications in FL settings: \(i)\) each client can use its own step size, and \(ii)\) each client’s step size adapts to the local smoothness of \(f_i\) –hence LocaliTy Adaptive– and can even increase during local iterations. Moreover, due to the simplicity of the proposed step size, \(\Delta\)-SGD is agnostic to the loss function and the server optimizer, and thus can be combined with methods that use different loss functions such as FedProx [11] or MOON [12], or adaptive server methods such as FedAdam [4].

• We provide convergence analysis of \(\Delta\)-SGD in a general nonconvex setting (Theorem 1). We also prove convergence in convex setting; due to space constraints, we only state the result of the general nonconvex case in Theorem 1, and defer other theorems and proofs to Appendix 6.

• We evaluate our approach on several benchmark datasets and demonstrate that \(\Delta\)-SGD achieves superior performance compared to other state-of-the-art FL methods. Our experiments show that \(\Delta\)-SGD can effectively adapt the client step size to the underlying local data distribution, and achieve convergence of the global model without any additional tuning. Our approach can help overcome the client step size tuning challenge in FL and enable more efficient and effective collaborative learning in distributed systems.

2 Preliminaries and Related Work↩︎

A bit of background on optimization theory. Arguably the most fundamental optimization algorithm for minimizing a function \(f(x): \mathbb{R}^d \rightarrow \mathbb{R}\) is the gradient descent (GD), which iterates with the step size \(\eta_t\) as: \(x_{t+1} = x_t - \eta_t \nabla f(x_t)\). Under the assumption that \(f\) is globally \(L\)-smooth, that is: \[\label{eq:L-smooth} \| \nabla f(x) - \nabla f(y) \| \leqslant L \cdot \| x - y \| \quad \forall x, y \in \mathbb{R}^d,\tag{2}\] the step size \(\eta_t = \frac{1}{L}\) is the “optimal” step size for GD, which converges for convex \(f\) at the rate: \[\label{eq:gd-rate-smooth} f(x_{t+1}) - f(x^\star) \leqslant\frac{L \|x_0 - x^\star \|^2}{ 2 (2t+1)}.\tag{3}\]

Limitations of popular step sizes. In practice, however, the constants like \(L\) are rarely known [13]. As such, there has been a plethora of efforts in the optimization community to develop a universal step size rule or method that does not require a priori knowledge of problem constants so that an optimization algorithm can work as “plug-and-play” [14]–[16]. A major lines of work on this direction include: \(i)\) line-search [17], [18], \(ii)\) adaptive learning rate (e.g., Adagrad [10] and Adam [5]), and \(iii)\) Polyak step size [19], to name a few.

Unfortunately, the pursuit of finding the “ideal” step size is still active [20]–[22], as the aforementioned approaches have limitations. For instance, to use line search, solving a sub-routine is required, inevitably incurring additional evaluations of the function and/or the gradient. To use methods like Adagrad and Adam, the knowledge of \(D\), the distance from the initial point to the solution set, is required to ensure good performance [21]. Similarly, Polyak step size requires knowledge of \(f(x^\star)\) [23], which is not always known a priori, and is unclear what value to use for an arbitrary loss function and model; see also Section 4 where not properly estimating \(D\) or \(f(x^\star)\) resulting in suboptimal performance of relevant client optimizers in FL scenarios.

Implications in distributed/FL scenarios. The global \(L\)-smoothness in 2 needs to be satisfied for all \(x\) and \(y\), implying even finite \(L\) can be arbitrarily large. This results in a small step size, leading to slow convergence, as seen in 3 . [24] attempted to resolve this issue by proposing a step size for (centralized) GD that depends on the local smoothness of \(f\), which by definition is smaller than the global smoothness constant \(L\) in 2 . \(\Delta\)-SGD is inspired from this work.

Naturally, the challenge is aggravated in the distributed case. To solve 1 under the assumption that each \(f_i\) is \(L_i\)-smooth, the step size of the form \({1}/{L_\text{max}}\) where \({L_\text{max}} := \max_i L_i\) is often used [25]–[27], to ensure convergence [28]. Yet, one can easily imagine a situation where \(L_i \gg L_j\) for \(i \neq j,\) in which case the convergence of \(f_j(x)\) can be arbitrarily slow by using step size of the form \({1}/{L_\text{max}}\).

Therefore, to ensure that each client learns useful information in FL settings as in 1 , ideally: \(i)\) each agent should be able to use its own step size, instead of crude ones like \(1/L_{\text{max}}\) for all agents; \(ii)\) the individual step size should be “locally adaptive” to the function \(f_i,\) (i.e., even \(1/L_i\) can be too crude, analogously to the centralized GD); and \(iii)\) the step size should not depend on problem constants like \(L_i\) or \(\mu_i\), which are often unknown. In Section 3, we introduce DistributEd LocaliTy Adaptive SGD (\(\Delta\)-SGD), which satisfies all of the aforementioned desiderata.

Related work on FL. The FL literature is vast; here, we focus on the results that closely relate to our work. The FedAvg algorithm [2] is one of the simplest FL algorithms, which averages client parameters after some local iterations. [4] showed that FedAvg is a special case of a meta-algorithm, where both the clients and the server use SGD optimizer, with the server learning rate being 1. To handle data heterogeneity and model drift, they proposed using adaptive optimizers at the server. This results in algorithms such as FedAdam and FedYogi, which respectively use the Adam [5] and Yogi [29] as server optimizers. Our approach is orthogonal and complimentary to this, as we propose a client adaptive optimizer that can be easily combined with these server-side aggregation methods (c.f., Appendix 7.4).

Other approaches have handled the heterogeneity by changing the loss function. FedProx [11] adds an \(\ell_2\)-norm proximal term to to handle data heterogeneity. Similarly, MOON [12] uses the model-contrastive loss between the current and previous models. Again, our proposed method can be seamlessly combined with these approaches (c.f., Table [tbl:tab:fedprox], Appendix 7.6 and 7.5).

The closest related work to ours is a concurrent work by [30]. There, authors utilize the Stochastic Polyak Stepsize [20] in FL settings. We do include SPS results in Section 4. There are some previous works that considered client adaptivity, including AdaAlter [31] and [32]. Both works utilize an adaptive client optimizer similar to Adagrad. However, AdaAlter incurs twice the memory compared to FedAvg, as AdaAlter requires communicating both the model parameters as well as the “client accumulators”; similarly, [32] requires complicated local and global correction steps to achieve good performance. In short, previous works that utilize client adaptivity require modification in server-side aggregation; without such heuristics, Adagrad [10] exhibits suboptimal performance, as seen in Table ¿tbl:tab:results?.

Lastly, another line of works attempts to handle heterogeneity by utilizing control-variates [33]–[35], a similar idea to variance reduction from single-objective optimization [36], [37]. While theoretically appealing, these methods either require periodic full gradient computation or are not usable under partial client participation, as all the clients must maintain a state throughout all rounds.

3 DELTA(\(\Delta\))-SGD: Distributed locality adaptive SGD↩︎

We now introduce \(\Delta\)-SGD. In its simplest form, client \(i\) at communication round \(t\) uses the step size: \[\label{eq:locality-stepsize} \eta_t^i = \min \Big\{ \tfrac{\|x_t^i - x_{t-1}^i \|}{2 \| \nabla f_i(x_t^i) - \nabla f_i (x_{t-1}^i) \|}, \sqrt{ 1 + \theta_{t-1}^i } \eta_{t-1}^i \Big\}, \quad \theta_{t-1}^i = \eta_{t-1}^i/\eta_{t-2}^i.\tag{4}\] The first part of \(\min\{\cdot, \cdot\}\) approximates the (inverse of) local smoothness of \(f_i\),² and the second part controls how fast \(\eta_t^i\) can increase. Indeed, \(\Delta\)-SGD with 4 enjoys the following decrease in the Lyapunov function: \[\begin{align} &\| x_{t+1} - x^\star \|^2 + \frac{1}{2m} \sum_{i=1}^m \| x_{t+1}^i - x_t^i \|^2 + \frac{2}{m} \sum_{i=1}^m \Big[ \eta_{t+1}^i \theta_{t+1}^i \big( f_i(x_t^i) - f_i(x^\star) \big) \Big] \nonumber \\ &\qquad\leqslant \| x_t - x^\star \|^2 + \frac{1}{2m} \sum_{i=1}^m \| x_t^i - x_{t-1}^i \|^2 + \frac{2}{m} \sum_{i=1}^m \Big[ \eta_t^i \theta_t^i \big( f_i(x_{t-1}^i) - f_i(x^\star) \big) \Big], \end{align}\] when \(f_i\)’s are assumed to be convex (c.f., Theorem 2 in Appendix 6). For the FL settings, we extend 4 by including stochasticity and local iterations, as summarized in Algorithm 2 and visualized in Figure 8. For brevity, we use \(\tilde{\nabla}f_i(x) = \frac{1}{|\mathcal{B}|} \sum_{z\in\mathcal{B}} \nabla F_i(x,z)\) to denote the stochastic gradients with batch size \(|\mathcal{B}| = b\).

We make a few remarks of Algorithm 2. First, the input \(\theta_0 > 0\) can be quite arbitrary, as it can be corrected, per client level, in the first local iteration (line 10); similarly for \(\eta_0 > 0\), although \(\eta_0\) should be sufficiently small to prevent divergence in the first local step. Second, we include the “amplifier” \(\gamma\) to the first condition of step size (line 9), but this is only needed for Theorem 1.³ Last, \(\tilde{\nabla} f_i (x_{t,k-1}^i)\) shows up twice: in updating \(x_{t,k}^i\) (line 8) and \(\eta_{t, k}^i\) (line 9). Thus, one can use the same or different batches; we use the same batches in experiments to prevent additional gradient evaluations.

3.1 Convergence Analysis↩︎

Technical challenges. The main difference of analyzing Algorithm 2 compared to other decentralized optimization algorithms is that the step size \(\eta_{t, k}^i\) not only depends on the round \(t\) and local steps \(k\), but also on \(i\), the client. To deal with the client-dependent step size, we require a slightly non-standard assumption on the dissimilarity between \(f\) and \(f_i\), as detailed below.

Assumption ?? has been standard in stochastic optimization literature [38]–[40]; recently, this assumption has been relaxed to weaker ones such as expected smoothness [41], but this is out of scope of this work. Assumption ?? is fairly standard in nonconvex optimization [29], [42], and often used in FL setting [4], [31], [43]. Assumption ?? is reminiscent of the strong growth assumption in stochastic optimization [44], which is still used in recent works [45]–[47]. To the best of our knowledge, this is the first theoretical analysis of the FL setting where clients can use their own step size. We now present the main theorem.

The convergence result in Theorem 1 implies a sublinear convergence to an \(\varepsilon\)-first order stationary point with at least \(T=\mathcal{O}(\varepsilon^{-2})\) communication rounds. We remind again that the conditions on \(\gamma\) and \(\eta_0\) are only required for our theory.⁴ Importantly, we did not assume \(f_i\) is globally \(L\)-smooth, a standard assumption in nonconvex optimization and FL literature [4], [11], [42], [48]; instead, we can obtain a smaller quantity, \(\tilde{L}\), through our analysis; for space limitation, we defer the details and the proof to Appendix 6.

4 Experimental Setup and Results↩︎

We now introduce the experimental setup and discuss the results. Our implementation can be found in https://github.com/jlylekim/auto-tuned-FL.

Datasets and models. We consider image classification and text classification tasks. We use four datasets for image classification: MNIST, FMNIST, CIFAR-10, and CIFAR-100 [49]. For MNIST and FMNIST, we train a shallow CNN with two convolutional and two fully-connected layers, followed by dropout and ReLU activations. For CIFAR-10, we train a ResNet-18 [50]. For CIFAR-100, we train both ResNet-18 and ResNet-50 to study the effect of changing the model architecture. For text classification, we use two datasets: DBpedia and AGnews datasets [51], and train a DistillBERT [52] for classification.

For each dataset, we create a federated version by randomly partitioning the training data among \(100\) clients (\(50\) for text classification), with each client getting \(500\) examples. To control the level of non-iidness, we apply latent Dirichlet allocation (LDA) over the labels following [53], where the degree class heterogeneity can be parameterized by the Dirichlet concentration parameter \(\alpha.\) The class distribution of different \(\alpha\)’s is visualized in Figure 9 in Appendix 7.9.

FL setup and optimizers. We fix the number of clients to be \(100\) for the image classification, and \(50\) for the text classification; we randomly sample \(10 \%\) as participating clients. We perform \(E\) local epochs of training over each client’s dataset. We utilize mini-batch gradients of size \(b = 64\) for the image classification, and \(b=16\) for the text classification, leading to \(K \approx \lfloor \tfrac{E \cdot 500}{b} \rfloor\) local gradient steps; we use \(E=1\) for all settings. For client optimizers, we compare stochastic gradient descent (SGD), SGD with momentum (SGDM), adaptive methods including Adam [5], Adagrad [10], SGD with stochastic Polyak step size (SPS) [20], and our proposed method: \(\Delta\)-SGD in Algorithm 2. As our focus is on client adaptivity, we mostly present the results using FedAvg [2] as the server optimizer; additional results using FedAdam can be found in Appendix 7.4.

Hyperparameters. For each optimizer, we perform a grid search of learning rates on a single task: CIFAR-10 classification trained with a ResNet-18, with Dirichlet concentration parameter \(\alpha=0.1\); for the rest of the settings, we use the same learning rates. For SGD, we perform a grid search with \(\eta \in \{0.01, 0.05, 0.1, 0.5\}\). For SGDM, we use the same grid for \(\eta\) and use momentum parameter \(\beta = 0.9\). To properly account for the SGD(M) fine-tuning typically done in practice, we also test dividing the step size by 10 after \(50\%\), and again by 10 after \(75\%\) of the total training rounds (LR decay). For Adam and Adagrad, we grid search with \(\eta \in \{0.001, 0.01, 0.1\}.\) For SPS, we use the default setting of the official implementation.⁵ For \(\Delta\)-SGD, we append \(\delta\) in front of the second condition: \(\sqrt{ 1 + \delta \theta_{t,k-1}^i } \eta_{t,k-1}^i\) following [24], and use \(\delta=0.1\) for all experiments.⁶ Finally, for the number of rounds \(T\), we use \(500\) for MNIST, \(1000\) for FMNIST, \(2000\) for CIFAR-10 and CIFAR-100, and \(100\) for the text classification tasks.

4.1 Results↩︎

We clarify again that the best step size for each client optimizer was tuned via grid-search for a single task: CIFAR-10 classification trained with a ResNet-18, with Dirichlet concentration parameter \(\alpha=0.1\). We then intentionally use the same step size in all other tasks to highlight two points: \(i)\) \(\Delta\)-SGD works well without any tuning across different datasets, model architectures, and degrees of heterogeneity; \(ii)\) other optimizers perform suboptimally without additional tuning.

Changing the level of non-iidness. We first investigate how the performance of different client optimizers degrade in increasing degrees of heterogeneity by varying the concentration parameter \(\alpha\in \{ 1, 0.1, 0.01\}\) multiplied to the prior of Dirichlet distribution, following [53].

Three illustrative cases are visualized in Figure 3. We remind that the step sizes are tuned for the task in Figure 3 (A). For this task, with \(\alpha=1\) (i.e., closer to iid), all methods perform better than \(\alpha=0.1,\) as expected. With \(\alpha=0.01,\) which is highly non-iid (c.f., Figure 9 in Appendix 7.9), we see a significant drop in performance for all methods. SGD with LR decay and \(\Delta\)-SGD perform the best, while adaptive methods like Adam (\(85\% \rightarrow 22.1\%\)) and Adagrad (\(84.1\% \rightarrow 12.5\%\)) degrade noticeably more than other methods.

Figure 3 (B) shows the results of training FMNIST with a CNN. This problem is generally considered easier than CIFAR-10 classification. The experiments show that the performance degradation with varying \(\alpha\)’s is much milder in this case. Interestingly, adaptive methods such as Adam, Adagrad, and SPS perform much worse than other methods

Lastly, in Figure 3 (C), results for CIFAR-100 classification trained with a ResNet-50 are illustrated. \(\Delta\)-SGD exhibits superior performance in all cases of \(\alpha\). Unlike MNIST and FMNIST, Adam enjoys the second (\(\alpha=0.1\)) or the third (\(\alpha=1\)) best performance in this task, complicating how one should “tune” Adam for the task at hand. Other methods, including SGD with and without momentum/LR decay, Adagrad, and SPS, perform much worse than \(\Delta\)-SGD.

Changing the model architecture/dataset. For this remark, let us focus on CIFAR-100 trained on ResNet-18 versus on ResNet-50, with \(\alpha=0.1\), illustrated in Figure 4 (A). SGD and SGDM (both with and without LR decay), Adagrad, and SPS perform worse using ResNet-50 than ResNet-18. This is a counter-intuitive behavior, as one would expect to get better accuracy by using a more powerful model, although the step sizes are tuned on ResNet-18. \(\Delta\)-SGD is an exception: without any additional tuning, \(\Delta\)-SGD can improve its performance. Adam also improves similarly, but the achieved accuracy is significantly worse than that of \(\Delta\)-SGD.

We now focus on cases where the dataset changes, but the model architecture remains the same. We mainly consider two cases, illustrated in Figure 4 (B) and (C): When CNN is trained for classifying MNIST versus FMNIST, and when ResNet-18 is trained for CIFAR-10 versus CIFAR-100. From (B), one can infer the difficulty in tuning SGDM: without the LR decay, SGDM only achieves around 78% accuracy for MNIST classification, while SGD without LR decay still achieves over \(96\%\) accuracy. For FMNIST on the other hand, SGDM performs relatively well, but adaptive methods like Adam, Adagrad, and SPS degrade significantly.

Aggravating the complexity of fine-tuning SGD(M) for MNIST, one can observe from (C) a similar trend in CIFAR-10 trained with ResNet-18. In that case, \(\Delta\)-SGD does not achieve the best test accuracy (although it is the second best with a pretty big margin with the rest), while SGD with LR decay does. However, without LR decay, the accuracy achieved by SGD drops more than 11%. Again, adaptive methods like Adam, Adagrad, and SPS perform suboptimally in this case.

Changing the domain: text classification. In Table ¿tbl:tab:text?, we make a bigger leap, and test the performance of different client optimizers for text classification tasks. We use the DBpedia and AGnews datasets [51], and train a DistillBERT [52] for classification. Again, the best step size for each client optimizer was tuned for the CIFAR-10 image classification trained with a ResNet-18, for \(\alpha=0.1\). Thus, the type of the dataset changed completely from image to text, as well as the model architecture: from vision to language.

Not surprisingly, four methods (SGDM, SGDM(\(\downarrow\)), Adam, and Adagrad) ended up learning nothing (i.e., the achieved accuracy is 1/(# of labels)), indicating the fine-tuned step sizes for these methods using CIFAR-10 classification task was too large for the considered text classification tasks. \(\Delta\)-SGD, on the other hand, still achieves competitive accuracies without additional tuning, thanks to the locality adaptive step size. Interestingly, SGD, SGD(\(\downarrow\)), and SPS worked well for the text classification tasks, which is contrary to their suboptimal performances for image classification tasks in Table ¿tbl:tab:results?.

Changing the loss function. In Table [tbl:tab:fedprox], we illustrate how \(\Delta\)-SGD performs when combined with a different loss function, such as FedProx [11]. FedProx aims to address heterogeneity; we thus used the lowest concentration parameter, \(\alpha=0.01\). We only present a subset of results: CIFAR-10(100) classification with ResNet-18(50) (additional results in Appendix 7.6). The results show that \(\Delta\)-SGD again outperforms all other methods with a significant margin: \(\Delta\)-SGD is not only the best, but also the performance difference is at least 2.5%, and as large as 26.9%. Yet, compared to the original setting without the proximal term in Table ¿tbl:tab:results?, it is unclear whether or not the additional proximal term helps. For \(\Delta\)-SGD, the accuracy increased for CIFAR-10 with ResNet-18, but slightly got worse for CIFAR-100 with ResNet-50; a similar story applies to other methods.

Other findings. We present all the omitted theorems and proofs in Appendix 6, and additional empirical findings in Appendix 7. Specifically, we demonstrate: the robustness of the performance of \(\Delta\)-SGD (Appendix 7.1), the effect of the different numbers of local iterations (Appendix 7.2), additional experiments when the size of local dataset is different per client (Appendix 7.3), additional experimental results using FedAdam [4] (Appendix 7.4), additional experiential results using MOON (Appendix 7.5) and FedProx (Appendix 7.6) loss functions, and three independent trials for a subset of tasks (Appendix 7.7). We also visualize the step size conditions for \(\Delta\)-SGD (Appendix 7.8) as well as the degree of heterogeneity (Appendix 7.9).

5 Conclusion↩︎

In this work, we proposed \(\Delta\)-SGD, a distributed SGD scheme equipped with an adaptive step size that enables each client to use its own step size and adapts to the local smoothness of the function each client is optimizing. We proved the convergence of \(\Delta\)-SGD in the general nonconvex setting and presented extensive empirical results, where the superiority of \(\Delta\)-SGD is shown in various scenarios without any tuning. For future works, extending \(\Delta\)-SGD to a coordinate-wise step size in the spirit of [5], [10], applying the step size to more complex algorithms like (local) factored gradient descent [54], and enabling asynchronous updates [55]–[57] could be interesting directions.

Acknowledgments↩︎

This work is supported by NSF FET: Small No. 1907936, NSF MLWiNS CNS No. 2003137 (in collaboration with Intel), NSF CMMI No. 2037545, NSF CAREER award No. 2145629, NSF CIF No. 2008555, Rice InterDisciplinary Excellence Award (IDEA), NSF CCF No. 2211815, NSF DEB No. 2213568, and Lodieska Stockbridge Vaughn Fellowship.

Supplementary Materials for “Adaptive Federated Learning with Auto-Tuned Clients”↩︎

In this appendix, we provide all missing proofs that were not present in the main text, as well as additional plots and experiments. The appendix is organized as follows.

• In Appendix 6, we provide all the missing proofs. In particular:

  • In Section 6.1, we provide the proof of Algorithm 2, under Assumption 1.

  • In Section 6.2, we provide the proof of Algorithm, 2, with some modified assumptions, including that \(f_i\) is convex for all \(i \in [m]\).

• In Appendix 7, we provide additional experiments, as well as miscellaneous plots that were missing in the main text due to the space constraints. Specifically:

  • In Section 7.1, we provide some perspectives on the ease of tuning of \(\Delta\)-SGD in Algorithm 2.

  • In Section 7.2, we provide some perspectives on how \(\Delta\)-SGD performs using different number of local iterations.

  • In Section 7.3, we provide additional experimental results where each client has different number of samples as local dataset.

  • In Section 7.4, we provide additional experimental results using FedAdam [4] server-side adaptive method.

  • In Section 7.5, we provide additional experimental results using MOON [12] loss function.

  • In Section 7.6, we provide additional experiemtns using FedProx [11] loss function.

  • In Section 7.7, we perform three independent trials for a subset of tasks for all client-optimizers. We plot the average and the standard deviations in Figure 7, and report those values in Table ¿tbl:tab:standard-dev?.

  • In Section 7.8, we visualize the step size conditions for \(\Delta\)-SGD.

  • In Section 7.9, we provide illustration of the different level of heterogeneity induced by the Dirichlet concentration parameter \(\alpha\).

6 Missing Proofs↩︎

We first introduce the following two inequalities, which will be used in the subsequent proofs: \[\begin{align} \langle x_i, x_j\rangle &\leqslant\frac{1}{2}\| x_i\|^2 + \frac{1}{2}\| x_j\|^2, \quad \text{and} \tag{5} \\ \Big \|\sum_{i=1}^m x_i \Big \|^2 &\leqslant m \sum_{i=1}^m \Big \| x_i \big \|^2, \tag{6} \end{align}\] for any set of \(m\) vectors \(\{x_i\}_{i{=}1}^m\) with \(x_i\in\mathbb{R}^{d}\).

We also provide the following lemma, which establishes \(\tilde{L}\)-smoothness based on the local smoothness.

Now, we define \(\tilde{L}_i:=\max_t \tilde{L}_{i, t}\). Given this definition, we relate the local-smoothness constant \(\tilde{L}\) of the average function \(f\) with (individual) local-smoothness constants \(\tilde{L}_i\) in the below lemma.

6.1 Proof of Algorithm 2 under Assumption 1↩︎

6.2 Proof of Algorithm 2 for convex case↩︎

Here, we provide an extension of the proof of [24] for the distributed version. Note that the proof we provide here is not exactly the same version of \(\Delta\)-SGD presented in Algorithm 2; in particular, we assume no local iterations, i.e., \(k=1\) for all \(i \in [m]\), and every client participate, i.e, \(p=1\), without stochastic gradients.

We start by constructing a Lyapunov function for the distributed objective in 1 .

The above lemma, which we prove below, constructs a contracting Lyapunov function, which can be seen from the second condition on the step size \(\eta_t^i:\) \[\begin{align} \eta_{t+1}^i \leqslant\sqrt{1 + \theta_t^i} \eta_t^i \implies \eta_{t+1}^i \theta_{t+1}^i \leqslant(1+\theta_t^i) \eta_t^i. \end{align}\]

7 Additional Experiments and Plots↩︎

7.1 Ease of tuning↩︎

In this subsection, we show the effect of using different parameter \(\delta\) in the step size of \(\Delta\)-SGD. As mentioned in Section 4, for \(\Delta\)-SGD, we append \(\delta\) in front of the second condition, and hence the step size becomes \[\eta_{t,k}^i = \min \Big\{ \tfrac{\gamma \|x_{t,k}^i - x_{t,{k-1}}^i \|}{2 \| \tilde{\nabla} f_i(x_{t,k}^i) - \tilde{\nabla} f_i (x_{t,{k-1}}^i) \|} , \sqrt{ 1 + \delta \theta_{t,k-1}^i } \eta_{t,k-1}^i \Big\}.\] The experimental results presented in Table ¿tbl:tab:results? were obtained using a value of \(\delta=0.1\). For \(\gamma\), we remind the readers that we did not change from the default value \(\gamma=2\) in the original implementation in https://github.com/ymalitsky/adaptive_GD/blob/master/pytorch/optimizer.py.

In Figure 5, we display the final accuracy achieved when using different values of \(\delta\) from the set \(\{0.01, 0.1, 1\}\). Interestingly, we observe that \(\delta\) has very little impact on the final accuracy. This suggests that \(\Delta\)-SGD is remarkably robust and does not require much tuning, while consistently achieving higher test accuracy compared to other methods in the majority of cases as shown in Table ¿tbl:tab:results?.

7.2 Effect of different number of local iterations↩︎

In this subsection, we show the effect of the different number of local epochs, while fixing the experimental setup to be the classification of CIFAR-100 dataset, trained with a ResNet-50. We show for all three cases of the Dirichlet concentration parameter \(\alpha \in \{0.01, 0.1, 1\}\). The result is shown in Figure 6.

As mentioned in the main text, instead of performing local iterations, we instead perform local epochs \(E,\) similarly to [4], [11]. All the results in Table ¿tbl:tab:results? use \(E=1,\) and in Figure 6, we show the results for \(E \in \{1, 2, 3\}\). Note that in terms of \(E\), the considered numbers might be small difference, but in terms of actual local gradient steps, they differ significantly.

As can be seen, using higher \(E\) leads to slightly faster convergence in all cases of \(\alpha.\) However, the speed-up seems marginal compared to the amount of extra computation time it requires (i.e., using \(E=2\) takes roughly twice more total wall-clock time than using \(E=1\)). Put differently, \(\Delta\)-SGD performs well with only using a single local epoch per client (\(E=1\)), and still can achieve great performance.

7.3 Additional experiments using different number of local data per client↩︎

In this subsection, we provide additional experimental results, where the size of the local dataset each client has differs. In particular, instead of distributing \(500\) samples to each client as done in Section 4 of the main text, we distribute \(n_i \in [100, 500]\) samples for each client \(i\), where \(n_i\) is the number of samples that client \(i\) has, and is randomly sampled from the range \([100, 500]\). We keep all other settings the same.

Then, in the server aggregation step (line 13 of Algorithm 2), we compute the weighted average of the local parameters, instead of the plain average, as suggested in [2], and used for instance in [4].

We experiment in two settings: CIFAR-10 dataset classification trained with a ResNet-18 [50], with Dirichlet concentration parameter \(\alpha=0.1,\) which was the setting where the algorithms were fined-tuned using grid search; please see details in Section 4. We also provide results for CIFAR-100 dataset classification trained with a ResNet-50, with the same \(\alpha.\)

The result can be found in Table ¿tbl:tab:diff-local-data?. Similarly to the case with same number of data per client, \(i.e., n_i = 500\) for all \(i \in [m],\) we see that \(\Delta\)-SGD achieves good performance without any additional tuning. In particular, for CIFAR-10 classification trained with a ResNet-18, \(\Delta\)-SGD achieves the second best performance after SGD (without LR decay), with a small margin. Interestingly, SGDM (both with and without LR decay) perform much worse than SGD. This contrasts with the same setting in Table ¿tbl:tab:results?, where SGDM performed better than SGD, which again complicates how one should tune client optimizers in the FL setting. For CIFAR-100 classification trained with ResNet-50, \(\Delta\)-SGD outperforms all other methods with large margin.

7.4 Additional experiments using FedAdam↩︎

As mentioned in Section 2 of the main text, since our work focuses on client adaptivity, our method can seamlessly be combined with server-side adaptivity like FedAdam [4]. Here, we provide additional experiments using the FedAdam server optimizer.

A big downside of the adaptive server-side approach like FedAdam is that it adds at least one more hyperparameter to tune: the step size for the global optimizer, set aside the two “momentum” parameters (\(\beta_1\) and \(\beta_2\)) in the case of Adam. This necessity to tune additional parameters is quite orthogonal to the approach we take, where we try to remove the need for step size tuning.

Indeed, as can be seen in [4][Appendix D.2], 9 different server-side global optimizer step size is grid-searched, and [4][Table 8] shows the best performing server learning rate differs for each task.

That being said, we simply used the default step size and momentum values of Adam (from Pytorch), to showcase that our method can seamlessly combined with FedAdam. Due to time constraints, we tested up to CIFAR-100 trained with a ResNet-18, so that all datasets are covered. The result can be found below.

For three out of four cases, \(\Delta\)-SGD equipped with Adam server-side optimizer achieves the best accuracy with large margin. For the last case, CIFAR-100 trained with a ResNet-18, SGD with decaying step size achieves noticeably better accuracy than \(\Delta\)-SGD; however, we refer the readers to Table ¿tbl:tab:results? where for the same setting, \(\Delta\)-SGD equipped with simple averaging achieves \(61.1\%\) accuracy, without any tuning.

7.5 Additional experiments using MOON↩︎

Here, we provide additional experimental results using MOON [12], which utilizes model-contrastive learning to handle heterogeneous data. In this sense, the goal of MOON is very similar to that of FedProx [11]; yet, due to the model-contrastive learning nature, it can incur bigger memory overhead compared to FedProx, as one needs to keep track of the previous model(s) to compute the representation of each local batch from the local model of last round, as well as the global model.

As such, we only ran using MOON for CIFAR-10 classification using a ResNet-18; for the CIFAR-100 classification using a ResNet-50, our computing resource ran out of memory to run the same configuration we ran in the main text.

The results are summarized in Table ¿tbl:tab:moon?. As can be seen, even ignoring the fact that MOON utilizes more memory, MOON does not help for most of the optimizers–it actually often results in worse final accuracies than the corresponding results in Table ¿tbl:tab:results? from the main text.

7.6 Additional experiments using FedProx↩︎

Here, we provide the complete result of Table [tbl:tab:fedprox], conducting the experiment using FedProx loss function for the most heterogeneous case (\(\alpha=0.01\)) for all datasets and architecture considered. The result can be found below, where \(\Delta\)-SGD achieves the best accuracy in three out of five cases (FMNIST trained with a CNN, CIFAR-10 trained with a ResNet-18, and CIFAR-100 with ResNet-50); in the remaining two cases (MNIST trained with a CNN and CIFAR-100 trained with a ResNet-18), \(\Delta\)- SGD achieves second-best accuracy with close margin to the best.

7.7 Additional plot with standard deviation (3 random seeds)↩︎

In this section, we repeat for three independent trials (using three random seeds) for two tasks: CIFAR-10 classification trained with a ResNet-18, and FMNIST classification trained with a shallow CNN, both with Dirichlet \(\alpha=0.1,\). The aim is to study the robustness of \(\Delta\)-SGD in comparison with other client optimizers.

We remind the readers that CIFAR-10 classification trained with a ResNet-18 with Dirichlet \(\alpha=0.1\) is where we performed grid-search for each client optimizer, and thus each are using the best step size that we tried. Then, for FMNIST classification, the same step sizes from the previous task are used. The result can be found below.

We see that \(\Delta\)-SGD not only achieves the best average test accuracy, but also achieves very small standard deviation. Critically, none of the other client optimizers achieve good performance in both settings, other than the exception of \(\Delta\)-SGD.

7.8 Step size plot for \(\Delta\)-SGD↩︎

Here, we visualize the step size conditions for \(\Delta\)-SGD to see how the proposed step size looks like in practice. We only plot the first 300 epochs, as otherwise the plot gets quite messy.

From Figure 8, we can see that both conditions for \(\eta_{t,k}^i\) are indeed necessary. The first condition, plotted in green, approximates the local smoothness of \(f_i,\) but can get quite oscillatory. The second condition, plotted in blue, effectively restricts the first condition from taking too large values.

7.9 Illustration of the degree of heterogeneity↩︎

As mentioned in the main text, the level of “non-iidness" is controlled using latent Dirichlet allocation (LDA) applied to the labels. This approach is based on [53] and involves assigning each client a multinomial distribution over the labels. This distribution determines the labels from which the client’s training examples are drawn. Specifically, the local training examples for each client are sampled from a categorical distribution over \(N\) classes, parameterized by a vector \(\mathbf{q}\). The vector \(\mathbf{q}\) is drawn from a Dirichlet distribution with a concentration parameter \(\alpha\) times a prior distribution vector \(\mathbf{p}\) over \(N\) classes.

To vary the level of “non-iidness," different values of \(\alpha\) are considered: \(0.01, 0.1\), and \(1\). A larger \(\alpha\) corresponds to settings that are closer to i.i.d. scenarios, while smaller values introduce more diversity and non-iidness among the clients, as visualized in Figure 9. As can be seen, for \(\alpha=1,\) each client (each row on \(y\)-axis) have fairly diverse classes, similarly to the i.i.d. case; as we decrease \(\alpha,\) the number of classes that each client has access to decreases. With \(\alpha=0.01,\) there are man y clients who only have access to a single or a couple classes.

References↩︎