Semi-asynchronous Federated Learning in Flower: Framework Extension and Performance Assessment

arXiv:2606.24230 · cs.DC · Submitted 2026-06-23 · Read on arXiv

Listen

Radio episode about this paper

Transcript

Introduction to the show: ident: Computer Science. The day in computer science: software, systems and theory on arXiv.

Tom: I'm Tom.

Jane: And I'm Jane, here with Lu, Meng and our in-house large language model, Lalam.

Tom: We're looking at the paper: "Semi-asynchronous Federated Learning in Flower".

Jane: Here's the gist of the paper. This paper presents an extension of the Flower federated learning framework to support Semi-Asynchronous Federated Learning (SAFL).

Tom: The proposed approach adapts the traditional synchronous paradigm to better handle client heterogeneity and straggler effects By introducing a semi-asynchronous training strategy, the system allows partial synchronization among clients while maintaining training efficiency and scalability We implement and evaluate the proposed modification within Flower, instantiated as the FedSaSync strategy, demonstrating improved robustness and reduced idle time compared to fully synchronous baselines in heterogeneous environments The results show that SAFL can balance convergence stability and system efficiency in heterogeneous environments typical of edge and distributed learning scenarios.

Jane: The rapid growth of distributed datagenerating devices has led to large-scale data availability across edge environments, enabling new opportunities for data-driven analysis and decision-making

1: Traditional Machine Learning (ML) approaches rely on centralized cloud infrastructure, in which data collected by edge devices is transmitted to remote servers for training However, conventional FL typically relies on a synchronous training process, where the global model is updated only after receiving contributions from all participating clients

8: .

Tom: In heterogeneous Internet of Things (IoT) environments, this rigid synchronization requirement becomes a major limitation, as slower or less capable devices, often referred to as stragglers, can delay the entire training process.

Paper summary: Tom: So we're looking at this paper, "Semi-asynchronous Federated Learning in Flower: Framework Extension and Performance Assessment," and basically, what they're doing is extending the existing Flower framework to handle Semi-Asynchronous Federated Learning, or SAFL.

Jane: It sounds like they are trying to adapt the standard synchronous training method to deal with real world problems where clients aren't all ready at the same time.

Lu: The core idea is that traditional federated learning often relies on every single client sending their model update before the server can do anything, which causes a big problem when some clients are much slower than others, which we call stragglers <ref:2606.24230#pg1>.

Meng: What’s the actual claim here? They introduce a semi-asynchronous training strategy in Flower called FedSaSync, and they show that this setup improves robustness and reduces idle time compared to just using the fully synchronous version when things are messy <ref:2606.24230#pg1>.

Tom: It’s about balancing things, right? They say it allows for partial synchronization among clients while still keeping the training efficient and scalable <ref:2606.24230#pg1>. That sounds like they're aiming to solve that tension between speed and making sure everyone keeps up with the model updates.

Jane: I wonder how this specifically helps when you have these heterogeneous environments, like in edge learning scenarios where devices have wildly different capabilities <ref:2606.24230#pg1>? It seems they are testing if this semi-asynchronous coordination actually balances convergence stability and system efficiency, which is what the abstract says <ref:2606.24230#pg1>.

Lalam: From my perspective, the paper is showing that this SAFL approach can work well in those diverse environments we see in real distributed learning setups <ref:2606.24230#pg1>. It suggests that instead of waiting for everyone, you get updates as they come in, which helps manage the different speeds of the clients.

Tom: Exactly what Lalam is saying is that it helps mitigate those straggler effects by reducing idle time <ref:2606.24230#pg1>. But I need to know how much better it actually performs against the synchronous baseline, because that’s where I look for concrete proof, not just a general idea of improvement.

Paper summary: Jane: The experimental setup they used is pretty standard—they tested it on image classification tasks using CIFAR-ten and MNIST datasets, distributed across ten clients with an independent and identically distributed partitioning strategy <ref:2606.24230#pg1>. It’s a solid starting point for seeing how this strategy holds up in practice.

