Context-Aware Online Model Splitting and Device Association for Semi-Decentralized Federated Learning in Internet of Things Authors: Bo Xu, Shuang Wang, Xiaoyu Tang Published: 2026 ABSTRACT As a distributed approach to Artificial Intelligence (AI) model construction over wireless networks, federated learning (FL) based on multi-device collaborative training can protect data privacy, as well as increase the computing load of local model updates. In contrast, split learning (SL) with proper model splitting can adapt to the computation and transmission capabilities among devices. In this paper, while taking advantage of FL and SL, we concentrate on a semi-decentralized hybrid federated split learning (SD-HFSL) framework, in which we surpass the limitations of a single central server and allow the shared split models to be aggregated among multiple edge servers. To verify the importance of latency optimization for training efficiency, we analyze the convergence performance of SD-HFSL while jointly considering the limited computation and communication resources. Then, aiming at maximizing the long-term training efficiency, we propose an online optimization problem that includes local model splitting and device association. Considering that the training latency is unknown to the system a priori, a context-aware online training algorithm with sublinear regret is proposed based on the framework of contextual multi-armed bandit (CMAB), where the edge servers can observe the context information of device sites for latency estimation, followed by the iterative optimization based on the evaluated information in different contexts. Experiments on several neural network models show that the proposed algorithm reduces training latency and improves test accuracy compared with the selected benchmarks. 1. Introduction Internet of Things (IoT) technology has been extensively applied across a variety of domains, including industry and transportation, where demand for intelligent applications continues to grow [1,2]. These intelligent applications are often implemented based on Artificial Intelligence (AI) technologies with a large amount of training data collected from widely distributed IoT devices [3]. Meanwhile, considering the increasing complexity of neural network models, it is more difficult for resource-constrained devices to efficiently build training models to support rapidly iterating AI applications. In particular, although cloud computing [4] or edge computing [5] has the ability to provide extra computing resources for large-scale data training, the third-party computing model has difficulty with meeting the privacy requirements among the involved devices [6]. To solve this issue, taking advantage of the distributed devices and their local computing power, the federated learning (FL) [7] algorithm is an approach that can be used for cooperatively training AI models by using the local data of several devices while meeting privacy requirements. In contrast to conventional centralized training, which exchanges local data with a central server to train on massive volumes of raw data, FL can effectively safeguard data privacy without local data interaction. Recent works have designed a variety of FL frameworks to accommodate a large number of devices by using techniques to reduce training overhead [8,9]. Moreover, to facilitate FL over dynamic wireless networks, strategies of resource allocation were fully addressed, considering communication link unreliability [2,10,11,12] and training efficiency [13,14]. Moreover, some interesting reviews of FL can be found in [15,16,17,18]. Nevertheless, with the increasing complexity of AI models, low-performance devices under the short-plate effect can significantly increase training latency and weaken the training efficiency of FL in real-world scenarios. Most importantly, the local computing tasks of traditional FL will be completely dependent on the device itself, which can not fully mobilize the existing computing resources. Considering the problem that a single device is insufficient to support complex training tasks, a deep neural network (DNN) can be divided into several sections via split learning (SL) [19], which is a cooperative training method that can send procedures of forward propagation and gradient calculations to other computing nodes for processing, such as devices and edge servers. Compared with FL, SL can lower a single device’s processing load and energy usage by performing model splitting and distributing the intermediate outcomes, such as model features and gradients across other computing units. To reduce the computational load of model training and inference processes, the SL framework is implemented in open-source applications, such as indoor positioning, cooperative identification, and rapid reasoning [20]. Moreover, in academia, SL is deployed over wireless networks, maximizing learning performance with resource adaptation [21,22,23,24]. However, the amount of data possessed by a single device in SL is limited, and the trained model is insufficient in generalization ability or learning ability, especially in the heterogeneous data environment. To solve this issue, jointly considering the advantages of FL and SL, recent works have incorporated the low computational load on SL devices and collaborative training of FL [25,26,27,28,29,30,31,32,33]. In [25], a novel learning framework, namely, hybrid federated split learning (HSFL), was proposed to obtain a trade-off between training time and energy consumption with the joint optimization problem, including splitting decisions. Moreover, the time consumption of the stragglers in HSFL was considered in [26], where the local models were trained among all devices along the ring through a pre-defined direction. We can see that HSFL, in fact, retains the characteristics of FL, integrated with existing learning mechanisms. For instance, in [27], a special split from the perspective of clustering was proposed in HFSL, which was similar to clustered FL, but optimized the model updating and cluster splitting schemes in the training stage to accelerate model convergence. Moreover, the authors in [28] adapted HFSL to intrusion detection systems, considering the reliability of split information in the sharing process. To strike a balance between latency and performance, optimization was proposed in [29] by jointly optimizing client selection, model splitting, and bandwidth allocation policies. Recent work [30] analyzed and optimized the HFSL under multi-tier systems, improving the flexibility of model splitting. An asynchronous framework that enabled personalized model splitting and aperiodic model aggregation was proposed in [31] to minimize the long-term average training latency. Moreover, HFSL can also introduce differential privacy and other security mechanisms under the premise of ensuring learning efficiency [32,33]. These studies indicate that HFSL can combine the low local computational load of SL with the collaborative training ability of FL. With regard to HFSL, there is a practical issue that has not been fully considered in previous works. In particular, the current HFSL framework is trained under the presumption that a central server has complete control over learning, which is obviously difficult to achieve due to the fact that the communication and computing power of the central server are limited. In particular, when the hardware of the central server fails, the local model of the device will lose the object of model uploading, resulting in extremely severe stagnation of the training process. To solve this issue, semi-decentralized edge learning frameworks were recently proposed in [34,35,36], which can greatly improve the robustness of the training process by performing model aggregation among various edge servers without a central server. Specifically, to reduce the consumption of spectrum resources, an adaptive control technique combining edge aggregation with device-to-device (D2D) technologies was proposed in [34]. Moreover, under the multiple edge server scenario, a tradeoff between training effectiveness and energy consumption was considered in [35]. Additionally, convergence performance of the global model in the case of decentralized architecture was analyzed in [36]. HFSL can be integrated with a semi-central architecture by reorganizing the local model update process into the interaction process between devices and edge servers. However, this combination is not simple to achieve and will create new challenges. On the one hand, adding the model splitting mechanism under a decentralized architecture needs to be redesigned according to the characteristics of each device in order to improve the training efficiency with limited wireless resources. On the other hand, it is difficult to describe the convergence performance of HFSL in a scenario of multiple edge servers accurately, and there is a lack of correspondence between training efficiency and splitting strategy. Therefore, we need to design an efficient training mechanism that includes model splitting and device association, where a semi-decentralized hybrid federated split learning (SD-HFSL) framework is designed. In this paper, the considered SD-HFSL framework can use SL to reduce the computational load of FL devices with intra- and inter-aggregations among multiple edge servers. Aiming at maximizing the long-term training efficiency, an online problem of model splitting decisions is formulated. Specifically, considering that the training latency is uncertain in different states of devices, i.e., the communication environment varies across time, and the local computing power changes accordingly. Learning the training latency for each device site precisely with a cold start (i.e., no prior knowledge available) is the first step toward efficient model splitting. Fortunately, to solve this issue, multi-armed bandit (MAB) algorithms have been studied to address the tradeoff between exploration and exploitation in sequential decision-making with uncertain information. The classic MAB algorithm, e.g., upper confidence bound (UCB), is concerned with learning the single optimal action among a set of candidate actions with unknown rewards [37]. Using the known information adequately, contextual bandits extend the basic MAB to contextual multi-armed bandit (CMAB) [38,39], where the edge servers can observe the context information (i.e., channel state, allocated bandwidth, transmit power, interference) of device sites for the training latency estimation, especially local computing power estimation. Since the problem of contextual bandits is already much more common and difficult than the basic MAB, this paper tackles solutions based on the framework of CMAB. Different from the previous works [38,39], this paper can merge local computing power evaluation with the training process by considering the training, exploration, and exploitation phases jointly. Meanwhile, we investigate multiple servers with incomplete information and compare them with the existing works of HFSL. Finally, the considered SD-HFSL framework based on the proposed scheme can improve learning efficiency, even with limited resources and unknown information. As summarized in Table 1, the main technical distinction of this work is not merely combining FL and SL, but jointly considering three coupled aspects that are usually treated separately, including semi-decentralized aggregation among multiple edge servers, three-part split training without label uploading, and context-aware online optimization of both split points and device–server association under unknown latency. As such, the main contributions of this paper are as follows. We propose a novel SD-HFSL framework over wireless networks, where multiple edge servers are deployed, and each of them can coordinate a device cluster with splitting-based local model updating. Moreover, the edge models can be periodically updated based on intra-cluster model aggregation and inter-cluster model aggregation. According to the analysis results of convergence performance, aiming at maximizing the long-term training efficiency, an online optimization problem of model splitting and device association is formulated. We propose a novel SD-HFSL framework over wireless networks, where multiple edge servers are deployed, and each of them can coordinate a device cluster with splitting-based local model updating. Moreover, the edge models can be periodically updated based on intra-cluster model aggregation and inter-cluster model aggregation. According to the analysis results of convergence performance, aiming at maximizing the long-term training efficiency, an online optimization problem of model splitting and device association is formulated. An online decision-making algorithm based on the framework of CMAB is proposed, which allows the edge servers to observe the context information of device sites for training latency estimation. Meanwhile, combined with the evaluated information, devices can update the model splitting and association decisions according to the estimated context-dependent latency through exploration and exploitation in sequential decision-making under uncertainty. Meanwhile, we prove that the proposed algorithm can provide a provable performance, achieving sublinear regret compared to an oracle algorithm that knows the expected training latency. An online decision-making algorithm based on the framework of CMAB is proposed, which allows the edge servers to observe the context information of device sites for training latency estimation. Meanwhile, combined with the evaluated information, devices can update the model splitting and association decisions according to the estimated context-dependent latency through exploration and exploitation in sequential decision-making under uncertainty. Meanwhile, we prove that the proposed algorithm can provide a provable performance, achieving sublinear regret compared to an oracle algorithm that knows the expected training latency. Our experiments adapt several model structures, including AlexNet, VGG16, and ResNet18, and present several comparison algorithms based on the existing works. The simulation results show that the proposed algorithm achieves lower training latency and higher test accuracy in the considered settings, especially when prior latency information is unavailable. Our experiments adapt several model structures, including AlexNet, VGG16, and ResNet18, and present several comparison algorithms based on the existing works. The simulation results show that the proposed algorithm achieves lower training latency and higher test accuracy in the considered settings, especially when prior latency information is unavailable. The organization of this paper is structured as follows. The system model with convergence analysis is presented in Section 2. The long-term optimization problem is introduced in Section 3. The details of the proposed online algorithm for training efficiency improvement are introduced in Section 4. Finally, we present extensive experimental results in Section 5, and the conclusions are drawn in Section 6. 2. System Model 2.1. SD-HFSL Framework The proposed SD-HFSL framework is shown in Figure 1, which consists of a set of edge servers S={1,2,…,S} and a set of devices K={1,2,…,K}. Each device k∈K has its local dataset {xk,i,yk,i}i=1Dk with Dk training samples, where xk,i and yk,i are the i-th training data and the corresponding training label, respectively. Given the training round set T={1,2,…,T}, by performing T rounds of multi-devices collaborative learning, our goal is to find the optimal global model w¯∗(T) from the trained edge model set W¯(T)={w¯1(T),w¯2(T),…,w¯S(T)} that can minimize the global training loss, i.e.,(1)minw¯(T)∈W¯(T)F(w¯(T))=∑k∈K|Dk|fk(w¯(T))∑k∈K|Dk|, where fk(w¯(T)) is the local loss of device k with edge model w¯(T) and can be evaluated at the end of each training round. The main notation used in the system model is summarized in Table 2. Specially, compared with the training process in traditional semi-decentralized FL [40], the characteristic of the considered SD-HFSL framework is that we redesign the device and edge server model interaction process, assuming that the trained local model on the device can be split to offload part of the computation to the associated edge server. For instance, we design a three-part splitting strategy without label sharing [26], where the DNN is beyond the execution capacity of the device and can be split into three parts, namely part a, part b, and part c. It is divided into three parts because we consider that in the case of model splitting, the labels of devices do not leave the local area in the gradient descent calculation, so as to improve the privacy protection capabilities. We note that keeping labels locally does not eliminate all privacy risks because intermediate features and back-propagated gradients may still contain information about local samples. Therefore, the proposed framework focuses on reducing label exposure and communication/computation latency, while stronger protection can be incorporated by adding feature perturbation, differential privacy noise, or secure aggregation to the exchanged activations and gradients. Then, in each training round t, the key steps of the SD-HFSL framework include local model updates, intra-cluster model aggregation, and inter-cluster model aggregation. (1) Local Model Updates: Considering the case of model splitting, the initial parameter w(t) of the device k in training round t can be written as wk(t)={wka(t),wkb(t),wkc(t)}, where only the model parameters of part a and part c are downloaded to devices. Since the model in splitting is usually large in scale and occupies more computing resources, we adopt parallel SGD with fast aggregation, in which the local model wk(t) obtained by device k is updated as(2)wk(t)=wk(t−1)−ηgk(ζk(t),wk(t−1)), where g(ζk(t),wk(t−1)) is the gradient computed on the batch of randomly-sampled local training dataset ζk(t) with model parameter wk(t−1), and η is the learning rate. Moreover, the parameter update for devices with splitting is performed based on the vanilla SL without label sharing. Specifically, in the forward propagation of SL, wka(t) is executed locally and the output feature is uploaded to the associated edge servers for the calculation of wkb(t). Then, the output of the edge server is downloaded by the device for the execution of wkc(t). Similarly, in the backward propagation, the gradients of part c, part b and part a are calculated in order, denoted as gkc(wk(t)), gkb(wk(t)), and gka(wk(t)), respectively. (2) Intra-cluster Model Aggregation: When the local models are updated, each device can upload its complete or partial model parameters to the associated edge server, performing intra-cluster model aggregation to obtain the edge mode w˜s(t), i.e.,(3)w˜s(t)=∑k∈Vs(t)Dkwk(t)∑k∈Vs(t)Dk, where the set of devices associated with the s-th edge server and successfully participating in training round t is denoted as Vs(t). Then, the updated edge models can be broadcast to the associated devices for the following local model updates in the current training round. (3) Inter-cluster Model Aggregation: When the edge model is updated, each edge server can upload its model parameters to the associated edge servers, performing inter-cluster model aggregation, i.e.,(4)w˜s(t+1)=∑k∈Vs(t)Dkwk(t)+∑s′∈Cs(t)∑k′∈Vs′(t)Dk′wk′(t)∑k∈Vs(t)Dk+∑s′∈Cs(t)∑k′∈Vs′(t)Dk′, where Cs(t) is the set of edge servers that are placed in the converging area of edge server s with successful model interaction in training round t. Finally, at the end of each training round, the updated edge models of edge servers are transmitted to the associated devices to perform the next round of training. As the complexity of the model increases, it is usually required to perform many training rounds to obtain the desired learning performance. 2.2. Latency Model The latency of the SD-HFSL framework consists of forward propagation and back propagation. Meanwhile, the single-round training process involves multiple stages of model transmission and computation. (1) Transmission Latency: The number of divisible layers contained in a model is denoted as Imax. Then, let 1≤Ika,b(t)≤Imax−2 and Ika,b(t)τmax(t), and the actual device–server participation variable is ak,s(t)=xk,s(t)zk(t). This separation removes the circular dependence between association selection and latency-feasible participation. We can observe that the model splitting strategy and the device association strategy can directly affect the defined training latency, which is affected by multi-dimensional factors such as bandwidth, transmit power, local computing power, and interference. Meanwhile, enhancing learning performance constitutes one of the primary objectives of SD-HFSL. Nevertheless, the influence of optimizing training latency on learning performance warrants additional investigation. 2.3. Convergence Analysis We conducted the convergence analysis of SD-HFSL to quantify the impact of training latency and considered the following three standard assumptions on the loss functions, which are consistent with the FL literature [27,30]. These assumptions are adopted to obtain a tractable upper bound for the semi-decentralized split aggregation process in resource-constrained IoT networks. They are standard in FL convergence analysis and allow us to explicitly connect device participation, inter-edge aggregation reliability, and the loss bound. Each gradient gk(w) of the local loss fk(w) is Lipschitz continuous with a positive constant L, i.e., ∥gk(w)−gk(w′)∥ ≤L∥w−w′∥. ∀w,w′. Each local loss fk(w) is strongly convex with a positive constant μ, i.e., fk(w)≥fk(w′)+(w−w′)Tgk(w′)+μ2∥w−w′∥2, ∀w,w′. Each local gradient gk(w) satisfies ξ12≤∥gk(w)∥2≤ξ22 with ξ1,ξ2>0, ∀w. Denote the global optimal model as w∗, then the upper bound of the training loss on edge server s can be expressed as (18) E(Fs˜(w˜s(t+1))−F˜s(w∗))≤1−1−μLt+14Lξ22∑k∈KDk−NUminμ∑k∈KDk+1−μLt+1EFs(w¯s(1))−Fs(w∗), where w˜s(t)=∑k∈Vs(t)Dkwk(t)∑k∈Vs(t)Dk. Here, ukD(t) denotes the probability that device k successfully participates in the current round under the latency budget, us,s′E(t) denotes the reliability of inter-edge model exchange from edge server s′ to s, and NU(t) denotes the amount of successfully aggregated data, including both intra-cluster and inter-cluster contributions. (19) NUmin=mint∈TNU(t)=mint∈T∑k∈Vs(t)ukD(t)Dk+∑s′∈Cs(t)∑k′∈Vs′(t)uk′D(t)us,s′E(t)Dk′. According to Theorem 1, increasing the device participation probability or increasing the reliability of communication between edge servers in NUmin can reduce the upper bound of training loss (see Appendix A). Moreover, it is worth noting that the factors affecting the learning performance among devices are not only the amount of locally owned data, but also the convergence parameters, such as L and μ. Specially, we define the local gradient of device k as gk(t) rather than gk(ζkj(t),wk(j−1)(t)), which can represent the average gradient or the gradient based on local complete data. This simplification has little effect on the results of the analysis, since this paper focus on the cost of edge servers rather than the local updates among the devices. In particular, the data held by the devices that do not have a low local loss based on the current edge model should be more important for improving learning performance. Finally, in light of the analytical findings of the convergence performance, we may rebuild the objective function using the acquired upper limit. It should be emphasized that the above theorem provides theoretical insight under simplified convex assumptions. The DNNs used in the experiments, such as AlexNet, VGG16, and ResNet18, are non-convex. Therefore, the bound should not be interpreted as a complete convergence guarantee for these neural networks. Instead, it explains why reducing latency and increasing latency-feasible participation are useful design principles. The experimental results then provide empirical evidence that the same principles improve SD-HFSL performance in practical non-convex training. 3. Problem Formulation The considered problem for SD-HFSL is a sequential decision-making problem, and the goal is to maximize the training efficiency. Specifically, to jointly optimize the learning performance and training latency, the training efficiency can be evaluated as the decrease in training losses per unit of time. Hence, for each device k, the training efficiency can be defined as(20)uk(t)=∑s∈Sak,s(t)F˜s(w˜s(t−1))−F˜s(w˜s(t))τk(t), where F˜s(w˜s(t−1))−F˜s(w˜s(t)) indicates the reduction of training loss under the associated edge model. Then, the system utility to represent the training efficiency can be expressed as(21)U(t)=∑k∈Kuk(t). Different from common optimization problems, this paper considers the unknown randomness in local computing power changes, resulting in training latency is uncertain in different states of devices, which can be evaluated based on the context information C^(t), including channel state, allocated bandwidth, transmit power, interference, etc. Then, the formulation of the online maximization problem with model splitting strategy I and device association strategy X can be expressed as(22a)max{I,X}∑t=1TU(I(t),X(t),C^(t))(22b)s.t.1≤Ika,b(t)≤Imax−2,∀k∈K,t∈T,(22c)Ika,b(t)