acceptodds
Under review as a conference paper at ICLR 2027

StreamSplit: Decoupling Split Federated Learning for Asynchronous and Continuous Optimization

Abstract

Distributed learning enables collaborative model training across distributed nodes. Split Federated Learning (SFL), a form of distributed learning, partitions model computation between clients and a server, but its tightly coupled execution requires clients and the server to wait for gradients and features from each other for subsequent optimization. This bidirectional dependency causes frequent execution stalls and severe resource underutilization, particularly under heterogeneous environments, leading to low training efficiency. In this paper, we propose StreamSplit, a decoupled SFL framework that enables clients and the server to optimize asynchronously and continuously while maintaining consistency between them. StreamSplit introduces a lightweight Shadow Server-side Model (SSM) at each client to substitute for the server-side model during local updates, enabling clients to perform continuous training without waiting for gradients. We design a depth-decoupled parallel SSM architecture with a corresponding multi-depth alignment strategy, allowing the SSM to approximate the evolving server-side model and provide reliable surrogate gradients for client updates. Meanwhile, StreamSplit maintains a Latest Feature Table to store and provide candidate features for continuous server-side model training. We also introduce an optimization-aware feature selection strategy to select informative features that facilitate server-side model training and SSM alignment. Experiments show that StreamSplit improves training efficiency and scalability over existing SFL methods under heterogeneous environments. It also performs well on both convolutional and transformer-based models, demonstrating its applicability across model architectures.

Primary area:
optimization
Keywords:
Split Federated Learning, Distributed Systems, Decoupled Execution, Heterogeneous Environments

Reviews

Among:
Shape:
1234this paper, Bottom 27%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.00 over 3 reviews, above 27% of the others.
Reviewer_WjYiOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper attempts to address the low training efficiency caused by mutual waiting between clients and the server in split federated learning. The authors deploy a lightweight shadow server-side model on clients and allow the server to reuse the latest available features, enabling asynchronous training on both sides and thereby improving training efficiency.

Critical strengths
  1. The paper proposes the idea of fully asynchronous training between clients and the server, which solves the bidirectional waiting problem and improves training efficiency.
  2. It deploys a lightweight Shadow Server-side Model (SSM) on each client with periodic server-guided synchronization, ensuring consistent optimization directions for local updates without real-time server gradients.
  3. It designs an optimization-aware feature selection strategy over the Latest Feature Table (LFT) to reuse buffered intermediate features, effectively reducing server idle time and improving resource utilization.
Critical weaknesses
  1. Lack of comparisons with key related methods and insufficient experimental validation.
  2. Insufficiently rigorous theoretical analysis, with some conclusions lacking adequate supporting evidence.
  3. Limited gradient alignment between the auxiliary model and the server-side model.
  4. Lack of validation in real-world settings, along with notable additional client-side computational overhead.
  5. Limited improvement from the feature selection strategy, without statistical significance tests.
Questions for authors
  1. Does StreamSplit still have significant advantages over methods such as GAS and MU-SplitFed?
  2. Can you further explain and verify the error analysis for different model structures to support the relevant conclusions?
  3. There is a significant difference in training direction between the auxiliary model and the server-side model. How do you ensure effective training?
  4. After accounting for the additional computational overhead, can this method still improve training efficiency in real-world settings?
  5. Can you provide statistical significance tests to demonstrate the effectiveness of the new feature selection strategy?
Reviewer_KPFJOpenReview ↗
Rating
2
Confidence
4
Informativeness
1
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes a split federated learning (SFL) framework that aims to remove the bidirectional waiting dependency between clients and the server. On the client side, each client maintains a local Shadow Server-side Model (SSM) that takes the cut-layer feature as input and provides surrogate gradients for client-side updates. A server-side copy of the SSM is trained jointly with the server-side model and is periodically mixed into the local SSMs. On the server side, a Latest Feature Table (LFT) stores the most recent feature from each client. The server selects features from this table according to a utility function that combines multiple factors. Experiments show faster accuracy improvement over time than several SFL baselines under simulated client heterogeneity.

Critical strengths
  1. The paper studies a practical problem. In standard SFL, clients must wait for cut-layer gradients and the server must wait for client activations. This bidirectional dependency leads to substantial idle time when clients have heterogeneous computation and communication speeds.
  2. The empirical study covers both a convolutional model and a transformer-based model. It also includes ablations on the alignment strategy, the feature selection rule, the synchronization interval, and the SSM architecture and size.
