FlexP-SFL: Flexible Personalized Split FL

• FlexP-SFL is defined as a framework that partitions model training between devices and servers to handle heterogeneous resources and personalized tasks.
• It employs a novel architecture that splits models into client-specific layers and a central server block, eliminating FedAvg aggregation in favor of alignment regularization.
• Empirical findings show that FlexP-SFL reduces fine-tuning time and communication overhead while maintaining competitive accuracy compared to standard FL and SL methods.

Searching arXiv for the cited FlexP-SFL and closely related split/personalized federated learning papers. arXiv query: Flexible Personalized Split Federated Learning for On-Device Fine-Tuning of Foundation Models (Yuan et al., 14 Aug 2025) Flexible Personalized Split Federated Learning (FlexP-SFL) denotes a class of hybrid distributed learning systems that combine split learning with personalized federated learning under heterogeneous client resource constraints. In the formulation that explicitly uses the term, FlexP-SFL is a framework for privacy-preserving, on-device fine-tuning of foundation models in which each client trains only a portion of the model locally, offloads the remaining computation to a server according to its resource limits, avoids FedAvg-style parameter aggregation, and uses an alignment strategy to improve personalized model performance on global data (Yuan et al., 14 Aug 2025). Closely related earlier systems, including PFSL and SplitGP, did not use the name “FlexP-SFL,” but they instantiated many of the same core ideas: split execution across client and server, explicit personalization, and mechanisms for balancing local specialization with shared generalization (Wadhwa et al., 2023, Han et al., 2022).

1. Concept and scope

FlexP-SFL is situated at the intersection of federated learning (FL), split learning (SL), and personalized federated learning (PFL). The motivating problem is the joint presence of limited local data, heterogeneous data distributions, and heterogeneous device resources during collaborative fine-tuning or training on edge devices. In the 2025 formulation, standard FL is characterized as requiring the full model on device and full-parameter communication, which is often infeasible for foundation models; standard SFL reduces on-device compute by splitting the model, but still relies on federated aggregation and synchronization; and lighter fine-tuning approaches such as LoRA-based and adapter-based methods remain constrained by synchronous updates, stragglers, or activation-transmission overheads (Yuan et al., 14 Aug 2025).

Within this design space, FlexP-SFL is defined by three coupled properties. First, it is split: computation is partitioned between client and server. Second, it is personalized: clients retain client-specific model components or objectives. Third, it is flexible: the local computation footprint can vary by client, and the degree of local specialization versus shared knowledge transfer is controlled explicitly. This suggests that FlexP-SFL is less a single algorithmic primitive than a family of architectures for heterogeneous edge training in which model partitioning, personalization, and collaboration are co-designed.

A recurring misconception is that FlexP-SFL is simply SFL with a different name. The cited literature does not support that reduction. The explicit FlexP-SFL framework removes parameter aggregation entirely and substitutes an alignment regularizer (Yuan et al., 14 Aug 2025); PFSL uses a three-stage architecture with personalization in the client-back layers and work-fairness constraints (Wadhwa et al., 2023); and SplitGP couples a multi-exit split model with tunable aggregation and adaptive inference routing (Han et al., 2022). These are all hybrid systems, but their personalization and collaboration mechanisms differ materially.

2. Core architecture and execution model

The explicit FlexP-SFL architecture partitions a foundation model into four parts: PL1 (Personalized Layers-1), CL (Client Layers), SL (Server Layers), and PL2 (Personalized Layers-2) (Yuan et al., 14 Aug 2025). Each client stores PL1, CL, and PL2 locally, while the server holds the SL block. PL1 and PL2 are described as the minimum client-side layers needed to preserve privacy: PL1 processes raw input without exposing it directly, and PL2 performs final prediction on the client side, helping protect labels and output behavior.

The forward path is split across the four blocks, and backward propagation mirrors this split. Operationally, the client sends an intermediate activation from its client-side stack to the server, the server processes its server-side block and returns transformed activations, the client completes the forward pass and computes loss, and gradients then traverse PL2, SL, CL, and PL1 in reverse order (Yuan et al., 14 Aug 2025). Unlike traditional SFL, the framework does not perform FedAvg parameter aggregation over client models; instead, each client keeps its own client-side layers, and collaboration occurs through exchanged activations and gradients with a global shared server-side model.