Lu: They specifically evaluate performance not just by the number of communication rounds, but by test loss as a function of wall-clock training time, which makes sense because the synchronization timing isn't uniform across clients <ref:2606.24230#pg1>. This is a smart way to measure efficiency in this context.

Meng: From an engineering standpoint, what I’m looking for is how it behaves when things get really varied, not just on CIFAR-ten or MNIST, but with real traffic and different hardware constraints <ref:2606.24230#pg1>. If the performance relies too heavily on a fixed synchronization degree M that they set beforehand, that might be a deployment headache.

Tom: That’s a fair point, Meng. The paper mentions that configurations where the semi-asynchronous degree M is less than or equal to N minus Nslow operate at fast client speeds because they bypass those slower devices <ref:2606.24230#pg1>. That sounds like a key finding for speeding things up when you have stragglers.

Jane: So, if we look at the results, the paper suggests that when clients are all behaving nicely—when they are homogeneous—the FedSaSync strategy acts just like the standard FedAvg <ref:2606.24230#pg1>. But as soon as you introduce real heterogeneity, it starts outperforming the synchronous baseline because it cuts down on waiting time <ref:2606.24230#pg1>.

Lalam: I’m also interested in what they found regarding convergence speed, which they define as the reduction in loss achieved per unit of time <ref:2606.24230#pg1>. Table three point three shows how effective each configuration is at this, which gives us a concrete metric beyond just watching the loss drop over time <ref:2606.24230#pg2>.

Tom: Concrete metrics are what I love to see, Lalam. If they can show that their strategy actually reduces the wall-clock time it takes to reach a certain accuracy compared to the fully synchronous approach in those varied settings, then that’s something we can ship <ref:2606.24230#pg1>.

Paper summary: Jane: What does this mean for us on the ground? It means that for edge and distributed learning, where you can’t guarantee perfect synchronization across all devices, you have a viable way to train models without letting one slow device hold up the entire system <ref:2606.24230#pg1>.

Lu: The limitation they flag is that this whole approach depends on defining that semi-asynchronous degree M in advance and keeping it fixed throughout the entire training process <ref:2606.24230#pg1>. That might make it tricky to deploy on highly dynamic systems where client capabilities change constantly.

Meng: I agree with Lu, that's a practical hurdle. If we have to manually set M before we even start the training, it’s not scalable for real-time edge deployments where conditions are always shifting <ref:2606.24230#pg1>. It stops being truly adaptive on the fly.

Tom: So, to wrap up this part of the paper, "Semi-asynchronous Federated Learning in Flower: Framework Extension and Performance Assessment," they’ve shown that FedSaSync is a solid way to manage client heterogeneity by cutting down on idle time compared to standard synchronous methods <ref:2606.24230#pg1>.

Jane: And the big picture for this research, as I see it, is that we can actually find a middle ground between being perfectly synchronized and being completely free with asynchronous updates <ref:2606.24230#pg1>. That balance seems important for making these systems more practical in real world edge scenarios.

Lalam: I'm confident that this work provides a clear direction for researchers looking to implement more robust training strategies when dealing with the inherent variability of distributed data sources <ref:2606.24230#pg1>. It shows a path forward for making federated learning less brittle in real life.

Meng: From my side, I’d watch how they handle the overhead of that degree M definition, because if setting it up takes too much work, it might just be an academic proof rather than a deployable system <ref:2606.24230#pg1>.

Tom: Yeah, so the whole story is that this extension to Flower helps us see how these strategies balance stability and speed in environments that are anything but perfect <ref:2606.24230#pg1>. That’s what we looked at today.

Conclusion: Tom: So we're wrapping up this look at the paper, "Semi-asynchronous Federated Learning in Flower: Framework Extension and Performance Assessment." The main thing here is they extended the existing Flower framework to handle semi-asynchronous federated learning.

