Heterogeneity-Aware Dynamic Federated Split Learning with Adaptive Compression (HADFL-AC) Edge–Cloud Inference in IoT Environments

Abstract

In resource-constrained environments, distributed split learning allows for collaborative training; however, the system suffers from high communication overhead and is sensitive to system heterogeneity. Despite advances in IoT data reduction and distributed learning, existing approaches treat heterogeneity, adaptability, and communication efficiency as separate problems. As a result, the Heterogeneity-Aware Dynamic Federated Split Learning with Adaptive Compression (HADFL-AC) framework is proposed, enabling adaptive adjustment of communication payloads to instantaneous bandwidth conditions during training. This approach distinguishes itself by focusing on feature-representation-level adaptation, offering seamless transitions between linear PCA, nonlinear Tiny Autoencoder (TinyAE), and hybrid PCA–AE compression methods without requiring changes to architecture or retraining. Experiments were conducted using the CIFAR10 and CI=NIC datasets with a lightweight ResNet-18 backbone under Dirichlet-based non-IID data partitioning and fluctuating network scenarios. HADFL-AC achieves significant communication reductions of 80.86% on CIFAR-10 and 77.2% on CINIC-10, as well as significant reductions in training time and energy consumption. In addition, the framework achieved these gains while maintaining competitive performance, reaching 79.58% on CIFAR-10 and exhibiting stable convergence on CINIC-10. Consequently, the results demonstrate that leveraging network heterogeneity as an adaptive signal facilitates efficient and scalable distributed learning while effectively balancing communication efficiency and model accuracy.

1. Introduction

In recent years, Internet of Things (IoT) ecosystems have been demonstrated to have a wide range of cyber–physical applications, including in autonomous drones, smart surveillance, industrial automation, environmental monitoring, and mobile healthcare [1,2]. To support tasks such as classification, detection, and semantic interpretation, modern IoT systems increasingly rely on deep neural networks (DNNs). However, state-of-the-art models typically require billions of operations and large memory footprints, which exceed the computational, memory, and energy capabilities of resource-constrained edge devices [3,4].

To overcome these limitations, edge–cloud collaborative learning has emerged as a promising approach to distribute computation across edge devices and cloud servers [5]. This type of system makes communication efficiency a critical factor. Traditional cloud-centric architectures typically transmit raw sensor data or high-dimensional features to centralized servers. For this reason, there is considerable overhead in communication, latency, and scalability, particularly in environments with limited bandwidth [1,6,7].

There are a variety of methods available to mitigate these issues, including statistical filtering, dimensionality reduction, and learned feature extraction [8,9]. A linear approach, Principal Component Analysis (PCA), has been widely used to compress data efficiently [10,11], while nonlinear approaches, such as autoencoders (AEs), provide more expressive latent representations [12,13,14,15].

To improve the communication efficiency in edge-cloud systems, several strategies for data reduction and offloading have been proposed, including hierarchical architectures and adaptive transmission mechanisms [16,17,18,19]. Several recent works have investigated communication-efficient learning through model compression, feature transmission, and distributed inference frameworks [20,21,22]. However, these approaches are typically designed for static settings and are not tightly integrated with dynamic distributed training processes.

Autoencoders (AEs) provide a more expressive representation of latents [12,13]. The hybrid edge–cloud framework combines local reduction with cloud-based processing [23,24]. Although these techniques are primarily designed for inference-time optimization, they are not tightly integrated into distributed training processes. With the increasing adoption of distributed learning paradigms such as federated learning and split learning, the communication bottleneck has moved from raw data transmission to iterative model training. Despite FL reducing raw data sharing, it introduces significant communication overhead due to frequent model updates [25].

A similar approach, known as SL, reduces the computational burden on edge devices but incurs high communication costs due to the transmission of intermediate activations [26,27]. Typically, these costs are higher than those associated with raw data transmission, especially when deep backbone models are used.

Many recent advancements in distribution learning seek to mitigate communication overhead, as exemplified by SplitFed [28] and communication-efficient FL methodologies [29]. Nevertheless, most current methods rely on static compression techniques or predetermined split points, thereby lacking the capacity to adjust to fluctuating network conditions. Most existing approaches, however, use static compression strategies, fixed split points, or predefined architectures that cannot adjust to changing network conditions [30,31]. Given the inherent heterogeneity of IoT environments, characterized by devices with diverse functional capabilities, power limitations, and bandwidths [32], existing approaches are consequently constrained in their ability to accommodate such variability. This limitation leads to inefficient communication, degraded performance, and increased energy consumption.

Adaptive techniques such as dynamic neural networks and monitoring frameworks underscore the importance of adapting to changes over time in Internet of Things (IoT) systems, as in [33,34]. Although these strategies have been widely applied to distributed learning pipelines, they have not been fully integrated, particularly regarding adaptive compression and dynamic feature transmission. Therefore, SL and hybrid FL-SL systems are still vulnerable to bandwidth fluctuations and dynamic network conditions.

Despite advancements in IoT data reduction and distributed learning, existing approaches treat communications efficiency, heterogeneity, and adaptability as separate problems. In the field of distributed learning, there is a lack of unified frameworks that dynamically integrate data-reduction mechanisms to reduce communication overhead during training while maintaining model accuracy in heterogeneous, bandwidth-constrained IoT environments.

To address this challenge, this paper proposes a Heterogeneity-Aware Dynamic Federated Split Learning Framework with Adaptive Compression (HADFL-AC). The proposed framework integrates multiple compression strategies—including PCA, autoencoders, and hybrid PCA–AE representations—within a unified edge–cloud learning pipeline. The hysteresis-based switch mechanism dynamically selects the most appropriate split point and compression method based on real-time network conditions, enabling stable, efficient communication without oscillation near the decision boundaries.

This paper makes several major and minor contributions. The two major contributions are as follows:

• The introduction of a Heterogeneity-Aware Dynamic Federated Split Learning Framework with Adaptive Compression (HADFL-AC), which integrates a unified multi-compressor architecture, enabling the dynamic selection of the model split point and compression strategy according to runtime system conditions without retraining.
• An overview of a lightweight compression design that relies on a reduced TinyAE bottleneck to improve communication efficiency while maintaining feature quality for downstream learning.

In addition, the minor contributions are as follows:

• Completion of numerous experiments, including non-IID distributions, bandwidth variations, device heterogeneity, and client churn, to assess the robustness of the proposed framework.
• Validation of the framework with generalization capability across multiple datasets, including CIFAR-10 and the more challenging CINIC-10, demonstrating its applicability beyond standard benchmark settings.
• Discussion of the empirical evidence that the proposed adaptive mechanism effectively balances communication efficiency with model accuracy under various system conditions.

2. Related Work

This section first discusses techniques for reducing IoT data. The following section discusses the literature on Distributed Edge Intelligence. At the end, a discussion outlines the research gaps.

2.1. IoT Data Reduction Techniques

IoT data reduction techniques aim to minimize communication overhead while preserving sufficient information for monitoring, inference, and learning tasks. These techniques have evolved from traditional statistical methods to more advanced machine learning-based approaches.

2.1.1. Statistical and Correlation-Based Methods

Early IoT data reduction approaches relied on statistical filtering, aggregation, and redundancy elimination. These methods remove duplicate or predictable data from sensor streams to reduce communication costs.

For example, a mean difference (MD) method in [35] detects deviations from expected sensor values, achieving approximately 67% data reduction in homogeneous environments. Similarly, DTW-based summary techniques [36] have demonstrated up to a 95% reduction in the size of time-series data on real datasets. Improved variants such as ClRe 3.x [37] enhance similarity preservation and representative selection.

Prediction-based suppression methods introduced by Santini and Römer [8] reduce communication by transmitting data only when the prediction error exceeds a predefined threshold. Spatial correlation techniques [38] further reduce redundant transmissions in dense sensor networks.

Cluster-based aggregation approaches [39] allow cluster heads to collect and aggregate data from nearby nodes, reducing network-wide communication overhead. Earlier studies also examined the impact of spatial correlation on communication efficiency and scalability in wireless sensor networks [39].

Approximate query processing methods [40] reduce communication by allowing controlled inaccuracies in aggregate queries over sensor data streams. Lightweight compression techniques suitable for low-power devices were proposed in [41], improving energy efficiency without introducing significant computational overhead.

