CroSatFL: Energy-Efficient Federated Learning with Cross-Aggregation for Satellite Edge Computing
arXiv:2604.15779v1 [cs.DC] 17 Apr 2026
Nan Yang Bahman Javadi Rodrigo Neves Calheiros Western Sydney University Western Sydney University Western Sydney University [email protected] [email protected] [email protected] David Boland Philip Leong The University of Sydney The University of Sydney [email protected] [email protected] Abstract—Low Earth Orbit (LEO) mega-constellations extend the cloud-to-edge continuum into space, enabling satellite edge computing. However, Federated Learning (FL) in this environment is fundamentally energy-constrained due to dynamic inter-satellite connectivity, heterogeneous onboard computing hardware, and strict power budgets. We propose CroSatFL, a sustainable on-orbit hierarchical FL framework that reduces end-to-end energy across computation and communication while maintaining strong training performance under realistic LEO dynamics. CroSatFL keeps the ground station (GS) off the iterative loop by performing all local training and intermediate aggregations on orbit, requiring only two GS communication phases: one for initialization and one for final model collection. This sharply reduces repeated use of bandwidth-limited and energy-expensive GS links and shifts iterative exchanges to laser inter-satellite links (LISLs). CroSatFL integrates three energyaware mechanisms: StarMask forms LISL-feasible clusters that align data volume with heterogeneous CPU/GPU capability, SkipOne mitigates transient stragglers by skipping at most one slow client per cluster to lower round energy and latency while preserving long-term fairness, and random-k cross-aggregation enables lightweight topology-aware cross-cluster mixing without extending round duration. Using an end-to-end energy model with a realistic Walker-Delta constellation, we show that CroSatFL reduces GS communication count by over two orders of magnitude and GS transmission energy by about 6× relative to GS-centric and on-orbit baselines, while achieving competitive accuracy and faster convergence. Index Terms—LEO satellites, hierarchical federated learning, edge computing, energy efficiency, laser inter-satellite links.
I. I NTRODUCTION Low Earth Orbit (LEO) mega-constellations such as Starlink and OneWeb are evolving into a planet-scale Satellite Edge Computing substrate with continuous sensing, onboard processing, and low-latency laser inter-satellite links (LISLs) [1]. This enables time-sensitive applications such as disaster response, environmental monitoring, maritime surveillance, and space situational awareness, where in-orbit learning reduces response latency and reliance on ground infrastructure. Nonetheless, downlinking remains a bottleneck due to short and misaligned ground station (GS) passes, limited satellite– ground bandwidth, and the high energy cost of long-range Radio Frequency (RF) transmission, making large-scale data transfer to Earth impractical. These constraints motivate pushing learning and decision-making into orbit.
Federated learning (FL) naturally fits this setting by shifting most training communication to on-orbit LISL exchanges [2]– [4]. However, existing satellite and edge FL frameworks rely on abstractions that do not fully reflect LEO operations [5]. Many remain GS-centric, coupling frequent global aggregation to short GS visibility windows and increasing latency and transmission energy on bandwidth-limited GS links [3]. Representative examples include synchronous FedSyn [6] and LEO-adapted FedLEO [7]. Even in on-orbit or hierarchical variants such as FELLO [8], satellites are often treated as computationally uniform, overlooking runtime gaps across CPU/GPU and embedded accelerators [9]. Energy-focused methods typically optimize isolated components, such as client selection in FedSCS [10] or reduced-precision arithmetic in FedOrbit [4], without jointly addressing heterogeneous compute, time-varying LISL connectivity, and straggler-sensitive synchronization. As a result, clustering and scheduling under dynamic LISLs remain underexplored, and slow or poorly connected satellites can dominate round latency [2]. These limitations motivate a fully on-orbit hierarchical FL framework that explicitly accounts for latency, communication cost, and energy under heterogeneous compute and time-varying LISLs. We study a multi-orbital-plane LEO constellation where satellites train models on board and exchange FL updates over LISLs, using the GS only for bootstrap and final model collection. We focus on fully on-orbit hierarchical learning under dynamic, fan-out-limited LISLs [11] and strong CPU/GPU heterogeneity, where GS communication is significantly more expensive than short-range on-orbit transfer. The key challenge is to limit straggler-driven synchronization delay while bounding computation and communication energy under time-varying connectivity. To this end, we design CroSatFL with three building blocks. StarMask forms LISL-feasible, resource-aware clusters from runtime, hardware, and link profiles. Skip-One reduces synchronization sensitivity by tolerating transient stragglers within each cluster while maintaining fairness over time. Random-k cross-aggregation enables lightweight model aggregation among reachable clusters based on instantaneous cross-plane connectivity. We summarize our contributions below. •
We propose CroSatFL, a new hierarchical FL architecture
that performs all intermediate aggregation on orbit and uses the ground station only for bootstrap and final model retrieval, avoiding GS-visibility bottlenecks and repeated high-cost satellite–ground communication. • We introduce StarMask, a resource-aware clustering method that forms LISL-feasible and hardware-balanced clusters, and Skip-One, a scheduling mechanism that alleviates synchronization bottlenecks by tolerating transient stragglers and consistently shortens round latency under heterogeneous compute. • We conduct an extensive performance evaluation to show that CroSatFL matches or exceeds existing GS-centric and on-orbit FL baselines in accuracy, while reducing GS communication count by over two orders of magnitude, reducing GS transmission energy by about 6×, and significantly shortening end-to-end training time across datasets. II. BACKGROUND AND R ELATED W ORK A. Intelligent Satellite Computing LEO constellations are evolving from passive relays into compute-capable sensing systems that continuously collect imagery, RF traces, and multi-modal telemetry [12]. Advances in processors, compact accelerators, and radiationtolerant storage make in-orbit learning and inference increasingly feasible [13]. Applications such as disaster response, environmental monitoring, maritime awareness, and space situational awareness require timely model updates and onorbit decision support. Satellites can therefore preprocess and fine-tune models at the data source, while LISLs enable lowlatency coordination to disseminate model progress across the constellation [14], [15]. In practice, ground connectivity is intermittent and contention-prone, whereas LISL contacts are often sufficient to support on-orbit collaboration without relying on congested GS schedules [16], [17]. However, on-orbit learning remains constrained by tight and time-varying power, thermal, and memory/throughput budgets across platforms. B. Limitations of LEO Satellite Computing Systems GS communication. GS links are scarce, scheduled, and energy intensive, so routing intermediate model updates via ground stations makes the GS a synchronization bottleneck [18], [19]. In practice, LEO satellites have only a few short contact windows per orbit day [20], shared with payload downlink and other missions, so model exchange competes with higher-priority traffic and is vulnerable to visibility limits, congestion, and weather outages. In contrast, LISL-based onorbit coordination is more frequent and can overlap with computation, enabling satellites to exchange updates with reachable peers while sensing continues. Yet many designs still centralize aggregation off orbit [16], repeatedly paying uplink and downlink costs and tying training progress to non-learning factors such as handovers, rain fade, and GS contention. Hardware heterogeneity. LEO satellite constellations mix GPU-based and CPU-only satellites [9], creating large and time-varying gaps in per-epoch latency and energy due to
thermal throttling and illumination-dependent power budgets. Under synchronous aggregation, round time is dictated by the slowest participants, inflating makespan and wasting energy as faster nodes wait at barriers. Earth-observation workloads further exacerbate this effect: cloudy, off-nadir, or nightpass imagery can slow training and yield weaker gradients, making straggling frequent and hard to predict [2], [3]. Yet many designs still use static heuristic clustering that ignores per-epoch time and energy and system constraints such as master buffering, LISL fan-out, and link budgets, leading to unbalanced groups that are difficult to synchronize [14], [21]. For time-critical surveillance or disaster response, this translates into wasted energy at aggregation nodes and delayed model refresh. C. Existing Solutions and Motivation Existing satellite FL solutions mainly coordinate training and aggregation under orbital dynamics and constrained communication. A representative line is GS-centric: satellites periodically upload updates to a GS for aggregation [18], [19]. While simple, this assumes frequent and reliable GS contact, making it better suited to small constellations or low-rate updates. To better exploit inter-satellite connectivity, recent work studies on-orbit or hierarchical aggregation over LISLs [15], [22]. These designs reduce GS dependence, but often rely on predefined or heuristic aggregation/participation policies, limiting adaptation to runtime variation and rapidly changing LISL topologies. Decentralized and offloading-assisted schemes leverage LISLs to reduce coordination overhead [2], [3], while arithmetic simplification and adaptive compression reduce computation or communication cost [4], [17]. Yet these techniques are typically used in isolation, offering limited endto-end control of latency and energy at the constellation scale. A key gap is that existing satellite FL systems do not jointly address the constraints that dominate LEO training in practice. Ground-centric designs assume frequent GS contact, while on-orbit variants often ignore dynamic LISLs fan-out limits, CPU/GPU heterogeneity, and straggler-induced waiting energy. As a result, they either place GS links on the critical path or waste energy and time at synchronization barriers, motivating a fully on-orbit, topology- and energy-aware design that remains accurate and fair under realistic LEO dynamics. III. S YSTEM M ODEL AND P ROBLEM F ORMULATION A. System Model We consider a hierarchical FL system over a LEO satellite constellation with N satellites S = {s1 , . . . , sN }. The on-orbit learning process is modeled as (0) F = S, {Di }N , d, ELISL (·), {ci }N (1) i=1 , w i=1 . Each satellite si holds a private dataset Di with ni = |Di | samples and trains a model of size d (bits) initialized by w(0) . Inter-satellite communication is enabled by LISLs with timevarying availability ELISL (t) and per-satellite fan-out limits {ci }. The LISL-reachable neighbors of si at time t are Ni (t) = { sj | {si , sj } ∈ ELISL (t) }, satisfying |Ni (t)| ≤ ci for all
i and t. The GS participates only at training boundaries to broadcast w(0) and retrieve the final model. All intermediate aggregation and exchange occur on orbit, keeping the GS off the iterative critical path. Satellite Clustering. To exploit constellation structure and heterogeneity, we partitionSS into K clusters C = {C1 , . . . , CK } K with Ck ⊆ S and k=1 Ck = S. Within each cluster, intra-cluster aggregation is performed at a designated master satellite. Each satellite si is characterized by xi = (ni , hi , Ticomp , Eitrain , ci ), capturing its data volume, hardware type, per-epoch computation time, per-round training energy, and fan-out limit. Given the satellite profiles {xi } and the timevarying LISL topology ELISL (t), we learn a LISL-feasible partition that balances connectivity stability, compute capability, and resource availability. For each cluster Ck , the master mk (g) ∈ Ck is selected dynamically in main round g and may migrate across rounds based on orbital geometry, instantaneous link quality, latency, and current load and resource conditions, while maintaining a single logical aggregator per cluster. Hierarchical Federated Learning. After GS broadcast of w(0) , training proceeds fully on orbit for G main rounds g ∈ {1, . . . , G} over K clusters. In this work, we use a single main round (G = 1). Within main round g, masters perform R edge rounds r ∈ {1, . . . , R} for iterative on-orbit training and random-k cross-cluster exchanges over transient crossplane LISLs. In each edge round (g, r), cluster Ck selects participants Pk (r) ⊆ Ck . Each si ∈ Pk (r) runs Lloc local epochs (one full pass over Di ) and uploads its update to the current master mk (g), which aggregates updates to maintain the cluster model. If the master changes, the new master continues from the latest cluster model. In edge round (g, r), cluster k also derives the reachable neighbor set Nkreach (g, r) from the instantaneous LISL topology and samples a small subset for aggregation. After R edge rounds, clusters are consolidated on P orbit via sample-size weighted averaging, where Nk = i∈Ck ni denotes the data volume of cluster k. This keeps the GS off the iterative critical path. Satellite Participation Scheduling. Satellite participation is adaptive rather than mandatory. In each edge round r, cluster Ck selects Pk (r) ⊆ Ck instead of enforcing full participation. Each satellite si is assigned an online utility score Ui (r) that reflects its computation performance (e.g., Ticomp ), energy and memory state, communication opportunity under the instantaneous LISL topology and master assignment, and historical contribution to training progress. Satellites with larger Ui (r) are prioritized for inclusion in Pk (r), while those with smaller Ui (r) may be skipped temporarily to reduce straggling and avoid unnecessary energy use. The scores Ui (r) are refreshed so that a skipped satellite can rejoin once its resources recover or connectivity improves. This adaptive scheduling reduces idle waiting, controls on-orbit energy consumption, and preserves long-term fairness by avoiding systematic exclusion. B. Computation and Communication Model This section characterizes the computation and communication processes in hierarchical federated learning over LEO
constellations, capturing heterogeneous on-board computation, time-varying inter-satellite connectivity, and GS communication constraints. Local Computation. One local epoch corresponds to a full pass over Di , and the per-epoch computation workload scales linearly with data volume as FLOPsi = ni · cflop ,
(2)
where cflop denotes the number of floating-point operations required per sample. Let Ticomp denote the per-epoch computation time of satellite si . Executing Lloc local epochs in one training round incurs a total local training time Titrain = Lloc · Ticomp .
(3)
To capture hardware heterogeneity, we introduce an effective computation throughput αi for each satellite and express the per-epoch runtime as FLOPsi . (4) Ticomp = αi Satellites equipped with GPU-class accelerators typically exhibit significantly larger αi than CPU-only satellites. The parameter αi provides a unified abstraction of on-board computational capability. As a result, satellites with comparable dataset sizes ni may experience substantially different training times, which motivates heterogeneity-aware participation scheduling. After completing local training, satellites in cluster Ck transmit their model updates to the cluster master for aggregation. The computational cost of aggregation scales as O(|Ck |d) and is negligible compared to local training. Execution and Waiting Time. Due to intermittent GS visibility and time-varying LISL availability, a satellite may be unable to immediately perform required communications after completing local computation. We define the waiting time as the wall-clock duration during which a satellite performs no local training, aggregation, or transmission solely because required GS or LISL communication opportunities are unavailable. Waiting time is treated as a latency-only quantity and does not incur additional computation or transmission energy. LISL Communication. We adopt a unified communication model that treats all LISL transmissions as peer-to-peer exchanges between satellites, regardless of whether the communicating nodes belong to the same cluster or different orbital planes. The transmission delay for a model of size d bits is d + LLISL (t), if {si , sj } ∈ ELISL (t), ij LISL (t) LISL R Ti→j (t) = ij ∞, otherwise, (5) LISL where Rij (t) denotes the instantaneous link bandwidth and LLISL (t) denotes the propagation latency between si and sj at ij time t. This model captures both high-bandwidth intra-plane LISLs used for uploading local updates to cluster masters and intermittent cross-plane LISLs used for cross-cluster model LISL exchange. Variations in Rij (t) and LLISL (t) reflect the ij geometry-dependent dynamics of the constellation without requiring separate models for different LISL types.
Ground Station Communication. Communication between satellites and the ground station differs from LISLs due to visibility constraints and link characteristics. A satellite si can communicate with the GS only when it enters the GS visibility window. Compared to LISLs, GS links generally exhibit lower bandwidth and higher latency. For a model of size d bits, the satellite–ground transmission delay is d + LGS i (t), if si is within GS coverage, GS Ti (t) = RiGS (t) ∞, otherwise, (6) where RiGS (t) and LGS i (t) denote the instantaneous bandwidth and propagation delay of the satellite–ground link. In CroSatFL, GS communication is used only for the initial model broadcast during session setup and a single final model downlink at session completion. C. Energy Consumption Model This subsection models satellite energy consumption in hierarchical FL. We focus on local computation and communication energy under heterogeneous on-board hardware and dynamic link conditions. During waiting periods, satellites are assumed to operate in a low-power standby state without local training or GS and LISL transmissions. Idle power is excluded to avoid conflating scheduling-induced latency with computation efficiency. Training Energy Model. During local training, satellite si consumes computation energy determined by its hardware type and the number of samples processed in one round. Let Ni = Lloc · ni .
(7)
For a CPU-based satellite, let CiCPU denote the number of CPU cycles required per sample and fiCPU denote the operating frequency. Under a CMOS dynamic power model with effective switched capacitance γi , the computation energy is EiCPU = γi · CiCPU · Ni · (fiCPU )2 . (8) For a GPU-based satellite, let Piavg denote the average power draw during training. Using Titrain from Eq. (3), the corresponding computation energy is EiGPU = Piavg · Titrain .
(9)
We summarize the per-round computation energy of satellite si as ( EiCPU , if si is CPU-based, comp Ei = (10) EiGPU , if si is GPU-based. In this work, the per-round training energy is defined as Eitrain = Eicomp .
(11)
We focus on computation energy, which dominates satellite power consumption during local training and enables fair comparison across methods. Waiting periods incur no computation or transmission energy, since satellites are idle.
LISLs Communication Energy Model. Satellites exchange model updates over time-varying LISLs whose availability, rate, and delay depend on orbital geometry. For a link between LISL si and sj at time t, let Rij (t) denote the instantaneous data LISL rate and Lij (t) the propagation and processing delay. LISLs are used for both intra-cluster uploads to the master and intermittent inter-cluster exchanges among masters (random-k), each transmitting a payload of size d bits. The corresponding communication energy for one transmission is LISL LISL Ei→j (t) = PiLISL · Ti→j (t),
(12)
LISL (t) where PiLISL is the transmission power of si and Ti→j follows Eq. 5. This model unifies intra- and inter-cluster LISLs communication and captures round-to-round energy variation induced by dynamic link conditions. We model LISL energy at the transmission level and omit receiver-side and controlplane overhead, as these costs are comparable across methods and do not affect relative comparisons. GS Communication Energy Model. GS links are available only within visibility windows and typically require much higher transmission power than LISLs due to larger path loss and time-varying channel conditions. In CroSatFL, GS communication is invoked only at session boundaries, consisting of a one-time initial model broadcast and a single final model transfer for collection, and thus stays off the perround critical path (Sec. III-B). Let RiGS (t) and LGS i (t) denote the instantaneous GS rate and propagation/processing delay between the GS and satellite si at time t. When si is in coverage, the transmission time for a payload of size d is TiGS (t) as in Eq. (6). We model the GS communication energy for a single transfer as
EiGS (t) = P GS · TiGS (t),
(13)
where P GS is the effective transmission power associated with GS communication (including both GS-to-satellite and satellite-to-GS transfers). We model GS communication energy with an effective power that captures both uplink and downlink costs, and finer-grained distinctions do not affect our design choices or comparative results. IV. O UR P ROPOSED M ETHOD : C RO S AT FL CroSatFL is a fully on-orbit hierarchical FL framework for LEO constellations with time-varying LISLs and heterogeneous on-board resources. It integrates StarMask for constraint-aware clustering, Skip-One for fair, edge-roundlevel straggler mitigation within each cluster, and random-k cross-aggregation among cluster masters to maintain on-orbit global coherence as illustrated in Figure 1. By keeping the ground station off the iterative critical path, CroSatFL reduces synchronization latency and computation energy. A. StarMask: RL-based Clustering with Action Masking RL Formulation. Clustering is modeled as a finite-horizon Markov decision process (MDP) with horizon N , where one satellite is assigned at each step. The decision maker is a parameterized policy network πθ that maps the current state to
StarMask: RL-based Clustering
Master Satellite Intra-Cluster LISLs
Data Share
Inter-Cluster LISLs
Hardware
GS Communication
Energy Time
Policy Network
Skip-One Client Selection Latency Energy Saving Fairness
Ground Station (GS)
Random-k Cross Aggregation
𝒊𝒇 𝒌 = 𝟐, 𝒕𝒉𝒆𝒏 1 ｜2 3
2 ｜3 4
3 ｜1 2
4 ｜2 3
Fig. 1. Overview of the proposed framework for CroSatFL. StarMask first forms constraint-aware clusters over heterogeneous satellites. Skip-One then mitigates transient stragglers within each cluster, while random-k cross-aggregation enables on-orbit model mixing among reachable masters. The ground station is used only for initialization and final model collection.
a distribution over actions. The action space has size Kmax +1, where Kmax denotes the maximum allowable number of clusters. Let ni sharei = PN (14) j=1 nj denote the relative data share of satellite si . At decision step t, the state is sMDP = xt , Φ(C1 ), . . . , Φ(CKmax ) , (15) t (sharet , ht , Ttcomp , Ettrain , ct )
where xt = summarizes the assigned satellite at step t, where sharet is the relative data share of the current satellite. It includes relative data share, hardware type, per-epoch runtime, per-round local training energy, and fan-out limit. The term Φ(Ck ) summarizes cluster Ck by its current size, per-epoch time range, cumulative energy, data-share sum, hardware composition, and remaining capacity. Uninstantiated clusters are treated as inactive until selected. The action at ∈ {1, . . . , Kmax , Kmax + 1}
where K is the number of instantiated clusters. The term W (C) measures the intra-cluster per-epoch time mismatch by aggregating the per-cluster time ranges W (C) =
K X k=1
i∈Ck
i∈Ck
(18)
and Etot (C) is the per-epoch total cost that sums persatellite computation energy and intra-cluster LISL transmission P energy under the resulting partition. Let share(Ck ) = i∈Ck sharei denote the data share of cluster Ck . We define the cross-cluster imbalance as 2 σshare (C) =
K K 2 1 X 1 X share(Ck ) − share(Cℓ ) . (19) K K k=1
ℓ=1
The term Mmix (C) penalizes heterogeneous hardware composition by counting mixed-hardware clusters
(16)
assigns the current satellite to an existing cluster index in {1, . . . , Kmax } or selects the (Kmax + 1)-th action to open a new cluster. Transitions are deterministic and incrementally update the partial partition. A terminal reward evaluates the completed clustering C = {C1 , . . . , CK } as R(C) = − θwait W (C) + βEtot (C) (17) 2 + γσshare (C) + ν# K + ΛMmix (C) .
max Ticomp − min Ticomp ,
Mmix (C) =
K X
1(∃i, j ∈ Ck : hi ̸= hj ) ,
(20)
k=1
where 1(·) is the indicator function. The coefficients θwait , β, γ, ν# , Λ are fixed across experiments to balance latency, energy, data-share fairness, the number of clusters, and hardware consistency. All reward terms are normalized using min–max ranges estimated from training instances so that no single component dominates the optimization.
Algorithm 1 StarMask: RL-based Clustering
Algorithm 2 Skip-One Client Selection for Cluster Ck
Require: Ordered satellites S = {s1 , . . . , sN }, profiles {xi }N i=1 , maximum clusters Kmax , minimum cluster size mmin , policy πθ Ensure: Cluster partition C = {C1 , . . . , CK } or Infeasible with Kmin 1: Initialize empty clusters {C1 , . . . , CKmax }; K ← 0 2: for t ← 1 to N do 3: sMDP ← (xt , Φ(C1 ), . . . , Φ(CKmax )) ▷ Eq. (15) t 4: At ← A(sMDP ) ▷ Eq. (22) t 5: if At = ∅ then N 6: Compute Kmin using {c̃ℓ }ℓ=1 ▷ Eq. (25) 7: if no feasible K ∈ [Kmin , Kmax ] exists then 8: return Infeasible with diagnostic Kmin 9: end if 10: C ← GreedyFallback(S, Kmax , mmin ) 11: return C 12: end if 13: Sample at ∼ πθ (· | sMDP ) restricted to At t 14: if at is O PEN N EW then 15: Instantiate CK+1 and assign the current satellite; K ← K + 1 16: else 17: Assign the current satellite to Cat 18: end if 19: end for 20: return C = {C1 , . . . , CK }
Require: Cluster Ck , local training times {Titrain }i∈Ck , computation energies {Eitrain }i∈Ck , cooldown counters {κi (r)}i∈Ck , staleness {τi (r)}i∈Ck Ensure: Participant set Pk (r) for edge round r 1: Sk (r) ← ∅ ▷ initialize skipped set 2: Compute admissible skip set Uk (r) ▷ Eq. (31) 3: if Uk (r) = ∅ then 4: Pk (r) ← Ck 5: return Pk (r) 6: end if 7: Compute current barrier Mk (r) ← maxi∈Ck Titrain ▷ Eq. (27) 8: for all i ∈ Uk (r) do (−i) 9: Mk (r) ← maxj∈Ck \{i} Tjtrain ▷ Eq. (28)
The policy network πθ is trained using an actor-critic method [23] "N # X MDP ∇θ J(θ) = Eπθ ∇θ log πθ (at | st ) At , (21) t=1
where At denotes the advantage estimate at step t. The short horizon and terminal-only rewards promote stable learning. Feasible Decision Making via Action Masking. To prevent infeasible intermediate assignments under strict LEO constraints, StarMask enforces feasibility through action masking. From the raw action set Araw , feasible actions are defined as A(sMDP ) = {a ∈ Araw : Γ(sMDP , a) = 1}, t t
(22)
where Γ evaluates whether assigning the current satellite under action a preserves all operational constraints and allows completion of a feasible terminal partition. For any cluster Ck , the master-feasibility constraint |Ck | − 1 ≤ max c̃j j∈Ck
(23)
is enforced, where c̃j denotes the effective fan-out capacity of satellite sj . When hardware-homogeneous clustering is required, assignments additionally satisfy ht = hj for all j ∈ Ck ; otherwise, heterogeneity is penalized through Mmix . A minimum cluster size mmin is enforced at termination. During construction, Γ also checks reachability based on remaining cluster capacity and unassigned satellites. The “O PEN N EW cluster” action is masked once K = Kmax . Attention-Guided Policy with Deterministic Fallback. StarMask employs attention to compute a relational embedding zt = Attn(Qt , Kt , Vt ),
(24)
where queries are derived from satellite features and keys and values from cluster summaries. This embedding emphasizes
(−i)
10: ∆Ti (r) ← Mk (r) − Mk (r) 11: ∆Eitrain (r) ← Eitrain 12: Compute utility Ψk ({i}; r) 13: end for 14: i⋆ ← arg maxi∈Uk (r) Ψk ({i}; r) 15: if Ψk ({i⋆ }; r) > 0 then 16: Sk (r) ← {i⋆ } 17: Update κi⋆ (r) and τi⋆ (r) 18: end if 19: Pk (r) ← Ck \ Sk (r) 20: return Pk (r)
▷ Eq. (29) ▷ Eq. (30) ▷ Eq. (33)
▷ Eq. (26)
per-epoch time compatibility, capacity headroom, and datashare balance, enabling the policy network to select among feasible actions only. If no feasible action exists, StarMask invokes a deterministic fallback. It computes a lower bound on the number of required clusters using effective capacities c̃i = min(ci − 1, Lhi ),
(25)
where Lhi denotes the hardware-dependent upper bound on the manageable number of member satellites for a master of type hi . StarMask then greedily constructs the smallest feasible partition by assigning satellites in descending perepoch runtime order while enforcing fan-out, hardware, and minimum-size constraints. The resulting partition satisfies Kmin ≤ K ≤ Kmax . If no feasible partition exists, StarMask reports infeasibility together with Kmin . The overall StarMask workflow is summarized in Algorithm 1. B. Skip-One Client Selection Skip-One Client Selection is a lightweight, edge-round-level mechanism within each cluster Ck . In this work, all edge rounds are executed within a single main round (G = 1). Despite long-term clustering, short-term variations in orbital geometry, LISL quality, and compute load can induce transient stragglers. To reduce synchronization barriers, the master mk may skip at most one satellite per edge round r, following Algorithm 2, to balance latency reduction, computation-energy saving, and long-term participation fairness. A skipped satellite performs no local training and sends no update to the master in that edge round. This design is intentionally conservative: it targets the common case where a single transient straggler dominates the cluster barrier, often the main source of delay in our relatively small clusters, while avoiding overly aggressive exclusion that could harm participation fairness. Extending the
rule to skip multiple satellites is possible, but is beyond the scope of this work. Barrier reduction under transient stragglers. Let the realized participant set in round r be Pk (r) = Ck \ Sk (r),
|Sk (r)| ≤ 1,
(26)
where Sk (r) denotes the skipped satellite set. The cluster-level computation barrier before skipping is defined as Mk (r) = max Titrain , i∈Ck
(27)
where Titrain denotes the local training time of satellite si . Communication delays over LISLs are handled separately and are not included in the computation barrier. To evaluate the effect of skipping a candidate satellite i ∈ Ck , we consider a counterfactual participant set Ck \ {i}, yielding the counterfactual barrier (−i)
Mk
(r) =
max Tjtrain ≤ Mk (r),
j∈Ck \{i}
(28)
and the resulting latency reduction (−i)
∆Ti (r) = Mk (r) − Mk
(r) ≥ 0.
(29)
This formulation captures the common LEO scenario where a satellite temporarily becomes a straggler despite being well matched by the long-term cluster assignment. Computation-energy saving. Skipping satellite i in round r excludes it from local training and eliminates its computation energy consumption for that round. The resulting energy saving is ∆Eitrain (r) = Eitrain , (30) where Eitrain denotes the per-round computation energy of satellite si . Waiting-induced idle energy is not considered. Skip-One therefore reduces round latency through barrier tightening while explicitly accounting for computation-energy savings. Fairness-aware admissible set. To prevent systematic exclusion of specific satellites, Skip-One restricts candidates to the admissible skip set Uk (r) = {i ∈ Ck : κi (r) = 0, τi (r) < τmax },
(31)
where κi (r) is a cooldown counter preventing consecutive skips, and τi (r) measures participation staleness. These constraints ensure bounded exclusion duration and preserve longterm participation fairness. Round-level selection rule. The cluster master selects the skip decision as Sk (r) ∈ arg
max
S⊆Uk (r), |S|≤1
Ψk (S; r),
(32)
with Ψk (∅; r) = 0 and Ψk ({i}; r) = θT ∆Ti (r) + θE ∆Eitrain (r) − θH Hi − θF ϕi (r), (33) where Hi is a static hardware-aware penalty that discourages skipping satellites with rare or high-value hardware configurations, and ϕi (r) encodes recent participation history. The
weights θT , θE , θH , θF are fixed across experiments, and all terms are normalized to comparable ranges to balance latency reduction, energy saving, and fairness. The resulting selection incurs O(|Uk (r)|) per-round complexity and relies only on locally available statistics. Since ∆Ti (r) ≥ 0, Skip-One weakly reduces the cluster computation barrier Mk (r) and improves round latency. Periodic all-participation rounds reset cooldown counters, ensuring that all satellites contribute regularly over long horizons despite transient straggler events. C. Cross-Aggregation without GS Communication CroSatFL maintains global model coherence fully on orbit via direct LISL-based exchanges among cluster masters. Since cross-plane LISLs are intermittent and the master graph is rarely connected, CroSatFL uses lightweight random-k crossaggregation, where each master mixes with a small set of currently reachable neighbors in each edge round. Random-k LISL-based cross-aggregation. Let wkg denote the model held by the master of cluster Ck after completing the intra-cluster aggregation stage of main round g. We initialize the edge-round model by setting wkg,1 = wkg . Let X Nk = ni (34) i∈Ck
denote the total number of samples hosted by cluster Ck . Within main round g, cluster masters perform R edge rounds indexed by r ∈ {1, . . . , R}. In edge round (g, r), cluster k observes the instantaneous LISL topology and identifies the set of reachable clusters Nkreach (g, r). From this set, it uniformly samples a neighbor subset Nk (g, r) ⊆ Nkreach (g, r), |Nk (g, r)| = min knbr , |Nkreach (g, r)| .
(35)
where knbr is a fixed sampling parameter. This definition keeps the sampling rule well-defined even when fewer than knbr neighbors are reachable. The local mixing group is then defined as Mk (g, r) = {k} ∪ Nk (g, r). (36) The master of cluster Ck updates its model by performing a sample-size weighted average X Nj P wjg,r , (37) wkg,r+1 = N ℓ ℓ∈Mk (g,r) j∈Mk (g,r)
where wjg,r denotes the model of cluster j available at the beginning of edge round r. Uniform neighbor sampling preserves statistical proportionality through data-weighted aggregation. Over successive edge rounds, the random-k exchanges induced by orbital motion propagate information across orbital planes, yielding a gossip-like consensus process at the cluster level without requiring full connectivity at any single time. On-orbit consolidation and once-per-session GS communication. After completing the R edge rounds in the final main round G, each cluster Ck holds a model wkG,R+1 that has incorporated information from multiple neighboring clusters.
1
5
10
15
20
25
Training Round
FedSCS FedOrbit CroSatFL
30
35
40
1.0 0.9 0.8 0.7 0.6 0.5 0.4 0.3 0.2 0.1 0.0
FedSyn FELLO FedLEO
1
5
10
15
20
25
Training Round
Test Accuracy
FedSyn FedLEO FELLO
Test Accuracy
Test Accuracy
1.0 0.9 0.8 0.7 0.6 0.5 0.4 0.3 0.2 0.1 0.0
FedSCS FedOrbit CroSatFL
30
35
40
1.0 0.9 0.8 0.7 0.6 0.5 0.4 0.3 0.2 0.1 0.0
FedSyn FedLEO FELLO
1
5
10
15
20
25
Training Round
FedSCS FedOrbit CroSatFL
30
35
40
FedSyn FELLO FedLEO
1
5
10
15
20
25
Training Round
FedSCS FedOrbit CroSatFL
30
35
40
1.0 0.9 0.8 0.7 0.6 0.5 0.4 0.3 0.2 0.1 0.0
FedSyn FELLO FedLEO
1
5
10
15
20
25
Training Round
FedSCS FedOrbit CroSatFL
30
35
Test Accuracy
1.0 0.9 0.8 0.7 0.6 0.5 0.4 0.3 0.2 0.1 0.0
Test Accuracy
Test Accuracy
Accuracy for ResNet-18-MNIST (IID) Accuracy for ResNet-18-CIFAR-10 (IID) Accuracy for ResNet-18-EuroSAT (IID) Fig. 2. Convergence comparison on MNIST, CIFAR-10, and EuroSAT using ResNet-18 under IID settings.
40
1.0 0.9 0.8 0.7 0.6 0.5 0.4 0.3 0.2 0.1 0.0
FedSyn FELLO FedLEO
1
5
10
15
20
25
Training Round
FedSCS FedOrbit CroSatFL
30
35
40
Accuracy for ResNet-18-MNIST (non-IID) Accuracy for ResNet-18-CIFAR-10 (non-IID) Accuracy for ResNet-18-EuroSAT (non-IID) Fig. 3. Convergence comparison on MNIST, CIFAR-10, and EuroSAT using ResNet-18 under non-IID settings.
The constellation then forms the final global model entirely on orbit as w
(final)
=
K X k=1
Nk PK
j=1 Nj
wkG,R+1 ,
(38)
using sample-size weighted averaging across clusters. After completing all G main rounds, the final on-orbit model is downlinked to the ground station for checkpointing or deployment. This design avoids placing GS communication on the round-level critical path and eliminates dependence on aligned GS visibility windows. Together, random-k cross-aggregation enables topologyaware and statistically correct global mixing while avoiding additional round-level synchronization. Combined with StarMask clustering and Skip-One client selection, it completes the CroSatFL design for fully on-orbit, energy-efficient hierarchical federated learning under realistic LEO dynamics.
TABLE I E XPERIMENTAL PARAMETERS Parameter Constellation Number of LEO satellites Number of orbits Number of LEOs per Orbit Inclination Altitude Allocated spectrum Bandwidth of ISL/GS System loss (h) Noise power (σ) Frequency Gain to noise temperature ratio (G) Data rate Transmission power (p) FL main rounds FL edge rounds Local training epochs Batch size
Value Walker Delta (Starlink) 720 36 20 70◦ 570 km 2.5/1.25 GHz 3 dB 2.2 × 10−16 W 27 GHz 5 dB/K 16 Mbps 40 Watts 1 40 10 10
A. Experimental Setup V. E XPERIMENTAL R ESULTS We evaluate CroSatFL on multiple datasets using model accuracy, energy consumption, and training time. CroSatFL is implemented in Flower [24] with PyTorch and executed on NVIDIA® RTX 5090 GPU. Satellite computing capacities follow real Spiral Blue Space Edge One1 traces collected in 2023 from multiple in-orbit tests. These traces are used under a simulated constellation in which 50% of satellites are CPUonly and 50% are GPU-equipped. 1 https://www.spiralblue.space/
We consider a Walker-Delta constellation of 720 LEO satellites at 570 km altitude and 70◦ inclination, arranged in 36 orbital planes with 20 satellites per plane (inter-/intra-plane spacings 10◦ /18◦ ), instantiated using the MATLAB Satellite Communications Toolbox. We place a ground station in Canberra, Australia (latitude −35.40139◦ , longitude 148.98167◦ ). We consider four LISL communication-range settings, i.e., 659, 1319, 1500, and 1700 km, which approximately support maximum cluster sizes of 2, 4, 6, and 10, respectively. We follow system parameters from prior work [4] as listed in Table I. We randomly select 40 satellites as FL clients and use StarMask to form 9 clusters, each managed by a master.
300
6
200
4
100
2
0
0
Syn LEO LLO SCS rbit tFL Fed Fed FE Fed FedO CroSa
Total Energy
Training Time 30
700
25
600
1500 1250
20
1000
15
750
10
500
5
250 0 Syn LEO LLO SCS rbit tFL Fed Fed FE Fed FedO roSa
C
0
Total Energy
Training Time
500
25 20
Training Time (Days)
8
1750
Total Energy (kJ)
Total Energy (kJ)
400
10
Training Time (Days)
Training Time
Total Energy (kJ)
Total Energy
Training Time (Days)
500
400
15
300
10
200 100 0
Syn LEO LLO SCS rbit tFL Fed Fed FE Fed FedO CroSa
5 0
ResNet-18-MNIST (Acc. 95%) ResNet-18-CIFAR-10 (Acc. 75%) ResNet-18-EuroSAT (Acc. 80%) Fig. 4. Comparison of total energy consumption and end-to-end training time for a common target accuracy.
TABLE II B REAKDOWN OF LISL/GS COMMUNICATION , ENERGY CONSUMPTION , AND WAITING TIME FOR E URO SAT
Intra-cluster LISLs (No.) Inter-cluster LISLs (No.) GS Communication (No.) Transmission Energy Cost (kJ) Training Energy Cost (kJ) Transmission Time (Hours) Waiting Time (Hours)
FedSyn FELLO FedLEO FedSCS FedOrbit CroSatFL – 3120 2800 2560 2560 1760 –
–
0
0
0
1440
3200
80
400
640
640
18
601.60
108.90
159.48
197.38
197.38
99.70
1080
1080
1080
1080
1080
179.18
0.87
0.20
0.27
0.32
0.32
0.19
936.25
816.92
696.85
456.80
456.80
7.89
Baselines. We compare CroSatFL with five representative baselines, each implemented following its original design, including its native communication and synchronization mechanisms. Baselines are not constrained to adopt CroSatFL’s onceper-session GS communication or on-orbit cross-aggregation. FedSyn [6] is standard synchronous FedAvg. FedLEO [7] adapts FL to LEO via intra-plane propagation and sink-satellite scheduling. FELLO [8] uses optical-LISL clustering and edge selection to reduce communication overhead. FedSCS [10] performs energy-aware client selection for orbital edge computing. FedOrbit [4] reduces computation and communication cost with block minifloat arithmetic. Together, they cover synchronous FL, clustering-based methods, topology-aware scheduling, and energy-efficient orbital FL. Model and Datasets. We evaluate our framework using ResNet-18 [25] on three standard image classification datasets: MNIST [26], CIFAR-10 [27], and EuroSAT [28] for both IID and non-IID data distributions. B. Experimental Results Model Accuracy. Figures 2 and 3 compare the convergence of CroSatFL and baselines under IID and non-IID data. Under IID settings, CroSatFL achieves the best final accuracy on CIFAR-10 (80.09%) and a top-performing result on
EuroSAT (89.49%), slightly outperforming or matching all baselines. Under non-IID (α = 0.5), where heterogeneity slows and destabilizes training for most baselines, CroSatFL maintains robust learning dynamics and achieves competitive final performance across all datasets, remaining close to the strongest methods. Overall, these results show that the proposed CroSatFL preserves convergence stability and learning effectiveness across both homogeneous and heterogeneous data scenarios, supporting scalable satellite FL. Energy Consumption. Figure 4 compares total energy and training time for six FL frameworks to reach the same target accuracy on MNIST (95%), CIFAR-10 (75%), and EuroSAT (80%) with ResNet-18. Across all datasets, CroSatFL achieves the lowest energy consumption and shortest training time. FedSyn appears relatively low because MNIST is simple and ResNet-18 converges quickly, but under lighter models and more realistic settings, it remains the slowest and most energyhungry baseline [10]. Table II shows that CroSatFL shifts communication to inter-cluster LISLs and sharply reduces costly GS interactions, cutting GS communications from 3200 to 18 and transmission energy from 601.60 kJ to 99.70 kJ. It also reduces straggler-induced synchronization delay, shrinking waiting time from hundreds of hours to 7.89 hours and lowering end-to-end latency. These results reveal that CroSatFL improves scalability by reducing both communication burden and synchronization-driven delays. Impact of Heterogeneous Hardware Composition. Figure 5 compares one-round computation energy and training time of CroSatFL and FedOrbit under three hardware compositions: All-CPUs (100% CPUs), Half-Mixed (50% CPUs/50% GPUs), and All-GPUs (100% GPUs). FedOrbit is used as the baseline because it explicitly considers heterogeneous on-board hardware (i.e., FPGA) and thus serves as a representative reference. With full participation, its round time is dominated by the slowest satellite and is therefore more sensitive to hardware heterogeneity. In contrast, CroSatFL adopts skipone scheduling to alleviate straggler effects and better utilize GPU-equipped satellites. As the GPU share increases, both methods achieve lower energy consumption and latency, while CroSatFL consistently maintains lower one-round cost and
Computation Energy Computation Time
30
0.6
25
0.5
20
0.4
15
0.3
10
0.2
5
0.1
0
Computation Time (Hours)
Computation Energy (kJ)
FedOrbit CroSatFL
All-CPUs
Half-Mixed
All-GPUs
0.0
Fig. 5. Single edge round computation energy and time comparison under heterogeneous CPU/GPU settings
stronger robustness across different hardware mixes. VI. C ONCLUSION This paper presents CroSatFL, a fully on-orbit hierarchical federated learning framework that eliminates frequent ground station dependence and enables energy-efficient training under realistic LEO constraints. CroSatFL keeps all intermediate aggregation in space and uses the ground station only for session bootstrap and final model retrieval, removing GS visibility from the critical path and avoiding costly, misaligned contacts. To address dynamic, fan-out-limited LISL connectivity and strong CPU/GPU heterogeneity, CroSatFL integrates StarMask for LISL-feasible, resource-balanced clustering, Skip-One for straggler-resilient round control, and random-k cross-aggregation for topology-aware inter-cluster mixing without increasing round latency. Experiments show that CroSatFL preserves competitive accuracy while reducing GS communication count by over two orders of magnitude, reducing GS transmission energy by about 6×, and consistently shortening end-to-end training time. Future work will explore adaptive compression and fault-tolerant scheduling, and validate CroSatFL under richer orbital dynamics and onboard accelerators. ACKNOWLEDGMENT We thank the Space Research Network and the NSW State Government for financial support of this project through the SRN Pilot Project grant 2024-25. R EFERENCES [1] S. Wang and Q. Li, “Satellite computing: Vision and challenges,” IEEE Internet of Things Journal, 2023. [2] Z. Lin, Z. Chen, Z. Fang, X. Chen, X. Wang, and Y. Gao, “Fedsn: A federated learning framework over heterogeneous leo satellite networks,” IEEE Transactions on Mobile Computing, 2025. [3] Z. Zhai, Q. Wu, S. Yu, R. Li, F. Zhang, and X. Chen, “Fedleo: An offloading-assisted decentralized federated learning framework for low earth orbit satellite networks,” IEEE Transactions on Mobile Computing, 2024.
[4] M. R. Jabbarpour, B. Javadi, P. H. W. Leong, R. N. Calheiros, and D. Boland, “Fedorbit: Energy efficient federated learning for orbital edge computing using block minifloat arithmetic,” IEEE Transactions on Services Computing, 2024. [5] Z. Li, S. He, Z. Yang, M. Ryu, K. Kim, and R. Madduri, “Advances in appfl: A comprehensive and extensible federated learning framework,” in CCGrid. IEEE, 2025. [6] B. McMahan, E. Moore, D. Ramage, S. Hampson, and B. A. y Arcas, “Communication-efficient learning of deep networks from decentralized data,” in AISTATS. PMLR, 2017. [7] M. Elmahallawy and T. Luo, “Optimizing federated learning in leo satellite constellations via intra-plane model propagation and sink satellite scheduling,” in IEEE ICC. IEEE, 2023. [8] C.-Y. Chen, L.-H. Shen, K.-T. Feng, L.-L. Yang, and J.-M. Wu, “Edge selection and clustering for federated learning in optical inter-leo satellite constellation,” in PIMRC. IEEE, 2023. [9] F. C. Bruhn, N. Tsog, F. Kunkel, O. Flordal, and I. Troxel, “Enabling radiation tolerant heterogeneous gpu-based onboard data processing in space,” CEAS Space Journal, 2020. [10] B. Al-Blewi, B. Javadi, and R. N. Calheiros, “Energy efficient client selection in federated learning for orbital edge computing,” in IEEE EDGE. IEEE, 2025. [11] H. S. Cha, J. M. Kim, B. Lim, J. H. Lee, and Y. C. Ko, “A survey on inter-satellite links for low-earth orbit satellite networks,” Journal of Korean Institute of Communications and Information Sciences, 2022. [12] M. Gardill, W. Kinser, J. Budroweit, A. Al-Hourani, E. Dunkel, J. Swope, D. Evans, and M. Staebler, “Towards space edge computing and onboard ai for real-time teleoperations,” 2023. [13] F. Ortiz, V. Monzon Baeza, L. M. Garces-Socarras, J. A. VásquezPeralvo, J. L. Gonzalez, G. Fontanesi, E. Lagunas, J. Querol, and S. Chatzinotas, “Onboard processing in satellite communications using ai accelerators,” Aerospace, 2023. [14] Z. Cheng, B. Denby, K. McCleary, and B. Lucia, “Eagleeye: Nanosatellite constellation design for high-coverage, high-resolution sensing,” in ASPLOS, 2024. [15] X. Xu, Q. Wang, Y. Hou, and S. Wang, “AI-SPACE: A cloud-edge aggregated artificial intelligent architecture for tiansuan constellationassisted space-terrestrial integrated networks,” IEEE Network, 2023. [16] B. Denby, K. Chintalapudi, R. Chandra, B. Lucia, and S. Noghabi, “Kodan: Addressing the computational bottleneck in space,” in ASPLOS, 2023. [17] C. Yang et al., “Towards efficient satellite computing through adaptive compression,” IEEE Transactions on Services Computing, 2024. [18] H. Chen, M. Xiao, and Z. Pang, “Satellite-based computing networks with federated learning,” IEEE Wireless Communications, 2022. [19] B. Matthiesen, N. Razmi, I. Leyva-Mayorga, A. Dekorsy, and P. Popovski, “Federated learning in satellite constellations,” IEEE Network, 2024. [20] D. Vasisht, J. Shenoy, and R. Chandra, “L2d2: Low latency distributed downlink for leo satellites,” in SIGCOMM, 2021. [21] Q. Li, S. Wang, X. Ma, A. Zhou, Y. Wang, G. Huang, and X. Liu, “Battery-aware energy optimization for satellite edge computing,” IEEE Transactions on Services Computing, 2024. [22] Y. Tang, “Tiansuan constellation: Intelligent software-defined microsatellite with orbital attention for sustainable development goals,” in ICBDIC. Springer, 2022. [23] V. Mnih, A. P. Badia, M. Mirza, A. Graves, T. Lillicrap, T. Harley, D. Silver, and K. Kavukcuoglu, “Asynchronous methods for deep reinforcement learning,” in ICML. PMLR, 2016. [24] D. J. Beutel, T. Topal, A. Mathur, X. Qiu, J. Fernandez-Marques, Y. Gao, L. Sani, K. H. Li, T. Parcollet, P. P. B. De Gusmão et al., “Flower: A friendly federated learning research framework,” arXiv preprint arXiv:2007.14390, 2020. [25] K. He, X. Zhang, S. Ren, and J. Sun, “Deep residual learning for image recognition,” in CVPR, 2016. [26] Y. LeCun, L. Bottou, Y. Bengio, and P. Haffner, “Gradient-based learning applied to document recognition,” Proceedings of the IEEE, 2002. [27] A. Krizhevsky, G. Hinton et al., “Learning multiple layers of features from tiny images,” 2009. [28] P. Helber, B. Bischke, A. Dengel, and D. Borth, “Eurosat: A novel dataset and deep learning benchmark for land use and land cover classification,” IEEE Journal of Selected Topics in Applied Earth Observations and Remote Sensing, 2019.