Jane: Basically, they took a standard way of training where everyone has to wait for everyone else before moving on, and they made it work better when clients are all at different speeds.

Tom: Right. They introduce this strategy called FedSaSync and show that it helps manage those slow devices, or stragglers, which used to just hold up the whole process.

Lu: The authors are looking at how this modification balances getting a stable model update with keeping the system running efficiently when things are messy across different machines.

Meng: From my side, I'm interested in how much overhead this adds for deployment; does it become too complicated to actually ship to a real edge device?

Lalam: I see what they did by testing it on image classification tasks, using CIFAR-ten and MNIST datasets distributed across ten clients. That gives us a concrete starting point for seeing how this plays out in practice.

Jane: So, the big implication is that for distributed learning where you can't guarantee perfect timing, there's now a way to train without letting one slow client dictate the pace of the entire group.

Tom: It’s about finding that middle ground between being perfectly synchronized and being completely free with asynchronous updates.

Lu: And they show that when clients are all behaving nicely, this strategy actually behaves just like the standard synchronous version, which is good to know.

Meng: But they also found it outperforms the standard version as soon as you introduce real differences in client capability.

Jane: The paper suggests this approach can really help make federated learning more practical for those edge and distributed learning scenarios we're talking about.

Tom: It’s a solid extension to Flower, showing how we can adapt existing tools to handle the real-world variability of data sources.

Lalam: And they point out that while it works well with this method, you still have to decide on that semi-asynchronous degree before you start training and keep it fixed.

Jane: That setup choice is a limitation they flag, which means we can't just throw this at any system without careful planning upfront.

Tom: So, the core of it is balancing convergence speed with system efficiency in environments that are anything but perfect.

Víctor Hidalgo-Izquierdo, Carmen Carrión, Blanca Caminero

Instituto de Investigación en Informática de Albacete, Universidad de Castilla-La Mancha

cs.DC

Submitted: 2026-06-23

Updated: 2026-11-16

Comments: 16 pages, 5 figures, 4 tables, 2 listings, 1 algorithm. This work is part of the author's PhD thesis

Journal ref: SoftwareX, Volume 36, 2026, 103183

DOI: 10.1016/j.softx.2026.103183

Code: https://github.com/VictorHidalgoUCLM/SAFlwr

License: http://creativecommons.org/licenses/by-nc-nd/4.0/

Importance score: 76/100

The gist: This paper presents an extension of the Flower federated learning framework to support Semi-Asynchronous Federated Learning (SAFL).

Key concepts

Semi-Asynchronous Federated Learning (SAFL)
SAFL is a training method that balances full synchronization with asynchrony. Instead of waiting for every client to finish before updating the global model, it allows updates to be aggregated when a predefined threshold (M) of clients has contributed. This helps manage slow or straggler devices more effectively.
Stragglers
Stragglers are clients in a distributed system that are significantly slower than other participants. In traditional synchronous learning, the entire process must wait for the slowest client to complete its training and send its update. Stragglers cause delays, reducing overall training efficiency.
FedSaSync Strategy
FedSaSync is the specific modification implemented in Flower that enables semi-asynchronous aggregation. The server tracks incoming updates and triggers an aggregation event as soon as the count reaches a set degree M. This allows the system to proceed with partial synchronization, improving resource utilization.
Wall-Clock Training Time
This metric measures performance based on how much time passes during training rather than the number of communication rounds. Since SAFL is semi-asynchronous, not every round has a fixed structure. Therefore, tracking wall-clock time provides a more accurate measure of system efficiency in this flexible learning setup.

Terminology

Summary

This paper presents an extension of the Flower federated learning framework to support Semi-Asynchronous Federated Learning (SAFL). p. 0

Where the paper says it