Lossless and near-lossless compression techniques tailored to sensor networks were introduced in [42]. Additionally, adaptive sampling strategies [8] dynamically adjust sampling rates based on signal dynamics, preserving important signal trends while reducing transmission.

2.1.2. Sampling and Approximation-Based Methods

Sampling-based methods reduce data transmission by selecting representative data points. Piecewise linear approximation (PLA) [43] segments time series data into linear components, achieving compression with bounded reconstruction error.

Information-theoretic adaptive sampling methods [44] adjust sampling rates based on information gain. Perceptually important points (PIPs) sampling [45] preserves critical shape features for downstream analytics.

2.1.3. Compression and Encoding Techniques

Compression-based approaches aim to reduce data size while maintaining reconstruction accuracy. Data synopsis techniques [46] generate compact summaries for approximate analytics.

Compressive sensing methods [47] enable signal reconstruction from reduced sampling rates. Distributed source coding approaches [48] exploit correlations between sensor data streams to improve compression efficiency across distributed nodes.

2.1.4. Machine Learning and Deep Learning-Based Reduction

Recently, machine learning (ML) and deep learning (DL) techniques have been introduced to achieve higher reduction efficiency through learned feature representations.

In industrial IoT applications, learned models achieved up to 95% reduction with minimal accuracy loss [49]. Autoencoder-based compression methods [9] enable edge devices to transmit compact latent representations instead of raw data, achieving 50–77% reduction.

Two-tier frameworks such as TTDR [50] combine local encoding with gateway-level clustering, whereas layered and fusion-based approaches [51] improve reduction efficiency by estimating errors.

Other ML-based techniques include energy-efficient reduction for wearable devices [52], PCA-based dimensionality reduction [53], and streaming PCA for embedded systems [54].

Additional methods include tensor decomposition techniques [55], which reduce the complexity of high-dimensional data, though they may be unsuitable for real-time applications due to computational overhead.

Knowledge distillation [56] and model pruning techniques [4] have been proposed to reduce model complexity and communication cost. Variational autoencoders (VAEs) [57] enable efficient representation learning across diverse data distributions.

DeepIoT [58] applies structured pruning to compress neural networks for IoT systems. Mobile sensing studies [59] demonstrate the feasibility of deep learning on edge devices. Federated edge learning approaches [25] further improve communication efficiency while maintaining model performance.

Finally, Caldas et al. [60] analyzed the impact of heterogeneity on communication efficiency and convergence in federated learning systems, while FedCompress methods combine gradient compression and sparsification to further enhance communication efficiency.

2.2. Distributed Edge Intelligence

A recent development in edge intelligence allows machine learning models to be placed closer to data sources in IoT settings. With edge intelligence, computation is distributed across edge devices and servers, supporting real-time analytics and reducing communication latency. A federated learning approach, split learning approach, and hybrid federated–split learning framework have emerged as promising solutions for enabling scalable and communication-efficient learning in heterogeneous IoT environments.

In these types of systems, edge computing is widely regarded as an important component. A concept called edge computing was introduced by Shi et al. [1], where computations are performed near data sources to reduce latency and communication overhead. A similar approach was proposed by Satyanarayanan et al. [61] to enable cloud-like functionality near edge devices. Additionally, the author of [62] suggests using Neurosurgeon, which dynamically partitions deep neural networks between mobile devices and cloud servers to minimize latency and energy consumption.

Recent studies have also highlighted the importance of communication-efficient edge learning. Edge computing frameworks aim to optimize computation and communication under resource constraints and heterogeneous environments [1,2].

2.2.1. Federated Learning for Communication-Efficient IoT

Federated learning (FL) has become a promising approach for distributed model training without sharing raw data. McMahan et al. [63] introduced the Federated Averaging (FedAvg) algorithm, which enables collaborative training across multiple clients.

Several works have focused on improving communication efficiency in FL. Konečný et al. [64] proposed structured updates and compression techniques, while Lin et al. [65] introduced Deep Gradient Compression to reduce communication bandwidth.

In addition, Caldas et al. [60] showed that device heterogeneity significantly impacts FL performance and convergence. Communication-efficient FL methods have also been investigated to reduce transmission overhead while maintaining model accuracy [25].

2.2.2. Split Learning for Edge Intelligence

The concept of split learning (SL) has been proposed as a means to reduce the computational burden on edge devices by splitting neural networks across clients and servers. Gupta and Raskar [9] introduced this paradigm, while Vepakomma et al. [26] demonstrated its applicability in privacy-sensitive applications.

Recent works have explored improvements in SL. Thapa et al. [28] proposed hybrid partitioning strategies for edge–cloud systems.

2.2.3. Hybrid Federated–Split Learning Frameworks

A hybrid framework that combines the advantages of FL and SL has been proposed. For example, Thapa et al. [28] proposed hybrid architectures that integrate federated and split learning. Additionally, [66] proposes Dynamic Federated Split Learning (DFL), which dynamically partitions models and groups devices across varying IoT environments. Despite this, neither of these methods uses adaptive compression techniques to make training more effective for communication.

2.3. Discussion and Research Gaps

As summarized in Table 1, existing approaches to IoT data reduction and distributed learning address different aspects of communication efficiency. However, they are typically developed in isolation.

Table 1. A comparison of IoT data reduction and distributed learning approaches.

Method	Category	Communication Reduction	Heterogeneity Support	Adaptive Capability	Limitation
Santini et al. [8]	Statistical	Medium	No	No	Limited to simple data patterns
PLA [43]	Sampling	Medium	No	No	Lossy approximation
Compressive Sensing [47]	Compression	High	No	No	Reconstruction complexity
DeepIoT [58]	ML/DL	High	Partial	No	High computational cost
FedAvg [63]	Distributed Learning	Medium	Partial	No	High communication overhead
Deep Gradient Compression [65]	Distributed Learning	High	No	No	No adaptability to heterogeneous environments
Split Learning [9]	Distributed Learning	Medium	Partial	No	Large intermediate activations
SplitFed [28]	Hybrid	Medium	Partial	Limited	Static architecture
DFL [66]	Hybrid	Medium	Yes	Partial	No adaptive compression
HADFL-AC (Proposed)	Hybrid	High	Yes	Yes	—

The statistics filtering, sampling, and compression techniques used in IoT data reduction are incompatible with distributed learning frameworks and cannot handle complex data patterns.

Conversely, distributed learning approaches such as federated learning (FL) and split learning (SL), however, shift the focus from raw data transmission to collaborative model training. In FL, model updates are exchanged instead of raw data, thereby preserving privacy risks; however, this requires frequent parameter updates, which impose significant communication overhead, particularly in large-scale IoT systems. Similarly, SL reduces the computational burden on edge devices by partitioning neural networks, although it incurs an additional communication cost due to intermediate activations.

Furthermore, hybrid frameworks merge the advantages of FL and SL, such as SplitFed and Dynamic Federated Split Learning (DFL), to enhance the scalability and heterogeneity of the Internet of Things (IoT). However, prior studies often rely on static reduction strategies in FL or SL that fail to adapt to heterogeneous device capabilities, dynamic network conditions, or varying workloads in IoT environments [32]. Despite these approaches enhancing resource utilization, they do not incorporate adaptive mechanisms to dynamically reduce communication overhead during training.

As a result, there is still a significant research gap in developing integrated frameworks that optimize distributed learning and data reduction. Specifically, the development of learning frameworks capable of dynamically balancing computation and communication, integrating adaptive compression mechanisms into the training pipeline, and adapting to heterogeneous IoT environments is needed.

To address these challenges, this paper proposes the Heterogeneity-Aware Dynamic Federated Split Learning with Adaptive Compression (HADFL-AC) framework. Using dynamic model partitioning, adaptive compression, and heterogeneity-aware optimization, this framework enables scalable, communications-efficient edge IoT learning.

3. Materials and Methods

In this section, the materials and methods used to develop and evaluate the proposed model are described. First, the research problem is formulated. Following is a brief description of the proposed Heterogeneity-Aware Dynamic Federated Split Learning with Adaptive Compression (HADFL-AC), including its backbone and compression methods. In addition, a detailed discussion of the compression modules, model architecture, bandwidth-aware adaptation policy, datasets and pre-processing, and training protocol follows. Afterward, hyperparameter tuning is discussed. Furthermore, the performance evaluation is explained. Finally, the implementation details are presented.

