Adaptive Joint Compression and Synchronisation in Federated Split Learning for IoT Rainfall Prediction

Source: arXiv:2606.25003 · Published 2026-06-23 · By Wenjie Ding, Yi Sin Lin, Jiale Liu, Baoyi Liu, Guanghua Liu, Zhuolu Li et al.

TL;DR

This paper addresses the communication bottleneck inherent in Federated Split Learning (FSL) systems for Internet of Things (IoT) rainfall prediction, where repeated transmission of intermediate activations and gradients creates overheads in bandwidth-constrained environments. Prior work has typically optimized either activation compression or synchronization frequency independently. The authors propose a novel adaptive joint control framework that simultaneously regulates activation compression and synchronization interval (ρ) using a latency-driven scheduler with per-client exponential moving average (EMA) smoothing. This scheduler dynamically selects compression modes (float32, float16, int8) and synchronization intervals based on runtime latency signals to optimize communication efficiency without degrading predictive performance.

They validate the approach on hourly ERA5 meteorological data from 11 geographically distributed weather stations in a 17-scenario simulation matrix covering various latency profiles (no, low, high, mixed). Additionally, they deploy four scenarios on Raspberry Pi 4 clients connected over a real wide-area network. Results show the adaptive joint scheme aggressively reduces activation payload by up to 87% and synchronization traffic by 54% compared to float32 baseline, while AUPRC predictive performance varies minimally (0.6381–0.6484 in simulation, within 0.011 on Pi). Moreover, runtime jitter on Pi declines dramatically from ±688 s to ±10 s, showing improved runtime stability. This joint adaptive control thus balances communication cost and model fidelity effectively in practical multi-node IoT FSL systems.

Key findings

• AUPRC ranges narrowly between 0.6381 and 0.6484 across 17 simulation scenarios and within 0.011 on Raspberry Pi deployment, showing compression and synchronization settings do not degrade predictive quality.
• The joint adaptive scheme with int8 compression and ρ=3 achieves an 87% reduction in activation upload payload (6.07 MB total across 11 clients) compared to float32 baseline (47.36 MB) in Pi deployment.
• Synchronization traffic reduces by 54% under joint adaptation (35.06 MB total vs 75.77 MB baseline) in Pi deployment.
• Using ρ=3 (less frequent synchronization) reduces synchronization traffic by ~53% relative to ρ=1, shown in simulation.
• EMA-based per-client latency tracking enables precise mode switching and adaptive control across heterogeneous networks, validated by latency traces closely tracking compression mode changes (Fig. 4).
• Runtime jitter on Pi clients decreases significantly with joint adaptation (±10 s) compared to baseline (±688 s), improving system stability.
• Simulation and Pi AUPRC metrics match closely (within 0.007), validating transferability of simulation results to physical deployment.
• Joint adaptive approach reaches early stopping in fewer federated rounds due to reduced synchronization overhead.

Threat model

Not applicable; the focus is on communication efficiency and latency adaptation in federated split learning rather than adversarial attacks or security threats.

Methodology — deep read

The authors designed an FSL system involving 11 edge clients (each corresponding to a distinct weather station storing local data) and a central server interacting via gRPC. Training proceeds through four RPC calls: Register (client ID), Forward (exchange compressed activations and receive gradients), Synchronize (FedAvg aggregation after ρ local epochs), and NotifyCompletion.

The client-side model is a two-layer LSTM encoder taking input windows of shape (batch, 48, 5) — representing 48 hourly steps and 5 meteorological features — and producing a fixed-size smashed activation of dimension 64. This 64-dimensional floating point vector (256 bytes float32) is the unit subject to compression and network transmission. The server-side prediction head is a two-branch MLP producing rainfall occurrence classification and auxiliary rainfall amount regression outputs.

Compression modes are symmetric on activations and gradients, with three levels: float32 (baseline, 256 B), float16 (half precision, 128 B), and int8 (uniform quantization, 68 B plus 4 byte scale).

A key novelty is the adaptive server-side scheduler using per-client latency measurements tracked by a smoothed exponential moving average (EMA) with smoothing factor α=0.2. Latency thresholds of 4 ms and 10 ms define operating regimes: low latency clients use float32 compression with synchronization interval ρ=1, moderate latency use float16 with ρ=2, and high latency use int8 with ρ=3. The scheduling decisions are communicated to the clients through the Forward RPC response every step.

Training is federated over up to 50 rounds with 10 local optimization steps per local epoch. Early stopping with patience 15 is used. The global synchronization barrier requires quorum (all 11 clients nominally) but enforces a timeout with partial aggregation and bounded staleness acceptance (max staleness Smax=3 allowing asynchronous aggregation for adaptive ρ).

Latency profiles are synthesized for simulation: no latency, low (~8 ms), high (~50 ms), and mixed. Real latency is used on Pi 4 clients remotely connected to server via WAN with ~21–24 ms RTT.