Semi-asynchronous Federated Learning in Flower: Framework Extension and Performance Assessment Víctor Hidalgo-Izquierdoa,∗ , Carmen Carriónb,1, Blanca Caminerob,1 a Instituto de Investigación en Informática de Albacete, Universidad de Castilla-La Mancha, Investigación 2, Albacete, 02071, Castilla-La Mancha, Spain bDepartamento de Sistemas Informáticos, Universidad de Castilla-La Mancha, Edificio Juan Manuel, Campus Universitario, Albacete, 02071, Castilla-La Mancha, Spain Abstract This paper presents an extension of the Flower federated learning framework to support Semi-Asynchronous Federated Learning (SAFL). The proposed approach adapts the traditional synchronous paradigm to better handle client heterogeneity and straggler effects.

The proposed approach adapts the traditional synchronous paradigm to better handle client heterogeneity and straggler effects By introducing a semi-asynchronous training strategy, the system allows partial synchronization among clients while maintaining training efficiency and scalability We implement and evaluate the proposed modification within Flower, instantiated as the FedSaSync strategy, demonstrating improved robustness and reduced idle time compared to fully synchronous baselines in heterogeneous environments The results show that SAFL can balance convergence stability and system efficiency in heterogeneous environments typical of edge and distributed learning scenarios. p. 0
Where the paper says it

We implement and evaluate the proposed modification within Flower, instantiated as the FedSaSync strategy, demonstrating improved robustness and reduced idle time compared to fully synchronous baselines in heterogeneous environments. The results show that SAFL can balance convergence stability and system efficiency in heterogeneous environments typical of edge and distributed learning scenarios.

Motivation for the Research

The rapid growth of distributed datagenerating devices has led to large-scale data availability across edge environments, enabling new opportunities for data-driven analysis and decision-making [1] Traditional Machine Learning (ML) approaches rely on centralized cloud infrastructure, in which data collected by edge devices is transmitted to remote servers for training However, conventional FL typically relies on a synchronous training process, where the global model is updated only after receiving contributions from all participating clients [8]. In heterogeneous Internet of Things (IoT) environments, this rigid synchronization requirement becomes a major limitation, as slower or less capable devices, often referred to as stragglers, can delay the entire training process. p. 1

Where the paper says it

However, conventional FL typically relies on a synchronous training process, where the global model is updated only after receiving contributions from all participating clients [8]. In heterogeneous Internet of Things (IoT) environments, this rigid synchronization requirement becomes a major limitation, as slower or less capable devices, often referred to as stragglers, can delay the entire training process [9].

Asynchronous Federated Learning (AFL) partially addresses these problems by loosening the strict synchronization requirement, enabling clients to submit updates independently. p. 1
Where the paper says it

Consequently, the overall learning pace is effectively determined by the slowest participant, reducing system efficiency and scalability. Asynchronous Federated Learning (AFL) partially addresses these problems by loosening the strict synchronization requirement, enabling clients to submit updates independently.

Nonetheless, this flexibility may reduce efficiency and hinder model convergence, especially in resource-limited settings where outdated client updates can seriously affect convergence. p. 1
Where the paper says it

Asynchronous Federated Learning (AFL) partially addresses these problems by loosening the strict synchronization requirement, enabling clients to submit updates independently. Nonetheless, this flexibility may reduce efficiency and hinder model convergence, especially in resource-limited settings where outdated client updates can seriously affect convergence.

These issues justify adopting SAFL, which strikes a balance between full synchronization and asynchrony. p. 1
Where the paper says it

Nonetheless, this flexibility may reduce efficiency and hinder model convergence, especially in resource-limited settings where outdated client updates can seriously affect convergence. These issues justify adopting SAFL, which strikes a balance between full synchronization and asynchrony.

Framework Implementation Details

The core of the work is the implementation of the FedSaSync strategy within Flower, which extends the synchronous FedAvg algorithm by supporting semi-asynchronous aggregation The server keeps track of the clients currently involved in training and continuously collects their updates as they become available. Whenever the number of received updates reaches the semiasynchronous synchronization degree M, an aggregation event is triggered without waiting for the remaining clients This stands in sharp contrast to the traditional FedAvg strategy, which operates in a strictly synchronous manner and requires updates from all selected clients before triggering an aggregation. p. 6