3.1. Problem Formulation

Data reduction in edge IoT systems and distributed learning remain problems to be resolved. Despite the effectiveness of current data reduction techniques, they are not designed for use in distributed learning pipelines. While distributed learning methods, such as federated learning and split learning, enable collaborative model training, they make communication considerably more challenging during iterative updates.

Moreover, different types of IoT devices have varying computational and communication capabilities, making it harder to implement efficient and stable training. Currently, there is a lack of adaptive mechanisms to dynamically optimize communication cost under such heterogeneous conditions.

Therefore, the purpose of this work is to develop a unified distributed learning framework that optimizes communication efficiency, computing distribution, and adaptability within heterogeneous IoT environments.

3.2. Overview of a Heterogeneity-Aware Dynamic Federated Split Learning Framework with Adaptive Compression (HADFL-AC)

The proposed Heterogeneity-Aware Dynamic Federated Split Learning with Adaptive Compressor (HADFL-AC) framework is designed to address the key limitations identified.

Here, the proposed system is explained in detail, including how it will work in practice. Figure 1 shows that the proposed HADFL-AC framework alternates between split learning and federated learning training procedures on heterogeneous edge devices.

Figure 1. Overview of the proposed Heterogeneity-Aware Dynamic Federated Split Learning with Adaptive Compression (HADFL-AC) framework.

3.2.1. Background of Backbone and Compression Methods

The multi-compressor Federated Split Learning framework recommends using ResNet-18 as a feature extractor for its good balance between model capability and computational efficiency. ResNet-18 learns deep representations without using many parameters, unlike traditional convolutional models such as VGG16, which have more than 100 million parameters and deep, densely connected layers [66]. In addition to being smaller (11.7 million parameters instead of 138 million), ResNet-18 works well on a set of standard vision benchmarks.

IoT devices with low power consumption usually have strict limits on the amount of memory, processing power, and energy they can use. In general, networks with large convolutional filters and dense classification heads exceed these limits, meaning they must be offloaded entirely to the cloud or aggressively pruned. In contrast, ResNet-18 reduces the number of floating point operations (1.8 GFLOPs per inference), which allows it to run on edge processors with moderate hardware acceleration [3,4].

The proposed framework runs only the first few convolutional stages of ResNet-18 locally on the client side, further reducing the computational load. Afterward, the compression modules work on the output feature map from the split layer (usually a 512-channel tensor). VGG activations send more data than ResNet-18 activations since ResNet blocks’ intermediate representations are not as wide or spatially dimensional. As a result, this feature is ideal for IoT applications with limited bandwidth and efficiently works with the proposed dynamic compression switching strategy.

In ResNet-18, the first convolutional stage uses a 7 × 7 kernel, followed by four residual stages [67,68]:

$${\mathbf{x}}_{l+1}={\mathbf{x}}_l+\mathcal{F}({\mathbf{x}}_l;{\mathbf{W}}_l)$$

(1)

where $\mathcal{F}({\mathbf{x}}_l;{\mathbf{W}}_l)$ represents a sequence of Batch Normalization (BN), ReLU activation, and convolutional operations parameterized by learnable weights ${\mathbf{W}}_l$. The residual identity mapping facilitates efficient gradient propagation, enabling deep representational learning without degradation [67].

In the proposed implementation, the feature tensor extracted after stage 4, with shape 512 × H × W, is selected as the split point for the compression module.

ResNet-18 is well-suited for Dynamic Federated Split Learning due to its stable feature representation and relatively low channel dimensionality. As the network depth increases, the spatial dimensions are progressively reduced, resulting in more compact feature maps. Compared with architectures such as VGG, which produce large early-stage activations (e.g., 512 × 32 × 32), ResNet-18 generates more communication-efficient intermediate representations. This property enables effective real-time switching of compression modules while maintaining stable model accuracy.

3.2.2. Utilized Compression Modules

In adaptive multi-compressor federated split learning, a key component is the feature compression module located on the client side prior to data transmission. Three complementary approaches are considered: Principal Component Analysis (PCA), a lightweight autoencoder (TinyAE), and a hybrid PCA+AE architecture. Each compressor operates on the feature vector $\mathbf{x}\in {\mathbb{R}}^d$ extracted at the split point of ResNet-18.

• Principal Component Analysis (PCA): PCA is a classical linear dimensionality reduction method that projects the feature vector $\mathbf{x}\in {\mathbb{R}}^d$ onto a k-dimensional subspace spanned by the eigenvectors of the covariance matrix [69]. Formally,

  $$\mathbf{z}={\mathbf{W}}^{\top }\mathbf{x}$$

  (2)

  where $\mathbf{W}\in {\mathbb{R}}^{d\times k}$ is an orthogonal projection matrix containing the top-k eigenvectors. The resulting compressed representation is $\mathbf{z}\in {\mathbb{R}}^k$, achieving a reduction ratio of ${\displaystyle \frac{d}{k}}$.
  In the experiments, PCA achieves significant compression with minimal impact on model accuracy.
• Tiny Autoencoder (TinyAE): The autoencoder learns a nonlinear encoding function $f_{\theta }:{\mathbb{R}}^d\to {\mathbb{R}}^k$ and a reconstruction function $g_{\varphi }:{\mathbb{R}}^k\to {\mathbb{R}}^d$ by minimizing a reconstruction objective [70]:

  $$\underset{\theta ,\varphi }{min}{∥\mathbf{x}-g_{\varphi }\left(f_{\theta }\left(\mathbf{x}\right)\right)∥}_2^2$$

  (3)
  Unlike PCA, the autoencoder captures nonlinear structure in the feature space, preserving task-relevant information even when k is small. To support low-power IoT deployment, a lightweight TinyAE is designed using a shallow encoder–decoder architecture.
• Hybrid PCA + AE: PCA is computationally efficient but limited to linear transformations, whereas autoencoders preserve nonlinear information at a higher computational cost. Therefore, both are combined by applying PCA as a linear bottleneck followed by a nonlinear encoder:

  $$\mathbf{z}=f_{\theta }\left({\mathbf{W}}^{\top }\mathbf{x}\right)$$

  (4)

  where $\mathbf{W}\in {\mathbb{R}}^{d\times k}$ is the PCA projection matrix, and $f_{\theta }$ represents the TinyAE encoder that maps the reduced representation into a refined latent space. This hybrid approach benefits from the efficiency of PCA and the expressive power of the autoencoder, achieving a balance between compression and accuracy.

3.2.3. Framework and Model Architecture

The proposed Hybrid Adaptive Distributed Federated Learning (HADFL) framework is designed to address communication costs in heterogeneous distributed learning environments. The system consists of multiple edge clients and a central server that collaboratively train a shared deep learning model without exchanging raw data.

Each client processes its local data using a client-side sub-network up to a selected split layers shown in Figure 1. The resulting intermediate feature representation is then compressed and transmitted to the server. The forward and backward passes are handled on the server side, and the model’s parameters are adjusted accordingly.

The system’s underlying model is based on a deep convolutional neural network backbone (e.g., ResNet-18), comprising client-side and server-side components. Split points determine the model’s division. A deeper split point yields more compact intermediate tensors, thereby reducing communication costs, whereas earlier split points yield more stable optimization due to richer feature representations.

Instead of transmitting full model parameters or raw inputs as in [63], in the HADFL framework, multiple edge clients collaboratively train a shared model while keeping raw data locally. In addition, the framework adopts a split learning mechanism [26] in which intermediate feature representations are exchanged between the client-side and server-side model partitions. This design reduces communication overhead while preserving data privacy.

3.2.4. Bandwidth-Aware Adaptation Policy

The proposed framework uses a bandwidth-aware adaptation mechanism that dynamically selects the split layer and the compression method for each communication round.

The decision process is defined as

$$(c_t,{\mathcal{C}}_t)=\pi \left(b_t\right)$$

(5)

where $b_t$ represents the available bandwidth at round t, $c_t$ denotes the selected split layer, and ${\mathcal{C}}_t$ represents the chosen compression method.

According to the HADFL-AC framework presented in Figure 1, the adaptation policy operates under three bandwidth regimes, as summarized in Table 2:

Table 2. Bandwidth-aware selection of the split layer and compression method.

Bandwidth Condition	Cut Layer	Compression
Very low	3	Hybrid
Low/medium	4	Hybrid
High	4	TinyAE

• Very low bandwidth: An intermediate split layer combined with hybrid compression is used to maintain training stability under severe communication constraints.
• Low-to-medium bandwidth: A deeper split is selected to reduce communication cost, while hybrid compression further minimizes the transmitted data volume.
• High bandwidth: A deeper split is maintained, and TinyAE-based compression is applied to preserve predictive performance while ensuring efficient representation.

Optimized compressors, such as TinyAE, are based on autoencoders, which are inspired by representation learning techniques explained in [12]. Furthermore, hybrid compression combines structured reduction with learned encoding to achieve stronger compression under constrained conditions.

An initial warm-up phase is introduced to stabilize training. During this phase, a fixed split configuration without compression is used. After the warm-up phase, adaptive split selection and compression are activated. Reducing the warm-up duration improves communication efficiency without affecting final accuracy.

3.2.5. Dataset and Pre-Processing

The datasets utilized in the experiment include the CIFAR-10 [71] and CINIC-10 [72] datasets for the training and testing operations. In the CIFAR-10 dataset, there are 60 k 32 × 32 × 3 images divided into ten classes of 6k images per class. There are 50k training images and 10k testing images included in the dataset. However, CINIC-10 comprises images from CIFAR-10 and the ImageNet database, resulting in a wider, more varied set of images.

CINIC-10 is a dataset designed to bridge the gap between standardized academic benchmarks and high-quality data from real-world applications. A total of 270,000 images are included in the dataset, with 90,000 images in each training, validation, and testing set. Each picture is a color image of 32 × 32 × 3, divided into ten groups. A balanced representation of categories is ensured in every split by using 9000 images per class. The larger size and diversity of this dataset make it a more challenging benchmark, enabling evaluation of the robustness of ML models.

During pre-processing, images are normalized and transformed, non-IID client portions are partitioned, and reproducibility and fairness are evaluated. To ensure fairness, this pre-processing pipeline is applied consistently across all clients and compared methods. First, input normalization is applied by converting images into tensors and standardizing them using per-channel mean μ and standard deviation σ, following standard deep learning practices [70]. The normalized input is defined as

$$\widehat{\mathbf{x}}={\displaystyle \frac{\mathbf{x}-\mathit{\mu }}{\mathit{\sigma }}}$$

(6)

Next, a realistic heterogeneous federated setting is simulated using a Dirichlet distribution-based non-IID data partitioning strategy, which is widely adopted in federated learning literature [73]. For each class $k\in \{1,\dots ,K\}$, where K = 10, a client proportion vector is sampled as

$${\mathbf{p}}_k\sim \mathrm{Dir}\left(\mathit{\alpha }\right)$$

(7)

The degree of statistical heterogeneity is controlled by the concentration parameter α > 0. Smaller values of α lead to greater label skew across clients, while larger values produce distributions closer to IID. In this study, α = 0.5 is used, following established federated learning evaluation protocols [63].

Finally, all experiments are conducted with a fixed random seed that governs the Dirichlet partitioning, local sampling, and network condition simulation. This ensures controlled and reproducible evaluation, where all compared methods share identical data distributions and network conditions.

3.2.6. Training Protocol

The overall training procedure is described in Algorithm 1, and the adaptive policy used to select the split layer and compression method is described in Algorithm 2. At each communication round, the system first observes the current network condition and, using the adaptive policy, determines the appropriate split layer and compression method.

Algorithm 1 The HADFL training procedure.

Require: Number of rounds T, warm-up rounds $T_{\mathrm{warm}}$

Require: Bandwidth $b_t$ at each round

1: for t = 1 to T do

2:    Observe network condition $b_t$

3:    if $t\le T_{\mathrm{warm}}$ then

4:       $c_t\leftarrow c_{\mathrm{fixed}}$

5:       ${\mathcal{C}}_t\leftarrow$ None

6:    else

7:       $(c_t,{\mathcal{C}}_t)\leftarrow \pi \left(b_t\right)$

8:    end if

9:    for each client k do

10:       Compute forward pass up to layer $c_t$

11:       Generate intermediate feature $z_k$

12:       Compress $z_k$ using ${\mathcal{C}}_t$

13:       Send compressed features to server

14:    end for

15:    Server performs forward and backward propagation

16:    Server sends gradients back to clients

17:    Clients update local model parameters

18: end for

Algorithm 2 HADFL adaptive policy for split and compression selection.

Require: Round index t, bandwidth $b_t$

1: if  $t\le T_{\mathrm{warm}}$ then

2:     $c_t\leftarrow c_{\mathrm{fixed}}$

3:     ${\mathcal{C}}_t\leftarrow$ None

4: else

5:    if $b_t<{\tau }_{\mathrm{low}}$ then

6:       $c_t\leftarrow 3$

7:       ${\mathcal{C}}_t\leftarrow$ Hybrid

8:    else if $b_t\le {\tau }_{\mathrm{mid}}$ then

9:       $c_t\leftarrow 4$

10:       ${\mathcal{C}}_t\leftarrow$ Hybrid

11:    else

12:       $c_t\leftarrow 4$

13:       ${\mathcal{C}}_t\leftarrow$ TinyAE

14:    end if

15: end if

16:

17: return$(c_t,{\mathcal{C}}_t)$

3.3. Experimental Settings

Hyperparameter tuning was conducted to balance the predictive performance, communication efficiency, and training stability. In contrast to conventional settings, HADFL-AC incorporates communication-related and learning-related parameters. Table 3 summarizes the main HADFL-AC framework settings.

Table 3. The hyperparameter configuration used in the experiments.

Category	Value
Model	ResNet-18 (split learning)
Number of Clients	5
Dataset	CIFAR-10, CINIC-10
Batch Size	128
Learning Rate	$3\times {10}^{-4}$
Optimizer	AdamW
Epochs per Round	3
Communication Rounds	50
Split Points	$\{3,4\}$
Warm-up Rounds	2
Max Cut Change	1
Compression Methods	TinyAE, hybrid
TinyAE Bottleneck	Reduced (group size = 4)
PCA	Baseline only (not used in final policy)
Dirichlet α	0.5, 0.3, 0.2
Bandwidth Levels	Low, medium, high
Low Bandwidth	<1 Mbps
Medium Bandwidth	1–10 Mbps
High Bandwidth	>10 Mbps

3.3.1. Optimization Hyperparameter

To ensure a fair comparison, the training configuration was kept consistent across all experiments. This method uses 128 batches and three local epochs per round. A total of 50 communication rounds were used to ensure the stable convergence of the model. Model optimization was performed using AdamW with a learning rate of $3\times {10}^{-4}$.

During the warm-up phase, a fixed split configuration without compression is used to stabilize training. Afterward, the adaptive mechanism dynamically adjusts the computation partitioning and compression strategy.

Each client computes forward through the chosen split layer and then sends the compressed intermediate features to the server. The server then completes the forward and backward passes, sending gradients back to the clients for local updates.

3.3.2. Split and Compression Configuration

Candidates for split points were limited to intermediate layers of the model, with a particular focus on cut indices 3 and 4, which presented a satisfactory balance between feature quality and communication costs. Several compression strategies were selected dynamically from Hybrid and TinyAE, although PCA was excluded from the final configuration due to its limited effectiveness under strong compression. As part of improving communication efficiency, a reduced TinyAE bottleneck was employed while maintaining sufficient feature representation.

3.3.3. Adaptive Policy and Warm-Up

To stabilize early training, two warm-up rounds were introduced with a conservative configuration (cut = 3; no compression). To maintain feature quality, compression was gradually introduced after this phase.

During consecutive rounds, the split depth could not exceed a predefined level to prevent abrupt transitions. By allowing only one level of change in the split index, smooth adaptation and stability were maintained.

Furthermore, bandwidth thresholds were used to control the adaptive policy. When bandwidth requirements were extremely low, a conservative configuration was used (cut = 3), while when bandwidth was higher, a deeper split (cut = 4) combined with either Hybrid or TinyAE compression was used.

3.3.4. Heterogeneity Settings

