Semi-asynchronous Federated Learning in Flower: Framework Extension and Performance Assessment
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 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. 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.Where the paper says it
Where the paper says it
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 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]. 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. 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. 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.Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
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 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. 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. 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).Where the paper says it
Where the paper says it
Where the paper says it
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 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 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. 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. 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.Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
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 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. 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. 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.Where the paper says it
Where the paper says it
Where the paper says it
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 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 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. 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.Where the paper says it
Where the paper says it
Where the paper says it
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
-
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 reducesthe impact of slow participants on the aggregation process.
-
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. -
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.
-
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 analyzemodel convergence speed,
quantifying efficiency asthe reduction in loss achieved per unit of time.
-
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
- Towards Federated Learning at Scale: System Design
- Flower: A Friendly Federated Learning Research Framework
Related papers
- Programmable Probabilistic Computer with 1,000,000 p-bits
- BatchGen: An Architecture for Scalable and Efficient Batch Inference
- Seamless Reconfiguration for DAG-BFT (Technical Report)
- ELDR: Expert-Locality-Aware Decode Routing for PD-Disaggregated MoE Serving
- iScheduler: Reinforcement Learning-Driven Continual Optimization for Large-Scale Resource Investment Problems
- TIRx: A Unified Tile Primitive ML Compiler Across Heterogeneous Backends