Where the paper says it

Whenever the number of received updates reaches the semiasynchronous synchronization degree M, an aggregation event is triggered without waiting for the remaining clients. This stands in sharp contrast to the traditional FedAvg strategy, which operates in a strictly synchronous manner and requires updates from all selected clients before triggering an aggregation, making it highly susceptible to the straggler problem.

The clients that contributed to the aggregation are then released and become eligible for subsequent training tasks, making them available for assignment in subsequent rounds. p. 6
Where the paper says it

This stands in sharp contrast to the traditional FedAvg strategy, which operates in a strictly synchronous manner and requires updates from all selected clients before triggering an aggregation, making it highly susceptible to the straggler problem. The clients that contributed to the aggregation are then released and become eligible for subsequent training tasks, making them available for assignment in subsequent rounds.

In the final round of the federated training, the server instead waits until all pending replies have been received before proceeding. p. 7
Where the paper says it

Aggregation is triggered as soon as M updates are available (lines 17–21), interrupting the waiting loop and enabling intermediate aggregation without blocking on slower clients. In the final round of the federated training, the server instead waits until all pending replies have been received before proceeding (line 17).

Experimental Setup and Methodology

The experimental evaluation considers an image classification task using two standard benchmark datasets: CIFAR-10 and MNIST. Both datasets contain 10 classes and are distributed across 10 clients using an IID partitioning strategy, ensuring that each client receives data drawn from the same underlying distribution. p. 8

Where the paper says it

Experimental setup The experimental evaluation considers an image classification task using two standard benchmark datasets: CIFAR-10 and MNIST. Both datasets contain 10 classes and are distributed across 10 clients using an IID partitioning strategy, ensuring that each client receives data drawn from the 9

The baseline model is a simple convolutional neural network implemented in PyTorch, following the default architecture provided in the Flower framework. p. 9
Where the paper says it

This configuration yields homogeneous data across clients and mitigates statistical heterogeneity, enabling clearer analysis of system behavior under controlled conditions. The baseline model is a simple convolutional neural network implemented in PyTorch, following the default architecture provided in the Flower framework.

Performance is evaluated in terms of test loss as a function of wall-clock training time rather than communication rounds. p. 9
Where the paper says it

Within each subfigure, different values of M are compared. Performance is evaluated in terms of test loss as a function of wall-clock training time rather than communication rounds.

This choice is motivated by the system’s semi-asynchronous nature, where communication rounds are not uniformly defined across clients and therefore may not provide a strictly comparable unit of progress. p. 9
Where the paper says it

Performance is evaluated in terms of test loss as a function of wall-clock training time rather than communication rounds. This choice is motivated by the system’s semi-asynchronous nature, where communication rounds are not uniformly defined across clients and therefore may not provide a strictly comparable unit of progress.

Performance Analysis and Results

The experimental results show that the FedSaSync strategy behaves similarly to FedAvg when all clients are homogeneous, and outperforms FedAvg as system heterogeneity increases, demonstrating that semiasynchronous coordination can effectively mitigate the impact of client heterogeneity by reducing idle time and improving resource utilization. For CIFAR-10 (see Figure 4), several observations can be made, including that configurations where M ≤ (N − Nslow) operate at fast-client speeds because they bypass the stragglers. p. 9

Where the paper says it

Consequently, loss-versus-time curves are used as a more consistent evaluation metric across configurations. Results For CIFAR-10 (see Figure 4), several observations can be made.

Additionally, Table 3. p. 4
Where the paper says it

The main() function of the server module initializes and activates the FedSaSync() strategy instead of the default FedAvg() strategy (see Listing 1), where the specific parameters added for our proposed strategy, namely strategy_name, semiasync_deg, number_slow, and dataset_name, are highlighted in blue and will be detailed in later sections. Additionally, both the FedSaSync() implementation and the server module rely on auxiliary utilities provided in the Utils module, enabling customized metrics aggregation and system logging.