The system’s robustness was evaluated under heterogeneous conditions to assess its performance under realistic conditions. To generate non-IID client data partitions across five clients, a Dirichlet distribution with $\mathit{\alpha }=0.5,0.3,0.2$ was used.

A probabilistic WiFi model was used to simulate network heterogeneity, in which bandwidth levels (low, medium, or high) were assigned with predefined probabilities. Additionally, heterogeneity in device size and client variability were implicitly accounted for through differences in communication conditions and local data sizes.

3.3.5. Model Selection Criterion

Hyperparameter selection was guided by a multiobjective criterion, which incorporated several factors:

• Test accuracy;
• Total communication cost;
• Total training time;
• Training stability across rounds.

As a result of the selected selection strategy, HADFL-AC is well-suited to achieve its objective of operating efficiently under communication constraints without compromising model performance.

3.3.6. Final Configuration

An effective final configuration involves TinyAE-based compression, bandwidth-aware splits, and a short warm-up. With this setup, substantial communication reduction was achieved under heterogeneous conditions, along with a stable training trajectory.

3.4. Performance Evaluation

To comprehensively evaluate the proposed HADFL-AC framework, we adopted a multi-dimensional evaluation methodology that captures system-level efficiency and model performance. The evaluation follows established practices in federated and distributed learning, where communication cost, training efficiency, and predictive performance jointly determine the effectiveness of a method [25,63,64,74].

In addition, the proposed framework is evaluated under realistic heterogeneous conditions, including non-IID data distributions, time-varying network bandwidth, device heterogeneity, and client churn. This allows us to assess not only efficiency improvements but also robustness and generalization under practical deployment scenarios.

3.4.1. Training Efficiency

Training efficiency is measured in terms of the total training time and average per-round latency. The total training time is defined as

$$T_{\mathrm{total}}=\sum _{r=1}^R{T}_r$$

(8)

where $T_r$ denotes the duration (in seconds) of round r, including the computation and communication overhead, and R is the total number of rounds. The average latency per round is given by

$$T_{\mathrm{avg}}={\displaystyle \frac{T_{\mathrm{total}}}{R}}$$

(9)

These metrics reflect the end-to-end system efficiency, which is a primary optimization objective in distributed learning systems [25,75].

3.4.2. Communication Efficiency

The communication efficiency is evaluated through the total transmitted data volume:

$$C_{\mathrm{total}}=\sum _{r=1}^R{C}_r$$

(10)

where $C_r$ represents the communication cost (in MB) in round r. The average communication per round is

$$C_{\mathrm{avg}}={\displaystyle \frac{C_{\mathrm{total}}}{R}}$$

(11)

To quantify compression effectiveness, we use the data reduction ratio (DRR):

$$\mathrm{DRR}=100\times \left(1-{\displaystyle \frac{C_{\mathrm{method}}}{C_{\mathrm{raw}}}}\right)$$

(12)

where $C_{\mathrm{method}}$ and $C_{\mathrm{raw}}$ denote the total communication cost of the evaluated method and the uncompressed baseline, respectively. While communication reduction is a key objective, it is important to note that reduced communication does not always directly translate into a lower runtime due to system-level interactions [30].

3.4.3. Energy Consumption

Communication energy is often proportional to transmitted data size, making data reduction critical for energy-efficient IoT systems [52,76]. Energy consumption is estimated based on computation and communication costs, following the formulation used in distributed learning systems [66]:

$$E_{\mathrm{total}}^{\left(m\right)}=E_{\mathrm{comp}}^{\left(m\right)}+E_{\mathrm{comm}}^{\left(m\right)}$$

(13)

Assuming constant power levels for computation ($P_{\mathrm{comp}}$) and transmission ($P_{\mathrm{tx}}$), the energy consumption for method m is computed as

$$E_{\mathrm{comp}}^{\left(m\right)}=P_{\mathrm{comp}}\sum _{r=1}^R{T}_{\mathrm{comp}}^{(m,r)}$$

(14)

$$E_{\mathrm{comm}}^{\left(m\right)}=P_{\mathrm{tx}}\sum _{r=1}^R{T}_{\mathrm{comm}}^{(m,r)}$$

(15)

Lower values of $E_{\mathrm{total}}^{\left(m\right)}$ indicate higher energy efficiency.

3.4.4. Data Reduction

The effectiveness of feature compression is further quantified using the data reduction ratio:

$$R_{\mathrm{red}}=1-{\displaystyle \frac{D_{\mathrm{reduced}}}{D_{\mathrm{original}}}}$$

(16)

where $D_{\mathrm{original}}$ and $D_{\mathrm{reduced}}$ denote the data size before and after compression, respectively. This metric directly reflects the impact of the proposed compression strategies on transmission efficiency.

3.4.5. Model Performance

To ensure that communication efficiency does not compromise learning quality, we report the best and final test accuracy:

$$\mathrm{Accuracy}={\displaystyle \frac{N_{\mathrm{correct}}}{N_{\mathrm{total}}}}\times 100\%$$

(17)

For each method m, we report the following:

• $A_{\mathrm{best}}^{\left(m\right)}$: The best accuracy achieved during training;
• $A_{\mathrm{final}}^{\left(m\right)}$: The final accuracy at convergence.

These metrics verify that the proposed adaptive compression mechanism preserves model performance while improving system efficiency [4,56].

3.4.6. Trade-Off Analysis

The final analysis focuses on the trade-off between the model’s accuracy and communication efficiency. Although stronger compression and deeper split configurations can significantly reduce communication overhead, they may negatively impact feature quality when applied prematurely. By applying an adaptive framework, this issue is mitigated by dynamically adjusting the split and compression strategies, thereby enabling operation along a controlled trade-off frontier between efficiency and predictive accuracy.

3.5. Implementation Details

A Python 3.12.13 implementation was used to implement the framework. To ensure reproducibility, all experiments were conducted on identical hardware and software. The implementation supports a dynamic split selection method, feature compression, bandwidth simulation, and logging of performance metrics across communication rounds. Experiments were conducted in a Google Colab environment.

4. Results

A detailed description of the adaptive split analysis is presented in this section. A three-part analysis is conducted in the beginning to evaluate whether the adaptive strategy works: (i) whether adaptation occurs, (ii) whether it is consistent with network conditions, and (iii) whether it enhances performance. Next, the use of heterogeneity analysis to test the framework under different scenarios, including heterogeneity across devices, networks, and devices, is detailed. Finally, a comparison is made between the proposed system and previous studies.

4.1. Overall Performance

As part of the evaluation process, the HADFL-AC framework is compared with an uncompressed baseline (raw) and static compression approaches, including PCA, TinyAE, and Hybrid. The comparison accounts for the total communication cost, total training time, and total energy consumption.

Evaluations are conducted on CIFAR-10 and CINIC-10 datasets. In Figure 2, the total communication (MB), total training time (s), and total energy consumption (J) are shown. Static compression keeps the compression ratio constant, regardless of the network conditions. This makes its performance predictable, even if it is not always the best. In contrast to static approaches, the proposed dynamic framework adapts to runtime network conditions to reduce unnecessary data transmission and improve overall system performance.

Figure 2. Overall efficiency comparison across CIFAR10 and CINIC datasets. The dynamic method consistently reduces the total training time and energy consumption while maintaining a competitive communication cost compared with static compression methods.

Based on Figure 2, the dynamic approach reduces communication by over 80% compared with the uncompressed baseline on CIFAR-10, and approximately 81% compared with the best static method (Hybrid). A communication reduction of approximately 77.2% is achieved on the more challenging CINIC-10 dataset, reducing the total communication from more than 140 GB to about 32 GB. As a result, the framework can handle larger datasets while still enabling efficient communication.

Dynamic approaches consistently deliver lower total training times than static approaches, improving training efficiency. According to CIFAR-10, the reduction reaches approximately 70.93%, while CINIC-10 achieves approximately 62%. A major factor behind these improvements is a reduction in communication overhead, particularly in low- and medium-bandwidth regimes where transmission latency dominates the training process.

Accordingly, the dynamic approach uses the least energy among all methods, measured in J. Due to the direct relationship between communication energy and the transmitted data volume, reducing communication saves significant amounts of energy. As a result, CIFAR-10 reduces energy by approximately 69.25%, while CINIC-10 reduces energy by approximately 62%.