Earlier related systems show alternative decompositions of the same basic principle. PFSL uses a three-stage architecture consisting of Client-Front $M_i^{CF}$, Server-Central $M_i^{S}$, and Client-Back $M_i^{CB}$, together with a separate client model averaging server distinct from the offloading server (Wadhwa et al., 2023). SplitGP decomposes the model into a client-side feature extractor $\phi_k$, a client-side auxiliary classifier $h_k$, and a server-side model $\theta$, thereby creating two exits: a client exit for local personalized inference and a server exit for generalized inference (Han et al., 2022). A plausible implication is that FlexP-SFL should be understood not as requiring one fixed partition template, but as a broader architecture pattern in which personalized client-side prefixes and suffixes are paired with an offloaded middle or server-resident subnetwork.

3. Personalization, generalization, and flexibility controls

The defining technical issue in FlexP-SFL-style systems is how to preserve client-specific adaptation without collapsing into isolated local training. In the 2025 FlexP-SFL framework, personalization is maintained by two mechanisms: client-specific client-side layers and a KL-divergence-based alignment loss that keeps local representations aligned with the shared side (Yuan et al., 14 Aug 2025). The client-specific workload is parameterized by

$$Q_n=\frac{\text{Number of Layers}(v_{\text{CL}^n})}{\text{Number of Layers}(w \setminus (w_{\text{PL1}} \cup w_{\text{PL2}}))}$$

with $Q_n \in [0,1]$, where $Q_n=1$ corresponds to maximal local computation and $Q_n=0$ to near-total offloading. This parameter is the principal resource-allocation knob for heterogeneous devices.

The local FlexP-SFL objective is given as

$M_i^{S}$0

where $M_i^{S}$1 is a KL-divergence-based alignment term. Larger $M_i^{S}$2 induces stronger alignment and better generalization, while smaller $M_i^{S}$3 permits more personalization but more drift (Yuan et al., 14 Aug 2025). This makes the personalization–generalization trade-off explicit rather than emergent.

SplitGP presents a different but closely related formalism. Its client-specific objective is

$M_i^{S}$4

where $M_i^{S}$5 is the client-side loss and $M_i^{S}$6 is the server-side loss (Han et al., 2022). Here, $M_i^{S}$7 weights personalization and $M_i^{S}$8 weights generalization. SplitGP adds a second flexibility control through partial aggregation of the client representation:

$M_i^{S}$9

with an analogous update for $M_i^{CB}$0 (Han et al., 2022). In this formulation, $M_i^{CB}$1 yields a fully personalized client model, while $M_i^{CB}$2 yields a fully global client representation. SplitGP therefore makes flexibility concrete at three levels: loss weighting via $M_i^{CB}$3, representation aggregation via $M_i^{CB}$4, and inference routing via an entropy threshold $M_i^{CB}$5.

PFSL achieves personalization through a phased protocol rather than an explicit regularizer. In Phase 1, clients train in parallel to obtain a generalized model; in Phase 2, server central layers are frozen, clients continue training their client-back layers on local private data, and no synchronization or merging is performed across clients (Wadhwa et al., 2023). The paper characterizes this as coarse-grained personalization and contrasts it with fine-grained multi-task methods such as Ditto, noting that PFSL does not require each client to maintain two full models or run expensive double backpropagation.

4. Privacy, fairness, and heterogeneity

Privacy in FlexP-SFL-style systems is not uniform across the literature; the specific mechanisms vary. In the explicit FlexP-SFL framework, privacy is supported structurally by keeping PL1 and PL2 on-device and by avoiding full-model aggregation (Yuan et al., 14 Aug 2025). PFSL makes stronger claims at the level of data and label locality: raw data never leaves the client, labels also never leave the client, and the offloading server receives activations and, in Phase 1, gradients with respect to server-side activations, but not labels or direct application information (Wadhwa et al., 2023). PFSL further emphasizes that separating the offloading server from the client model averaging server helps avoid leaking model-structure information and makes model inversion attacks harder.

Privacy and heterogeneity are treated even more explicitly in PM-SFL, which is best viewed as a concrete architecture within the broader FlexP-SFL design space. PM-SFL introduces probabilistic mask training with client-specific masks $M_i^{CB}$6, producing effective client weights $M_i^{CB}$7, and formalizes a privacy amplification bound

$M_i^{CB}$8

under mask sampling assumptions (Wang et al., 18 Sep 2025). Its personalized mask learning addresses data heterogeneity, while layer-wise knowledge compensation addresses system heterogeneity. This suggests that later FlexP-SFL-like systems increasingly treat privacy, data heterogeneity, and system heterogeneity as coupled design constraints rather than separate concerns.