Critical weaknesses
  1. Both main components of StreamSplit closely follow ideas from existing work, and the paper does not accurately describe these works, which makes its novelty unclear. On the client side, the SSM is essentially an auxiliary network. The mechanism in Eqs. (5)–(8), where a small local network takes the cut-layer feature and produces a surrogate gradient from a local task loss, is the same mechanism used by CSE-FSL [3] and FSL-SAGE [2]. The paper argues that FSL-SAGE passively selects an auxiliary network rather than actively aligning it. However, FSL-SAGE already periodically aligns its auxiliary models to emulate the server-side model [2]. The remaining differences are the multi-branch architecture and the use of feature and logit alignment instead of aligning the cut-layer gradient itself. The paper does not explain why aligning intermediate features should be preferable to aligning gradients. This is particularly important because the authors’ own bound in Eq. (35) shows that the surrogate gradient error is governed by the Jacobian mismatch, which feature alignment controls only indirectly. In addition, the SSM increases client-side FLOPs by 53.0% for ResNet-18 and 66.7% for ViT-Tiny, which is not lightweight. On the server side, the continuous server-side optimization in Section 3.2 is closely related to MU-SplitFed [1]. MU-SplitFed targets the same problem, namely server idleness caused by waiting for client activations under heterogeneous clients. It addresses this problem by letting the server performs multiple local updates on the available activations within each client round, instead of waiting for new ones. The LFT follows the same principle of letting the server keep updating on already received features. Its main addition is a utility-based rule for choosing which retained feature to reuse, which can be viewed as a variant of this multi-step server update. However, the paper does not discuss this connection and describes MU-SplitFed only as a zeroth-order method for client-side updates. This paper should clarify what the LFT contributes beyond multi-step server updates.
  2. The convergence analyses do not address the main problem of the method. The client-side analysis in Eqs. (79)–(90) only bounds the one-step deviation from a hypothetical standard SFL update by the gradient approximation error, and it assumes that this error is small without proving it. The server-side theorem is a standard analysis of SGD with bounded bias. The selection error and the maximum staleness are directly assumed to be bounded, and the utility-based selection itself is not analyzed. The derivation also does not use the unbiasedness of the stochastic gradient, so the variance term 9σ29\sigma^2 in Eq. (130) does not decay with the learning rate. Therefore, the claim in the discussion that the result reduces to the standard non-convex characterization when Δ=0\Delta = 0 and ϵselection=0\epsilon_{selection} = 0 is not correct. Most importantly, the paper analyzes the client side and the server side separately, but does not provide a convergence result for the coupled system.
  3. The experimental evaluation is not sufficient to support the claims. The paper only reports accuracy against time curves and accuracy at fixed time points, without the final accuracy at convergence or results over multiple random seeds. In Table 2, the accuracy difference between baselines and the proposed method is small. Without standard deviations, it is difficult to conclude that the utility-based selection is beneficial. Moreover, only one cut layer is evaluated for each model, and in both cases the client-side model is very shallow. This is the setting where noisy surrogate gradients are least likely to hurt the final accuracy. Finally, the training time is simulated on a single multi-GPU machine with assigned speed ratios, and the paper should explain how communication time is modeled.

References

[1] D. Liang, J. Zhang, E. Chen, Z. Li, R. Li, and H. Yang. Towards Straggler-Resilient Split Federated Learning: An Unbalanced Update Approach. In Advances in Neural Information Processing Systems (NeurIPS), 2025.

[2] S. Nair, M. Lin, P. Ju, A. Talebi, E. S. Bentley, and J. Liu. FSL-SAGE: Accelerating Federated Split Learning via Smashed Activation Gradient Estimation. In International Conference on Machine Learning (ICML), 2025.

[3] Y. Mu and C. Shen. Communication and storage efficient federated split learning. In IEEE International Conference on Communications(ICC), 2023.

Questions for authors

How do the two components of StreamSplit differ from existing designs? On the client side, what does the SSM provide beyond auxiliary-network methods such as CSE-FSL [3] and FSL-SAGE [2], especially when the auxiliary network has a matched model size or is aligned with the server-side model? On the server side, how does the LFT-based continuous optimization differ from performing multiple server updates per client round as in MU-SplitFed [1]?

Reviewer_PzP7OpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper investigates the dependency of model updates for both server-side and client-side submodels under Split Federated Learning. In SFL, the server has to wait for client-generated activations, while clients have to wait for server-generated cut-layer gradients. Such a bidirectional client-server submodel update dependency introduces severe training latency for SFL. To address this, the authors present StreamSplit, a decoupled SFL framework where both client-side submodels and the server-side model can be updated in a continuous way. The paper provides both theoretical analysis of the surrogate-gradient error bound and empirical results on StreamSplit across two benchmarks, with 40 clients and simulated data and system heterogeneity.

Critical strengths
  • This paper aims to address an important and practical problem in SFL, where the bidirectional waiting between clients and the server severely undermines the SFL wall-clock training performance, which is exacerbated by system heterogeneity across clients.
  • To enable parallel and continuous client-side and server-side submodel updates, StreamSplit introduces a lightweight Shadow Server-side Model (SSM) for each client to provide pseudo cut-layer gradients and a Latest Feature Table (LFT) for the server to update the server-side submodel on the activations with high utility.
Critical weaknesses
  • Some details on the SSM design are unclear: 1) more details about the hyperparameters of both parallel convolutional and transformer-block architectures are required for reproduction; 2) the underlying accuracy–cost trade-off is not sufficiently discussed. Table 3 reports only the accuracy under the fixed wall-clock time budget, while lacking the detailed computation, memory, and synchronization costs. Besides, the small, medium, and large SSM configurations in Table 3 are not specified; and 3) it is still unclear what the rationale is for alternating the two alignment objectives in Section 3.1.2, and the paper does not compare this choice with jointly optimizing both losses.
  • It is unclear about the feature-selection overhead and details of implementation for the LFT. Algorithm 1 evaluates utility over all LFT entries, while the loss and gradient discrepancy are updated only after an entry is selected. It is unclear whether loss and gradient discrepancy are recomputed for every candidate or reused from previous selections, and how to initialize for newly received features.
  • The evaluation of this paper is weak: 1) wall-clock performance is the main metric, but the experiments are simulated on a single 4-GPU platform, and it lacks the details on the time model for the reported results; 2) no standard deviations are reported across the multiple trails and the scale of the clients is relatively small; 3) the simulation of the data heterogeneity is too mild; 4) the choice of the baselines is limited and not convincing; 5) could you please explain the results under the homogeneous Cluster-1 setting: StreamSplit still converges faster, which suggests that the performance gain of StreamSplit may mainly come from the server performing more updates on reusing LFT features; and 6) the evaluation lacks sensitivity analysis across different cut layers.
  • It is confusing regarding the experimental results in Table 1. For StreamSplit, the cosine similarity between the SSM and server-side gradients is quite low, which means that the pseudo-gradient is nearly orthogonal to the actual one.
Questions for authors

See the concerns in the Weakness section above.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.