Generally, the results show a strong correlation between reduced communication and energy efficiency. The results confirm that HADFL-AC performs effectively under heterogeneous conditions in balancing efficiency and prediction.

4.2. Adaptive Split Analysis

A three-part analysis is conducted to evaluate the effectiveness of the proposed adaptive strategy: (i) whether adaptation occurs, (ii) whether the adaptation is consistent with network conditions, and (iii) whether the adaptation leads to performance improvements.

• Adaptation behavior: The first step is to determine whether the proposed method changes its settings during training. An analysis of the proposed framework is performed in relation to the split selection and compression strategy. Table 4 summarizes the distribution of selected split points (cuts) across all training rounds. Based on the results, there is more than one split point.
  Table 4. The distribution of selected split layers across communication rounds.

  Cut Layer	Usage (%)
  3	10.0
  4	90.0

  Table 4 shows that cut layer 4 is selected in 90% of the rounds, indicating that the framework primarily relies on the deeper split for communication efficiency. The less frequent use of cut layer 3 reflects its role as a stability-oriented fallback rather than a dominant operating mode.
  Similarly, Table 5 also demonstrates that the compression strategy varies dynamically depending on the round. The use of TinyAE accounts for 52% of the rounds, while hybrid compression accounts for 44%, and no compression is applied only during the warm-up phase (4%).
  Table 5. The distribution of compressor selection across communication rounds.

  Compressor	Usage (%)
  None	4.0
  TinyAE	52.0
  Hybrid	44.0

  Although the split layer changes less frequently than the compression strategy, this behavior is consistent with the framework’s design objectives. During most rounds, deeper split configurations are selected because they offer the greatest communication savings, while shallower splits are retained only as a fallback mechanism. Consequently, fine-grained adaptation is primarily determined by the compression strategy rather than the location of the split.
  According to these results, the framework actively adapts the partitioning and compression strategies, rather than using a fixed configuration.
• Consistency with network conditions: The significance of the adaptation is assessed by the correlation between network conditions and the selected configurations. Table 6 shows that the average split depth increases as bandwidth increases, shifting from 3.73 under low-bandwidth conditions to 4.00 under high-bandwidth conditions.
  Table 6. The relationship between network conditions and adaptive decisions.

  Network Level	Avg Cut	Most Frequently Used Compressor
  Low	3.73	Hybrid
  Mid	3.96	TinyAE
  High	4.00	TinyAE

  Adapting the compression technique to network conditions is a key feature of the proposed framework. To achieve stronger data reduction, hybrid compression is most commonly selected when the bandwidth is low, combining TinyAE with PCA. Conversely, TinyAE is preferred when the bandwidth is medium or high, as it preserves feature quality without sacrificing compression efficiency. As a result, the system’s behavior reveals an adaptive mechanism that is well aligned with communication costs and representation quality. Due to this behavior, the framework can balance aggressive compression with representation fidelity depending on the available network resources.
• Performance impact: The last step is to determine whether the adaptive behavior translates into measurable performance gains. The proposed method is compared against lossless transmission and fixed-compression baselines.
  The proposed framework achieves an optimal balance between communication efficiency and model accuracy. Even with a reduction of over 80.91% in communication, the model maintains 79.58% accuracy, with only marginal improvements over baselines.
  Simultaneously, it significantly reduces communication costs to 3704 MB, compared with 19,400 MB in the baseline setting. Regarding the training time, the proposed method takes a total of 11,522 s, reducing it by approximately 70.92% compared with the lossless baseline, which is equal to 39,623 s. With the dynamic approach, accuracy is equal to or better than the fixed compression baseline, while the communication costs and total runtime are further reduced. As a result, the results emphasize that computation partitioning and communication compression need to be jointly optimized in distributed learning systems.

Generally, the results demonstrate that the proposed adaptive strategy is effective across all three dimensions. Methodologically, the method actively adjusts its configuration and aligns its decisions with network conditions to trade off accuracy, communication, and training time. Based on these findings, the proposed framework dynamically adjusts the split layer and the compression strategy in response to network conditions.

4.3. Heterogeneity Analysis

In this section, the framework is tested under different scenarios, e.g., device, network, and device heterogeneity. Each of these will be discussed separately.

4.3.1. Data Heterogeneity

To assess the robustness of the proposed framework under statistical heterogeneity, a Dirichlet distribution is used. In this model, there are three concentration parameters: α = 0.5, α = 0.3, and α = 0.2. The lower the α value, the stronger the non-IID data distribution, resulting in a more severe imbalance across clients. Conversely, increasing heterogeneity made the training task more challenging because local client distributions changed more frequently.

In such situations, communication-efficient distributed learning methods are typically unable to achieve high predictive performance or to tolerate aggressive compression. Despite this challenge, the proposed HADFL framework maintained strong communication efficiency across heterogeneous levels.

Despite skewed data distributions, the framework remains strong when the data becomes more skewed. This means that the adaptive combination of split selection and compression can help reduce the negative effects of non-IID data.

There is a general consensus that increasing the heterogeneity of data (i.e., smaller Dirichlet α) adversely affects model performance [30,73]. Communication reduction, however, is primarily governed by the compression and partitioning strategies, which makes it less sensitive to statistical heterogeneity. Consequently, while accuracy may decrease under non-IID conditions with greater strength, communication efficiency usually remains stable or deteriorates only slightly.

For α = 0.5, the proposed framework reached an accuracy of 79.58% and a communication reduction of 80.90%. A change in accuracy occurred when heterogeneity was set to 0.3, while communication remained at 80.85%. Even in the hardest situation, α = 0.2, the framework achieved 72.22% accuracy and 80.85% less communication.

As expected, strengthening non-IID conditions led to a gradual decrease in accuracy. Nevertheless, the communication reduction remained high in all settings, indicating that the proposed framework is more sensitive to statistical heterogeneity in predictive performance than in communication efficiency.

4.3.2. Network Heterogeneity

According to the adaptive split analysis in Section 5.1, the proposed framework does not rely on a fixed split point or compression strategy. With each communication round, it dynamically adjusts its behavior based on the observed bandwidth. Analyzing performance across different bandwidth regimes is part of the analysis in this section, which complements the adaptive split analysis.

To avoid the effects of unstable early rounds, the results are shown as late-stage averages, which more accurately reflect the model’s behavior after warm-up and adaptive stabilization.

Based on Table 7, the framework maintains a similar level of performance regardless of the changes in the communication costs and runtime caused by network conditions. Specifically, low-bandwidth regimes incur the highest runtime since slower transmission becomes the bottleneck. In contrast to low-bandwidth regimes, high-bandwidth regimes often employ deeper split configurations and stronger compression to achieve the lowest communication overhead and runtime.

Table 7. Late-stage performance under different bandwidth conditions.

Bandwidth Level	Late-Stage Avg. Accuracy (%)	Comm. (MB)	Time (s)
Low	75.02	466.83	2712.53
Medium	74.56	509.26	763.46
High	74.48	291.00	314.79

These trends are fully consistent with the adaptive split analysis. Under constrained bandwidth, the framework tends to prefer safer, more conservative operating points to keep things stable. When bandwidth conditions are more favorable, the system can shift to deeper splits and more communication-efficient compression choices. Accordingly, the analysis of network heterogeneity confirms that adaptive behavior yields practical efficiency gains without sacrificing predictive performance.

4.3.3. Device Heterogeneity and Client Churn

A distributed learning system in the real world is inherently heterogeneous, with devices having significantly different computational capacity, memory, and energy constraints [25,75]. The proposed framework is evaluated realistically by incorporating device heterogeneity and client churn into the training process.

The device heterogeneity setup is as follows: each client has a computational profile that reflects its hardware capability. In federated learning simulations, the clients are divided into three categories: fast, medium, and slow, following similar practices in federated learning simulations [25]. These tiers are modeled using two scaling factors, the time scaling factor and the batch capacity scaling factor. The time scaling factor simulates computation latency, whereas the batch capacity scaling factor limits the number of local updates.

For example, clients with fast connections show shorter execution times and update their local data more often. In contrast, clients with slower connections have longer delays and process fewer local updates. A more realistic edge scenario is captured in this design, where resource-constrained devices contribute less frequently and less effectively to the global model overall.