PFSL adds an additional dimension that is not always foregrounded in later formulations: work fairness. It defines total client work as

$M_i^{CB}$9

and imposes the rule

$\phi_k$0

so that all clients perform the same number of iterations per global epoch and extra data is carried over to later epochs (Wadhwa et al., 2023). Performance fairness is then evaluated using the standard deviation of test accuracy across clients. A common misconception is that personalization necessarily undermines fairness because clients specialize independently; PFSL provides counterevidence in the specific sense that personalization can reduce inter-client performance disparity after a shared training stage.

5. Empirical findings and system-level trade-offs

The empirical evidence for FlexP-SFL and adjacent methods centers on accuracy, wall-clock efficiency, memory, communication, and robustness under heterogeneity. In the explicit FlexP-SFL paper, results are reported on MMLU and MMLU-Pro using heterogeneous edge devices and several encoder/decoder foundation models, including BERT-Large-Uncased, BERT-Base-Uncased, ModernBERT-Base, GPT2-Medium, and GPT2-Small (Yuan et al., 14 Aug 2025). Against FedAvg and SFL on BERT-Large for MMLU, FlexP-SFL reports 28.89% final accuracy and 1.57 h overall fine-tuning time, compared with 27.55%, 128.33 h for FedAvg and 27.38%, 27.33 h for SFL. For BERT-Base on MMLU, it reports 28.81%, 1.18 h, compared with 27.53%, 31.63 h for FedAvg and 27.38%, 5.70 h for SFL (Yuan et al., 14 Aug 2025).

Against personalized FL baselines, the same paper reports that FlexP-SFL is competitive or better in personalized accuracy while remaining much faster. For BERT-Large on MMLU, the reported numbers are 28.89%, 1.57 h for FlexP-SFL, 28.18%, 100.16 h for APFL, 29.91%, 90.47 h for Ditto, and 27.04%, 113.57 h for FedRep (Yuan et al., 14 Aug 2025). Against on-device fine-tuning baselines on ModernBERT-Base for MMLU, FlexP-SFL reports 28.89% final accuracy, compared with 26.63% for FLoRA, 27.88% for MobiLLM, and 27.34% for PocketLLM, together with lower memory and communication overhead: 0.57 GB memory and 1.07 GB communication for FlexP-SFL, versus 1.91 GB and 3.78 GB for FLoRA, 1.26 GB and 5.88 GB for MobiLLM, and 1.40 GB and 116.99 GB for PocketLLM (Yuan et al., 14 Aug 2025).

PFSL provides earlier evidence that split-personalized designs can substantially outperform conventional FL and SL variants for thin clients. In a small non-i.i.d. setting, reported average F1 scores include 0.505 for FL, 0.794 for SL, 0.749 for SFLv1, 0.773 for SFLv2, 0.816 for PFSL$\phi_k$1 generalization, and 0.953 for PFSL$\phi_k$2 personalization; the paper highlights that personalization boosts F1 by about 0.14 over the generalized model (Wadhwa et al., 2023). In larger-dataset experiments with five clients, PFSL reports average test accuracy of 92 on CIFAR-10, 93 on FMNIST, and 99.46 on MNIST, while also showing the least overfitting on CIFAR-10 with 7.8, compared with 10.48 for FL, 14.94 for SL, 13.91 for SFLv1, and 22.68 for SFLv2 (Wadhwa et al., 2023).

SplitGP’s empirical focus is different: it targets the trade-off between local personalization and out-of-distribution robustness. On Fashion-MNIST, it reports 95.10% at $\phi_k$3, 90.93% at $\phi_k$4, 87.95% at $\phi_k$5, 85.74% at $\phi_k$6, and 84.15% at $\phi_k$7, compared with sharper degradation for personalized FL and weaker main-task performance for generalized FL (Han et al., 2022). It also reports that only about 10.62% of the client storage of the full-client model is needed for FMNIST and 10.64% for CIFAR-10, and that for FMNIST with $\phi_k$8, only 20.30% of test samples were inferred at the server (Han et al., 2022). This supports the view that flexibility in inference routing can be as important as flexibility in training partitioning.

6. Historical lineage and relation to adjacent frameworks

The terminology “FlexP-SFL” is specific to the 2025 foundation-model paper (Yuan et al., 14 Aug 2025). Earlier works are better interpreted as precursors or neighboring formulations rather than direct uses of the term. The following table summarizes the relationship among the principal cited systems.

