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

summary

The gist

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

In short

This research extends Flower's federated learning framework to support Semi-Asynchronous Federated Learning (SAFL). The proposed FedSaSync strategy modifies standard training by aggregating updates when a specific number of clients, M, are reached, rather than waiting for everyone. This adaptation improves robustness and efficiency in heterogeneous environments by reducing idle time and balancing convergence stability with system performance.

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 used across episodes

This episode discusses

The paper

Semi-asynchronous Federated Learning in Flower: Framework Extension and Performance Assessment · Read on arXiv

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

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

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.

DOI: 10.1016/j.softx.2026.103183

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.

More episodes

← Home