In addition to device variability, client churn is simulated by randomly selecting a group of active clients at each communication round, and devices can differ [75]. As a result, the number of participating clients changes dynamically (for example, 3/5, 4/5, or 5/5 clients), leading to instability in the training process.

According to the experimental results, aggressive compression strategies lead to instability under heterogeneous joint conditions. A deep split configuration with strong compression (cut = four with TinyAE), for instance, leads to a sharp drop in accuracy (e.g., from ∼68% to below 45%) when only a small number of clients are active (e.g., three out of five).

To solve this problem, the proposed framework incorporates churn-aware adaptive policies. In more conservative configurations, the system switches to an earlier split (cut = three) combined with hybrid compression if the number of active clients is limited. Following this adjustment, training stabilizes, and accuracy improves significantly (e.g., recovering to above 75% in subsequent rounds).

Additionally, the framework switches back to a more aggressive configuration when there are more active clients (cut = four with TinyAE), thereby improving performance.

Table 8 shows that a slight reduction in communication efficiency can be observed when incorporating device heterogeneity and client churn. While maintaining high predictive performance, the framework has demonstrated its robustness under realistic system conditions. As a result of the proposed framework, the maximum achievable accuracy is approximately 79.94% with a communication reduction of around 77%, despite the presence of device heterogeneity and client churn.

Table 8. HADFL performance under device heterogeneity and client churn.

Setting	Accuracy (%)	Comm. (MB)	Reduction (%)
Adaptive (No Churn)	79.8	4019	79.3
Adaptive + Device Heterogeneity	79.6	4300	77.8
Adaptive + Device Heterogeneity + Churn	79.94	4480	77.0

Based on these results, adaptive distributed learning should incorporate system awareness. While aggressive compression offers advantages in stable environments, its implementation demands careful oversight when device variability and participation dynamics are present. Adjusting the split point and compression method dynamically allows for a balance between reliability and efficiency. Overall, in conjunction with the adaptive split analysis in Section 4.2, these observations confirm that the framework maintains stable accuracy as it adapts to changing network conditions.

4.4. Comparison with Previous Studies

For a comprehensive evaluation of the proposed HADFL-AC framework, a comparison was conducted with representative approaches in communication-efficient distributed learning, as discussed in Section 2.3. These include federated learning (FL), split learning (SL), and hybrid federated–split learning. As summarized in Table 9, existing methods consider a variety of perspectives, including communication efficiency, heterogeneity, and distributed training; however, these aspects are typically addressed independently rather than jointly.

Table 9. A comparison of related distributed learning studies with representative methods.

Method	Comm. Eff.	Heterogeneity	Adaptivity	Limitation
FedAvg [63]	Low	Partial	No	High communication overhead
DGC [65]	Medium	No	No	Static compression
SL [9]	Medium	Partial	No	Activation overhead
SplitFed [28]	Medium	Partial	Limited	Static architecture
DFL [66]	Medium	Yes	Partial	No adaptive compression
HADFL-AC (Proposed)	High	Yes	Yes	—

FL approaches, such as FedAvg [63], can facilitate collaborative model training without sharing raw data; however, they incur significant communication overhead due to frequent model updates.

Compression methods, like Deep Gradient Compression, as described in [65], reduce the size of gradient updates to lower communication costs. However, these methods do not consider changing network conditions or the differences between devices.

SL [9] reduces the computational burden on edge devices by partitioning neural networks between clients and servers. Despite its advantages, it introduces additional communication overhead because intermediate activations are continuously transmitted during training. Hybrid methodologies seek to leverage the advantages inherent in federated and split learning paradigms. For example, SplitFed [28] combines federated aggregation with split learning, thereby improving scalability.

Furthermore, Dynamic Federated Split Learning (DFL) [66] addresses dynamic client participation, adaptive task offloading, and resource-aware model partitioning to more effectively manage the complexities of heterogeneous IoT environments. Both methods share the same overarching objective: adapting the learning process to heterogeneous, time-varying IoT network conditions. The mechanisms behind them, however, differ significantly. While the original DFL emphasizes dynamic client participation, adaptive task offloading, and resource-aware split point selection, the proposed HADFL-AC framework focuses on feature-level adaptation through hysteresis-based multi-compressor switching that dynamically alternates between hybrid PCA–AE and TinyAE encoders.

Regarding communication efficiency, the original DFL reports an approximate communication-related performance improvement of up to 48%, measured by reduced training time and adaptive offloading overhead, compared with classical FL and static split learning baselines. In contrast, the HADFL-AC framework achieves an overall communication reduction of 70.92% compared with the non-compression baseline, directly measured in transmitted feature volume (MB). By using dynamic feature compression, communication savings can equal—and even exceed—the task-level adaptation of DFL, while maintaining a fixed client participation set and a stable split architecture. In bandwidth-constrained scenarios, the original DFL reduces energy consumption by up to 62.8%. Leveraging the same power-based energy model described in Section 3.4.3, the proposed framework achieves a total energy saving of 80.91% compared with the baseline, primarily due to aggressive feature compression and reduced wireless transmission time. Importantly, both frameworks preserve model accuracy while reducing communication and energy costs. Based on CIFAR-10 experiments, the original DFL reports an accuracy improvement of up to 32% over classical FL baselines, while the proposed HADFL-AC framework reaches a test accuracy of 79.58%.

These results confirm that dynamic, bandwidth-aware feature compression does not degrade learning performance, even under severe network constraints. Based on these results, adaptive feature compression can significantly decrease communication without compromising learning performance. Therefore, a comparison of three communication-efficient learning approaches reveals three complementary design directions: federated learning centers around distributed optimization, split learning emphasizes model partitioning, and hybrid approaches address system heterogeneity.

HADFL-AC, on the other hand, uses a feature-level adaptive compression strategy to optimize communication efficiency, heterogeneity support, and adaptability simultaneously. Based on these results, IoT systems can be scaled and communicated efficiently by integrating adaptive compression with distributed learning, addressing the key limitations identified in Section 2.

Unlike prior work, which often reported improvements across different evaluation protocols and metrics, HADFL-AC explicitly and uniformly quantifies system-level efficiency gains. According to the proposed method, it reduces communication by 80.86%, training time by 70.93%, and energy consumption by 69.25% on CIFAR-10, with consistent improvements on CINIC-10.

A key distinction is that the proposed framework leverages network heterogeneity as a signal of optimization, rather than relying on fixed or partially adaptive strategies. As a result, it can operate effectively across a variety of conditions, making it an ideal candidate for realistic distributed learning environments.

This comparison demonstrates that HADFL-AC is not only more efficient in communication but also introduces a unified adaptive design that accounts for system heterogeneity and resource constraints, which other existing designs do not jointly address.

5. Discussion

In light of the experimental results, several important insights have been gained regarding the behavior and effectiveness of the proposed HADFL-AC framework.

In the first instance, the results show that adaptive split selection and compression must be optimized jointly. Applying aggressive compression too early can result in instability, particularly when heterogeneous conditions are present. It is crucial to introduce a warm-up phase and gradual adaptation to maintain stable convergence.

Secondly, communication efficiency and model accuracy are clearly inversely related. Despite their ability to reduce communication costs, deeper split configurations and stronger compression can degrade feature quality if applied prematurely. Using the proposed framework, aggressive configurations are delayed to allow the model to stabilize before stronger compression is applied.

As a third outcome, the experiments indicate that compression design matters as much as the adaptive policy itself. With a reduced TinyAE bottleneck, communication efficiency is improved while feature representation is preserved, outperforming linear methods such as PCA.

Furthermore, the proposed approach has been evaluated under multiple forms of heterogeneity and has demonstrated its robustness. As a result, the framework is suitable for real-world distributed learning scenarios, as it can adapt effectively to non-IID data distributions, variable-bandwidth conditions, and dynamic client participation.

Finally, the results obtained on CIFAR-10 and CINIC-10 demonstrate that the framework generalizes beyond the parameters of standard benchmarks. Despite the fact that the performance of the proposed method naturally decreases with dataset complexity, the adaptive behavior remains effective, demonstrating its robustness and scalability.

5.1. Adaptability to Network Conditions

As stated, adapting to bandwidth changes is possible through dynamic frameworks that adjust the split point and compression strategy. In contrast to static compression, dynamic compression continuously improves communication efficiency and training performance.