Framework	Core mechanism	Relation to FlexP-SFL
PFSL (Wadhwa et al., 2023)	Three-stage split architecture, two-phase training, client-back personalization, work fairness, data and label privacy	Conceptually close; earlier personalized split-learning system for thin clients
SplitGP (Han et al., 2022)	Multi-exit split model, joint personalization/generalization objective, flexible aggregation, entropy-based inference routing	Very close to a flexible personalized split federated learning interpretation
FSL (Zhang et al., 2023)	Hybrid FL+SL with client–edge pairs and server-side weight averaging	Foundational precursor, but not personalized or client-adaptive in the modern sense
PM-SFL (Wang et al., 18 Sep 2025)	Probabilistic masking, personalized mask learning, adaptive splitting, layer-wise knowledge compensation	Concrete realization within the broader FlexP-SFL design space

The 2023 FSL paper is especially important as a systems precursor. It studies the hybrid FL+SL design pattern with clients, edge servers, and a central parameter server, formalizes split-point optimization, and examines the trade-off among delay, computation, accuracy, and attack resilience (Zhang et al., 2023). However, it is explicit that the method is not personalized and only partially flexible through the choice of cut index and privacy mechanisms. The distinction matters historically: the progression from FSL to PFSL and SplitGP, and then to FlexP-SFL and PM-SFL, is not merely one of nomenclature but of increasing emphasis on client heterogeneity, personalized objectives, and dynamic allocation of computation.

Another possible misunderstanding is to treat these lines of work as converging on a single canonical architecture. The evidence instead indicates a design space with several axes: model partition topology, aggregation policy, personalization mechanism, inference routing, privacy defense, and fairness criterion. FlexP-SFL, in its explicit 2025 form, occupies one point in that space by combining layer-partitioned backbone fine-tuning, no parameter aggregation, and KL-based alignment (Yuan et al., 14 Aug 2025). PFSL emphasizes thin-client transfer learning, label privacy, and work fairness (Wadhwa et al., 2023). SplitGP emphasizes dual exits, adaptive routing, and convergence analysis to stationary points (Han et al., 2022). PM-SFL emphasizes structured stochastic masking and heterogeneity-aware participation (Wang et al., 18 Sep 2025). A plausible implication is that “FlexP-SFL” functions both as a named framework and as a broader umbrella for flexible, personalized, split-federated designs.

7. Limitations, assumptions, and open questions

The cited literature identifies several assumptions and unresolved issues. The explicit FlexP-SFL framework is designed for on-device fine-tuning of foundation models, but this benefit is tied to the feasibility of partitioning the backbone into PL1, CL, SL, and PL2 and maintaining client-specific layer ratios $\phi_k$9 across heterogeneous hardware (Yuan et al., 14 Aug 2025). It also replaces FedAvg with activation/gradient collaboration plus alignment regularization, which removes synchronization bottlenecks but introduces split-management complexity and additional dependence on communication of intermediate states.

PFSL relies on pre-trained models, specifically ResNet-18 with pre-trained weights in the reported experiments, freezes front layers to keep computation low, uses 224×224 inputs for transfer-learning experiments, and assumes a separate secure client model averaging server in addition to the offloading server (Wadhwa et al., 2023). The paper explicitly states that it does not provide a formal proof of convergence or privacy guarantees and lists these as future work. These are not minor details: they delimit the scope of the framework’s claims, especially where privacy is argued structurally rather than proven formally.

By contrast, SplitGP provides a convergence result under standard assumptions, showing that all client models approach stationary points asymptotically when the learning rate is set as

$h_k$0

with $h_k$1 (Han et al., 2022). It also notes an explicit trade-off: larger $h_k$2 increases personalization but slows convergence, while $h_k$3 does not guarantee convergence because client-side models are not aggregated. This should caution against overly broad claims that more personalization is uniformly beneficial in split-federated systems.

Finally, privacy claims remain heterogeneous across the field. The FSL precursor emphasizes attack-resilience analysis rather than absolute guarantees and notes vulnerability to reconstruction attacks from intermediate activations (Zhang et al., 2023). PM-SFL strengthens the privacy story with formal masking-based and noise-based analyses, but its mechanism is specific to probabilistic masking rather than generic FlexP-SFL (Wang et al., 18 Sep 2025). The literature therefore supports a restrained conclusion: FlexP-SFL and related methods offer a technically coherent response to the joint challenges of personalization, heterogeneity, and edge constraints, but the exact balance among privacy, efficiency, convergence, and personalization depends strongly on the chosen variant and its assumptions.