3 reports the effectiveness of each configuration in terms of model convergence speed, defined as the reduction in loss achieved per unit of time. p. 9
Where the paper says it

Performance is evaluated in terms of test loss as a function of wall-clock training time rather than communication rounds. This choice is motivated by the system’s semi-asynchronous nature, where communication rounds are not uniformly defined across clients and therefore may not provide a strictly comparable unit of progress.

Limitations and Future Work

The proposed implementation is subject to several limitations, including its dependence on the Flower execution model. Furthermore, the current implementation is subject to limitations inherent in the communication backend’s design. p. 3

Where the paper says it

Flower is designed to enable a seamless transition from experimental research in simulation environments to system-level research on edge devices. Its main design goals include scalability, communication, and client agnosticity, privacy preservation, and flexibility to support both experimental studies and real-world deployments.

The Grid component is primarily optimized for synchronous execution patterns, in which coordinated broadcast and aggregation operations dominate the communication paradigm. Finally, the proposed approach requires the semi-asynchronous degree to be defined a priori and remain fixed throughout the training process. p. 0
Where the paper says it

The proposed approach adapts the traditional synchronous paradigm to better handle client heterogeneity and straggler effects. By introducing a semi-asynchronous training strategy, the system allows partial synchronization among clients while maintaining training efficiency and scalability.

These factors may limit scalability and adaptability in highly dynamic federated environments. p. 0
Where the paper says it

By introducing a semi-asynchronous training strategy, the system allows partial synchronization among clients while maintaining training efficiency and scalability. We implement and evaluate the proposed modification within Flower, instantiated as the FedSaSync strategy, demonstrating improved robustness and reduced idle time compared to fully synchronous baselines in heterogeneous environments.

Green — the paper says it, and the page is printed. Red — no passage carries it, so treat that sentence as unverified. The same check runs on your own text: check a summary against its source, $5.

Improvements for AI systems

  1. Native Semi-Asynchronous Aggregation Mechanism: The system can aggregate model updates whenever a predefined number of clients complete their local training, decoupling aggregation from full client synchronization, which reduces the impact of slow participants on the aggregation process.

  2. Support for Heterogeneous and Time-Varying Clients: The AI system can faithfully realize semi-asynchronous behavior in environments with heterogeneous and time-varying client execution times, reducing the effect of slow participants on the overall learning pace.

  3. Systematic Evaluation of SemiAsynchronous Training: The framework enables a systematic study of the effects of different semiasynchronous configurations, facilitating analysis of convergence, training efficiency, and client participation dynamics across varying levels of heterogeneity.

  4. Improved Convergence Efficiency Measurement: By using loss-versus-time curves as a metric, the system can provide a more consistent evaluation metric across configurations to analyze model convergence speed, quantifying efficiency as the reduction in loss achieved per unit of time.

  5. Robustness in Heterogeneous Environments: The FedSaSync strategy is shown to outperform FedAvg as system heterogeneity increases, demonstrating that semiasynchronous coordination can effectively mitigate the impact of client heterogeneity by reducing idle time and improving resource utilization.

Abstract

This paper presents an extension of the Flower federated learning framework to support Semi-Asynchronous Federated Learning. The proposed approach adapts the traditional synchronous paradigm to better handle client heterogeneity and straggler effects. By introducing a semi-asynchronous training strategy, the system allows partial synchronization among clients while maintaining training efficiency and scalability. We implement and evaluate the proposed modification within Flower, instantiated as the FedSaSync strategy, demonstrating improved robustness and reduced idle time compared to fully synchronous baselines in heterogeneous environments. The results show that SAFL can balance convergence stability and system efficiency in heterogeneous environments typical of edge and distributed learning scenarios.

Sources

Related papers