Evaluation metrics include AUPRC (primary), ROC-AUC, F1 (fixed threshold 0.5), communication volume for activation uploads and synchronization messages, throughput (samples/sec), runtime, and runtime jitter. Repeated trials use three random seeds (42, 52, 62). The dataset is hourly ERA5 data from 11 meteorological stations from 2015 to 2026 split chronologically into 80% train, 8.9% validation (2024), and 11.1% test (2025-26) to avoid temporal leakage.

For example, in one run under high latency, the scheduler assigns int8 compression and sets synchronization interval ρ=3, reducing upload payload to 68 B per activation vs 256 B baseline. Clients send compressed activations and latency reports in Forward RPCs; the server aggregates weights asynchronously with bounded staleness after every 3 local epochs indicated by ρ=3. This enables significant reduction in communication and stabilizes runtime jitter without degrading accuracy.

Code, experimental configs, and data preparation scripts are publicly available to enhance reproducibility, although the dataset is publicly accessible from historical weather APIs and ERA5 open data. The batching, optimizer, and detailed model hyperparameters are well documented.

Technical innovations

• Joint adaptive scheduling of both activation compression mode and synchronization interval ρ driven by per-client latency EMA in a federated split learning system.
• Rule-based latency thresholds to deterministically map latency to compression level and synchronization frequency, allowing fine-grained runtime control.
• Integration of bounded staleness aggregation with adaptive synchronization intervals in a multi-client FSL environment.
• Demonstration that aggressive int8 quantization combined with sparser synchronization does not degrade rainfall prediction AUPRC in IoT time-series data.

Datasets

• ERA5-based hourly meteorological data from 11 geographic weather stations — ~78,888 hourly training rows per station, total ~867,000 samples — publicly sourced from Open Meteo Historical Weather API

Baselines vs proposed

• float32, ρ=1 baseline: activation upload = 256 B per step vs joint adaptive int8+ρ=3: 68 B per step (−73% compression), Pi total upload 47.36 MB vs 6.07 MB (−87%)
• float32, ρ=1 baseline: synchronization traffic = 6.74 MB/client vs ρ=3 static: 3.19 MB/client (−53% sync), joint adaptive: 3.19 MB/client (−54%)
• float16, ρ=1: activation upload 128 B vs float32 256 B (−50%), but synchronization traffic similar to float32 baseline (~7 MB)
• AUPRC on joint adaptive 0.6483 (simulation, high latency) vs 0.6393 baseline (float32, ρ=1) shows no significant degradation
• Runtime jitter on Pi clients drops from ±688 s (baseline) to ±10 s (joint adaptive), stabilizing system performance substantially

Limitations

• Rule-based scheduler thresholds are static and heuristic; learning-based adaptive policies could further optimize trade-offs.
• Limited evaluation on larger or more diverse IoT networks; experiments constrained to 11 clients/stations.
• Absence of adversarial evaluation: robustness to malicious clients or data poisoning untested.
• Limited tests on distribution shifts beyond station heterogeneity and network latency scenarios.
• Regression error metrics for rainfall quantity prediction are not reported, limiting insights on full task performance.
• Runtime measurements in simulation affected by shared host process scheduling, making wall clock results less reliable.

Open questions / follow-ons

• Can learning-based adaptive schedulers outperform rule-based latency thresholding in joint compression and synchronization control?
• How does the system perform under non-IID data distributions with stronger statistical heterogeneity across clients?
• What are the effects of adversarial clients or corrupted data on convergence when using aggressive quantization and sparse synchronization?
• Could more flexible synchronization intervals (e.g., client-specific ρ rather than uniform) improve efficiency further?

Why it matters for bot defense

For bot-defense and CAPTCHA practitioners focused on communication constrained edge environments, this paper provides a concrete methodology to jointly optimize communication payload and synchronization frequency in federated split learning systems. Its adaptive scheme demonstrates how latency-aware dynamic compression and aggregation intervals can dramatically reduce bandwidth use without degrading model quality or training stability. While the application is rainfall prediction, the core principles translate to other time-series IoT tasks where bandwidth and latency vary across devices. Practitioners designing robust, low-latency, distributed bot-detection or CAPTCHA verification models on resource-constrained edge devices could adapt these joint scheduling techniques to optimize network usage and reduce system jitter. The bounded staleness aggregation combined with per-client latency smoothing also offers practical guidance for managing heterogeneity in distributed model updates under network variance. However, since this work does not address adversarial robustness or model poisoning, defensive system designers should consider additional security layers alongside this communication optimization.

Cite

@article{arxiv2606_25003,
  title={ Adaptive Joint Compression and Synchronisation in Federated Split Learning for IoT Rainfall Prediction },
  author={ Wenjie Ding and Yi Sin Lin and Jiale Liu and Baoyi Liu and Guanghua Liu and Zhuolu Li and Suleiman Sabo and Chuadhry Mujeeb Ahmed and Aydin Abadi and Rehmat Ullah and Rajiv Ranjan },
  journal={arXiv preprint arXiv:2606.25003},
  year={ 2026 },
  url={https://arxiv.org/abs/2606.25003}
}

Read the full paper

• arXiv:2606.25003 (abstract)
• arXiv:2606.25003 (PDF)