5.1.1. Communication Versus Bandwidth Fluctuation

Figure 3 illustrates that communication behavior differs with bandwidth. The results indicate that the dynamic framework adjusts the data transmission volume according to the network capacity.

Figure 3. The communication behavior of CIFAR-10 and CINIC-10 under varying bandwidth conditions. In the proposed dynamic framework, the transmitted data volume varies with network conditions, reducing communication when bandwidth is low and increasing representation richness when bandwidth is adequate. In contrast, static compression methods maintain fixed communication regardless of network fluctuations.

As a result of low bandwidth, the framework uses conservative configurations to minimize the communication overhead and maintain the quality of features. The system becomes more stable as bandwidth increases, allowing larger intermediate representations to be transmitted. Comparatively, static compression methods maintain nearly constant communication regardless of the network condition.

An adaptive communication pattern is essential in constrained environments, where excessive data transmission degrades system performance.

5.1.2. Training Time Versus Bandwidth Fluctuation

The training time is affected by network variability, as shown in Figure 4 and Figure 5. As a result of adjusting to instantaneous bandwidth conditions, dynamic approaches consistently reduce the training time compared with fixed approaches.

Figure 4. The average training time per round has fluctuated in CIFAR-10 due to fluctuating network conditions. Through adaptive communication volume, the dynamic framework consistently accelerates end-to-end training compared with static approaches, reducing training time.

Figure 5. The average training time per round for CINIC-10 under fluctuating network conditions. As the dataset’s complexity increases, communication overhead grows, and adaptive compression becomes more effective at reducing training latency.

During low-bandwidth scenarios, the framework minimizes transmission delay by reducing communication volume. In contrast, it improves convergence speed when higher-bandwidth conditions allow richer representations to be transmitted. As a result, this adaptive mechanism results in more efficient end-to-end training.

In complex datasets such as CINIC-10, the communication cost is higher and impacts the overall training latency.

5.1.3. Variance Analysis and Stability

In addition, the dynamic approach exhibits a higher variance than static compression. A major reason for this behavior is the proposed framework’s adaptability.

The dynamic approach continuously adjusts the split point and compression strategy according to instantaneous network conditions, unlike static methods that maintain fixed communication patterns. Therefore, communication behavior is non-uniform across rounds, increasing variance.

It is important to note that this variance does not indicate instability in the learning process. Instead, it reflects the system’s responsiveness to changing bandwidth conditions. Despite these fluctuations, the model maintains stable convergence and consistent performance.

There are several strategies to mitigate excessive variability. The first step is to apply smoothing mechanisms to reduce abrupt changes in split or compression selection across consecutive rounds. Additionally, incorporating hysteresis-based switching can reduce the frequency of configuration oscillations. Furthermore, lightweight scheduling policies can be used to impose predefined constraints on adaptation, improving stability without compromising flexibility.

As a result of adaptive optimization, the observed variance is a trade-off between responsiveness and consistency in dynamic distributed learning systems.

5.1.4. Training Latency Versus Bandwidth Fluctuation

Furthermore, the dynamic framework improves latency stability, even in fluctuating network conditions. Continuous adjustment of compression strength and split configuration prevents wasted communication time under poor network conditions.

As a result, the training behavior is more consistent, reducing variability between rounds and improving the system’s overall robustness. Compared with static compression methods, which can adapt to changing network conditions, static compression methods are more susceptible to bandwidth fluctuations.

Moreover, the increasing efficiency gains in the overall performance analysis are directly explained by the adaptability observed in this section. Using this framework, communication cost, training time, and energy consumption are substantially reduced while maintaining training stability by dynamically adjusting communication and computational behavior.

5.2. Efficiency Gains and Trade-Off Analysis

As a result of the proposed approach, substantial communication reduction is achieved on CIFAR-10, with an 80.86% reduction, and a 77.2% reduction on CINIC-10. The framework also reduces the total training time by approximately 62.3% for CIFAR-10 and 70.93% for CINIC-10. As a result of these improvements, energy consumption has been reduced by 69.25% on CIFAR-10, and by 62% on CINIC-10.

Adaptive split points and compression strategies are largely responsible for these gains, reducing unnecessary data transmission and improving overall system efficiency, particularly under bandwidth-limited conditions.

The results, however, reveal a clear trade-off between communication efficiency and model accuracy. In contrast to CIFAR-10, which allows aggressive compression without adversely affecting performance, CINIC-10 requires more conservative behavior to maintain feature quality. This results in a decrease in accuracy on CINIC-10 relative to the raw baseline, mainly because complex datasets are more sensitive to compression.

Adapting to changing conditions in a controlled manner is critical in this situation. Instead of applying maximum compression at all times, the proposed framework defers aggressive compression until stability is reached to balance efficiency and performance. A controlled efficiency–accuracy frontier is therefore achieved.

As a result, communication-aware adaptive compression can achieve significant system-level efficiency gains while maintaining acceptable model performance in heterogeneous distributed learning environments.

5.3. Findings

From the previous results, the following can be concluded:

5.3.1. HADFL-AC Is Significantly More IoT-Friendly

According to the IoT experiments, HADFL-AC can reduce communication delays by nearly 45–60%, and make deep split inference possible even in bandwidth-limited environments. This validates that the HADFL-AC framework is a practical solution for real-world heterogeneous networks.

5.3.2. HADFL-AC Learning Is More Robust

By changing the cut point and compression type, excess compression is reduced when the network is strong, compression is increased when the network is weak, and representation distortion is prevented. Thus, it achieves a higher accuracy and gradual stability in learning.

5.3.3. Static Compression Remains Acceptable

A static approach performs well in the initial stages, offering a reasonable balance between connectivity and accuracy. However, they are not adaptable to network changes. Therefore, they remain practical solutions but are not ideal for changing wireless environments.

5.4. Implications for Future Edge Intelligence Systems

Dynamic compression enables several aspects:

• Bandwidth-aware adaptive neural networks;
• Intelligent communication resource management;
• Robust deployment under 5G/6G, WiFi, and IoT constraints.

The Heterogeneity-Aware Dynamic Federated Split Learning with Adaptive Compression (HADFL-AC) framework is model-agnostic and can be applied to a wide range of backbones and modalities.

6. Conclusions

The purpose of this study was to investigate the problem of communication inefficiency in distributed learning systems under heterogeneous and dynamically changing network conditions. While existing compression methods reduce communication costs with fixed ratios, they remain unresponsive to network variability, increasing training latency and inefficiently utilizing bandwidth. Therefore, this work introduced the Heterogeneity-Aware Dynamic Federated Split Learning with Adaptive Compression (HADFL-AC) framework.

With HADFL-AC, split learning, federated learning, and bandwidth were considered in heterogeneous IoT settings. Unlike static compression and previous task-level adaptive approaches, HADFL-AC adjusts split points and compression mechanisms in real time based on the current state of the network.

The proposed reproducible prototype of the HADFL-AC framework was developed using a lightweight ResNet-18 architecture and evaluated on the CIFAR10 and CINIC datasets under Dirichlet-based non-IID data partitioning and fluctuating network environments. In addition, static compression techniques were used: linear PCA, nonlinear Tiny Auto-encoder (TinyAE), and hybrid PCA–AE. Furthermore, the cuts were made at three distinct levels, namely, early, mid, and late, as discussed in the Methodology Section.

As demonstrated by experiments on CIFAR-10 and CINIC-10, the proposed framework reduces communication and training time, as well as energy consumption. An 80.86% reduction in communication is achieved while maintaining the performance of a competitive model. In addition, the results highlight the need to balance efficiency and accuracy, especially when working with complex datasets such as CINIC-10.

The adaptability analysis showed that using dynamic compression and split selection is crucial for improving system robustness under unstable network conditions. Using changes in bandwidth as a control signal enables the system to achieve stable, efficient training, eliminating the need for a fixed setup.

Overall, HADFL-AC provides an effective and scalable solution for communication- and energy-efficient distributed learning in IoT systems. Future work may extend this framework by (i) exploring integrating dynamic client participation with adaptive feature compression, (ii) integrating advanced adaptive policies, and (iii) deploying the framework on real hardware platforms to further quantify the system-level performance gains.