arXiv:2604.08474v1 [cs.LG] 9 Apr 2026
Quantization Impact on the Accuracy and Communication Efficiency Trade-off in Federated Learning for Aerospace Predictive Maintenance Abdelkarim LOUKILI [email protected] April 10, 2026 Abstract Federated learning (FL) enables privacy-preserving predictive maintenance across distributed aerospace fleets, but gradient communication overhead constrains deployment on bandwidth-limited IoT nodes. This paper investigates the impact of symmetric uniform quantization (b ∈ {32, 8, 4, 2} bits) on the accuracy–efficiency trade-off of a custom-designed lightweight 1-D convolutional model (AeroConv1D, 9 697 parameters) trained via FL on the NASA C-MAPSS benchmark under a realistic Non-IID client partition. Using a rigorous multi-seed evaluation (N = 10 seeds), we show that INT4 achieves accuracy statistically indistinguishable from FP32 on both FD001 (p = 0.341) and FD002 (p = 0.264 MAE, p = 0.534 NASA score) while delivering an 8× reduction in gradient communication cost (37.88 KiB → 4.73 KiB per round). A key methodological finding is that naı̈ve IID client partitioning artificially suppresses variance; correct Non-IID evaluation reveals the true operational instability of extreme quantization, demonstrated via a direct empirical IID vs. Non-IID comparison. INT2 is empirically characterized as unsuitable: while it achieves lower MAE on FD002 through extreme quantization-induced over-regularization, this apparent gain is accompanied by catastrophic NASA score instability (CV = 45.8% vs. 22.3% for FP32), confirming nonreproducibility under heterogeneous operating conditions. Analytical FPGA resource projections on the Xilinx ZCU102 confirm that INT4 fits within hardware constraints (85.5% DSP utilization), potentially enabling a complete FL pipeline on a single SoC. The full simulation codebase and FPGA estimation scripts are publicly available at https://github.com/therealdeadbeef/aerospace-fl-quantization.
1
Introduction
Predictive maintenance of aerospace propulsion systems relies on accurate estimation of the Remaining Useful Life (RUL) of turbofan engines [16]. As aerospace operators increasingly operate large, geographically distributed fleets, a fundamental tension arises: training accurate 1
predictive models requires pooling data across many engines, yet centralizing raw telemetry raises significant privacy, regulatory, and bandwidth concerns. Federated learning (FL) [13] resolves this tension by training models collaboratively across edge nodes without exposing raw data to a central server. However, FL deployment in aerospace IoT settings faces two compounding practical constraints. First, communication overhead : each FL round requires broadcasting a fullprecision gradient vector, whose size scales linearly with model precision. Over bandwidthconstrained aeronautical links (e.g., LoRaWAN at 5 kbps), even modest models become prohibitively expensive to synchronize. Second, hardware constraints: inference must run on resource-constrained FPGAs rather than cloud GPUs, imposing strict limits on model complexity and numerical precision. Symmetric uniform gradient quantization addresses both constraints simultaneously by reducing the bit-width b of transmitted gradients. Lower-precision updates occupy fewer bits per parameter, directly reducing communication cost; lower-precision arithmetic also reduces FPGA resource utilization, enabling deployment on smaller devices. However, the quantization–accuracy trade-off in FL has been studied almost exclusively under IID data assumptions and on general-purpose classification benchmarks [1, 2, 12], leaving open questions about its behavior under the Non-IID distributions that characterize realistic aerospace deployments with heterogeneous operating conditions [15]. This paper makes four contributions: 1. AeroConv1D and experimental protocol. We design AeroConv1D, a custom sub-10k parameter, purely feed-forward 1-D CNN optimized for FPGA inference, and conduct a multi-seed (N = 10), Non-IID evaluation of four quantization levels (b ∈ {32, 8, 4, 2}) on NASA C-MAPSS FD001 and FD002 using paired t-tests to assess statistical significance. 2. Methodological contribution on IID bias. We demonstrate empirically that IID-biased client partitioning artificially suppresses variance and inflates the apparent accuracy benefit of quantization. Under correct Non-IID evaluation, INT4 achieves accuracy parity with FP32 (p > 0.05 on all metric × subset combinations) rather than dominance. 3. Characterization of INT2 instability. We show that INT2 exhibits an unexpected MAE reduction on FD002 attributed to extreme over-regularization by the 3-level quantization grid, accompanied by catastrophic NASA score instability (CV = 45.8%), making it operationally unusable regardless of its average error. 4. Hardware projection. Analytical FPGA resource projections following the hls4ml scaling model [3] show that INT4 fits within the Xilinx ZCU102 (85.5% DSP), leaving 366 spare DSPs for a potential NTT-based homomorphic encryption co-processor [14]. Scope and limitations. While previous iterations of this work emphasized a gradientdistortion privacy proxy, we recognize this metric serves only as a heuristic indicator of gradient-inversion attack surface [4, 20] rather than a formal (ε, δ)-DP bound; establishing formal DP guarantees for the RUL regression setting is left as future work. FPGA projections 2
are analytical and have not been validated on physical ZCU102 silicon; silicon validation is part of ongoing independent research [7, 17].
2
Related Work
2.1
Federated Learning for Predictive Maintenance
McMahan et al. [13] introduced FedAvg as a communication-efficient, privacy-preserving distributed training paradigm. Landau et al. [8] propose FL across multi-airline fleets for RUL prediction, and Purkayastha et al. [15] survey FL’s role in industrial maintenance more broadly. However, neither work addresses communication overhead or quantization trade-offs on constrained edge nodes, the central concerns of the present paper.
2.2
Quantization in Federated Learning
Quantization of gradients for communication efficiency has a substantial literature. Alistarh et al. [1] introduce QSGD, providing unbiased stochastic quantization with convergence guarantees. Bernstein et al. [2] propose SignSGD, which transmits only the sign of each gradient component, achieving extreme compression at the cost of bias. Ma et al. [12] survey the broader challenges of resolving Non-IID data distributions in FL. Concurrently, recent work by He et al. [5] reports that low-bit quantization can act as an implicit regularizer under certain conditions, though they note results are dataset-dependent. Recent advances have also explored hybrid and runtime quantization strategies. Zheng et al. [19] introduce FedHQ, a framework that dynamically combines post-training and quantization-aware training at runtime to automatically allocate optimal hybrid strategies per client under heterogeneous FL conditions, further demonstrating the potential of adaptive quantization as an implicit regularizer. Our work revisits these claims on an aerospace RUL regression benchmark. We find that the regularization effect is statistically indiscernible for INT4 on both subsets after correcting for IID partitioning bias, while INT2 produces a spurious MAE improvement on the harder FD002 subset that is operationally meaningless due to catastrophic score instability. This constitutes a methodological warning for practitioners who evaluate quantization under IID assumptions and then deploy under Non-IID conditions. Scope of the quantization comparison. This work evaluates symmetric uniform pertensor quantization as a clean, hardware-deployable baseline rather than as an exhaustive survey of FL compression schemes. QSGD [1] adds stochastic rounding and variable-length entropy coding, which reduces communication further but requires floating-point dequantization at the aggregator and is not directly implementable in fixed-point FPGA pipelines. SignSGD [2] achieves 1-bit compression but introduces gradient bias that can harm convergence under Non-IID distributions [12]. Advanced compression schemes [5] dynamically assign bit-widths or apply non-uniform mappings, which could improve the INT4 operating point further but require complex decoding logic incompatible with the strict latency budget of aeronautical IoT links. Comparing these schemes head-to-head on C-MAPSS under Non-IID conditions 3
is a natural extension; we leave it to future work to avoid conflating the methodological contribution (IID partitioning bias) with a compression benchmark.
2.3
FPGA Acceleration and Cryptographic Co-design
hls4ml [3] enables automatic synthesis of neural networks to Xilinx FPGAs with configurable precision, providing the scaling model we use for resource projections. NTT-based homomorphic encryption (HE) accelerators have been demonstrated on Zynq platforms [9, 14, 18], motivating the spare-DSP co-design goal of this work: if INT4 inference fits comfortably on the ZCU102, the remaining DSP budget could host an HE co-processor, enabling encrypted gradient transmission without a second device.
3
System Model
3.1
Federated Learning Framework
We consider a synchronous FedAvg setup with N = 10 clients and a central aggregator. Each client k holds a private dataset Dk (a subset of turbofan engine trajectories) and trains a local copy of the global model for E = 2 local epochs per round, producing updated weights wr,(k) . The aggregator updates the global model as: N
w
r+1
1 X =w + Qb wr,(k) − wr , N k=1 r
(1)
where Qb (·) denotes symmetric uniform quantization to b bits applied to the per-client weight delta ∆w(k) = wr,(k) − wr before transmission. Quantization is applied to the delta, not to the model weights during local training, preserving full-precision gradient accumulation on each client.
3.2
Local Model: AeroConv1D
To meet the strict hardware constraints of aerospace IoT nodes, we propose AeroConv1D, a custom lightweight 1-D convolutional architecture (9 697 parameters) designed specifically for this study. Recurrent architectures (e.g., LSTMs) and CNN-LSTM hybrids are common baselines for C-MAPSS RUL prediction, but their recurrent temporal dependencies complicate ultra-low-bit quantization — weight state accumulation amplifies quantization noise across time steps — and prevent deep hardware pipelining, which is essential for low-latency FPGA inference. AeroConv1D instead relies on a purely feed-forward topology to maximize FPGA parallelism. The architecture processes temporal windows of 50 time steps over 14 variance-filtered sensor channels. A small temporal kernel (k = 3) efficiently captures local sensor degradation trends without excessive multiplication overhead. The subsequent channel doubling (14 → 32 → 64) builds a hierarchical feature representation, providing sufficient capacity while strictly bounding the total parameter footprint below 10k. The full layer-by-layer specification is given in Table 1. 4
Table 1: AeroConv1D architecture specification (9,697 parameters total). B: batch size. The parameter count is verified programmatically at simulation startup via an assertion. Layer Type / Configuration Output Shape Params Input 1 2 3 4 5 6 7
Time-series window Conv1D (k = 3, s = 1, p = 1) + ReLU MaxPool1D (k = 2, s = 2) Conv1D (k = 3, s = 1, p = 1) + ReLU AdaptiveAvgPool1D Flatten Linear + ReLU Linear
Total
3.3
(B, 14, 50) (B, 32, 50) (B, 32, 25) (B, 64, 25) (B, 64, 1) (B, 64) (B, 32) (B, 1)
0 1,376 0 6,208 0 0 2,080 33 9,697
Symmetric Uniform Quantization
Prior to transmission, each client applies symmetric uniform quantization independently to each layer’s weight delta ∆w(l) : b−1 α(l) (2 − 1) ∆w(l) (l) Qb ∆w = b−1 , (2) 2 −1 α(l) clip where α(l) = max |∆w(l) | is the per-tensor scale factor computed independently for each layer l, following standard per-tensor quantization practice, and ⌊·⌉clip denotes round-to-nearest followed by saturation clipping to [−(2b−1 − 1), +(2b−1 − 1)].1 For INT2, 2b−1 − 1 = 1, yielding the 3-level grid {−α(l) , 0, +α(l) }. This extreme coarseness is the root cause of INT2’s over-regularization behavior discussed in Section 5.4. Note that the INT2 grid {−α(l) , 0, +α(l) } is effectively a per-layer ternary update with a learned scale α(l) = max |∆w(l) |, which differs from the fixed {−1, 0, +1} grids used in ternary network classification literature [11]; the scale adapts each round to the magnitude of the weight delta, so the scheme remains within the symmetric uniform quantization family of Eq. (2) rather than constituting a separate ternarization algorithm.
3.4
Dataset and Non-IID Client Partition
The NASA C-MAPSS dataset [16] provides run-to-failure trajectories of turbofan engines under controlled degradation scenarios. We use two subsets: FD001 (100 training engines, 1 operating condition) and FD002 (260 training engines, 6 operating conditions). RUL targets are capped at 125 cycles (piece-wise linear label). The 14 variance-informative sensor channels retained are: s2, s3, s4, s7, s8, s9, s11, s12, s13, s14, s15, s17, s20, s21. Features are z-score standardized using training-set statistics, applied identically to the test set. Test-set ground-truth RUL values are loaded from the official RUL FDxxx.txt files 1
The notation ⌊·⌉clip is non-standard and introduced here for compactness; it combines rounding (nearest integer) with symmetric saturation clipping.
5
rather than inferred from cycle counts, which would underestimate RUL for the truncated test sequences. All available test windows (sliding over the full test trajectory, approximately 8,700 windows for FD001 and 22,000 for FD002) are used for evaluation, matching the NASA score formulation. Non-IID partition. Client partitioning assigns engines per client, sampled without replacement and without sorting by RUL, so that each client’s RUL histogram differs from the global distribution. This corrects the IID-biased assignment common in preliminary evaluations, which assigns contiguous engine blocks and artificially homogenizes each client’s data distribution. To quantify the resulting heterogeneity, Table 2 reports the per-client mean RUL and Earth Mover’s Distance (EMD) from the global RUL distribution for seed 42. The inter-client EMD spread (Avg. EMD = 3.9 cycles on FD001, 2.8 cycles on FD002) confirms that the partition induces meaningful label heterogeneity. Table 2: Per-client mean RUL (cycles) for seed 42, confirming Non-IID label heterogeneity. EMD: Earth Mover’s Distance from the global RUL histogram. FD001 FD002
3.5
Client
Mean RUL
EMD
Mean RUL
EMD
k=1 k=2 k=3 k=4 k=5 k=6 k=7 k=8 k=9 k = 10
66.5 74.1 68.8 73.3 86.8 74.8 76.4 76.8 71.8 77.7
8.9 1.2 6.5 2.0 11.4 0.5 1.1 1.4 3.5 2.4
72.0 77.6 78.1 74.8 71.5 72.2 79.5 79.7 73.9 73.4
3.4 2.2 2.6 0.6 4.0 3.2 4.0 4.2 1.6 2.0
Global Avg. EMD
75.3 —
— 3.9
75.5 —
— 2.8
Evaluation Metrics
MAE. Mean absolute error in RUL cycles: MAE = n1
P
i |ŷi − yi |.
NASA asymmetric score. S=
X i
s(di ),
( e−d/13 − 1 d < 0 (under-prediction) s(d) = ed/10 − 1 d ≥ 0 (over-prediction)
6
(3)
where di = ŷi − yi . Over-prediction is penalised exponentially more steeply than underprediction, reflecting the safety-critical cost of declaring a healthy engine as near-failure. S is reported as a sum over all test windows (approximately 8,700 for FD001; 22,000 for FD002), making it sensitive to both systematic bias and prediction variance. Gradient-distortion privacy proxy. Lpriv =
1 2 ∆w − Qb (∆w) 2 , |θ|
(4)
where |θ| = 9,697. This measures the mean squared quantization distortion per parameter, averaged over the N clients per round. Higher Lpriv indicates greater gradient corruption, which raises the noise floor for gradient-inversion attacks [4, 20]. Lpriv is not a formal DP bound ; it is used here solely as an exploratory indicator. FP32 transmits the unquantized delta (Lpriv = 0 by definition) and is therefore omitted from Figure 4.
4
Experimental Setup
Simulation protocol. Simulations run for 20 FL rounds with local batch size 32, learning rate 10−3 , and Adam optimiser. To isolate the effect of distributional heterogeneity, a baseline IID partition was additionally simulated on FD001. The IID evaluation is restricted to FD001 for computational efficiency, as it sufficiently demonstrates the baseline bias without requiring the full FD002 parameter sweep. Reproducibility. Each configuration is evaluated for N = 10 random seeds {42, 123, 256, 789, 1024, 2024, 3141, 4242, 5555, 9999}, controlling client partitioning, minibatch shuffling, and weight initialisation. The local training RNG is set per-round and per-client as seedclient = s · 104 + r · 102 + k, ensuring statistically independent shuffles across rounds. Statistical analysis. Results are reported as mean ± std (sample std, df = 9) over seeds. Statistical significance is assessed with a two-tailed paired t-test (α = 0.05, df = 9). At N = 10, the 95% confidence interval on Cohen’s dˆ spans approximately dˆ± 0.95 [6]; effect-size estimates are reported as directional indicators only. The larger seed-to-seed variability observed under the corrected Non-IID partition (e.g., FD001 FP32 NASA Score std = 123k vs. 41k under IID, see Table 4) further validates the distributional heterogeneity documented in Table 2. FPGA projection methodology. Resource estimates target the Xilinx Zynq UltraScale+ ZCU102 (xczu9eg-ffvb1156-2-e): 274 080 LUT, 2 520 DSP, 912 BRAM36. Projections follow the hls4ml scaling model [3]: LUT = |θ| · b/6, DSP = |θ| · b/18, Latency = b/2 µs at 500 MHz. These are analytical projections; the FPGA estimation script is available in the public repository.
7
5
Results and Discussion
Table 3: Test-set results: Mean ± Std over 10 random seeds. p-values from two-tailed paired t-test vs. FP32 (n = 10, df = 9). Bold: p < 0.05. NASA score S reported as sum over all test windows (Eq. 3). CVS : coefficient of variation of S across seeds. Cohen’s dˆ at N = 10 carries 95% CI ≈ dˆ ± 0.95; interpret as directional only. Sub. Cfg MAE (cycles) pMAE Score S (×103 ) pS CVS FP32 INT8 FD001 INT4 INT2
17.52 ± 0.47 17.51 ± 0.48 17.48 ± 0.51 19.03 ± 1.62
— 0.520 0.341 0.018
449 ± 123 447 ± 127 452 ± 115 802 ± 573
— 27.3% 0.746 28.6% 0.802 25.3% 0.064 72.0%
FP32 26.99 ± 1.69 — 923 ± 206 — 22.3% INT8 27.24 ± 1.40 0.265 951 ± 167 0.364 16.9% FD002 INT4 27.20 ± 1.84 0.264 938 ± 233 0.534 24.8% † INT2 21.53 ± 2.31 0.001 749 ± 347 0.207 45.8% † INT2 lower MAE on FD002 is an over-regularization artefact; see Section 5.4.
5.1
INT8 Matches FP32 Across All Conditions
INT8 achieves accuracy statistically indistinguishable from FP32 on both subsets and both metrics (p ≥ 0.265 on all four comparisons, Table 3). This confirms the well-established result that 8-bit quantization preserves model quality with negligible accuracy cost, consistent with prior work [1].
5.2
INT4: Communication–Accuracy Parity
The corrected multi-seed evaluation reveals no statistically significant accuracy difference between INT4 and FP32 on either subset (p > 0.05 on all metric×subset combinations, Table 3). On FD001, the mean MAE difference is only 0.04 cycles, well within the seedto-seed variability of FP32 itself (std = 0.47 cycles). On FD002, INT4 yields p = 0.264 on MAE and p = 0.534 on NASA score, confirming full accuracy parity under the harder multi-condition Non-IID setting. LoRaWAN feasibility. INT4 delivers an 8× reduction in gradient communication cost (37.88 KiB → 4.73 KiB per round). At 5 kbps, the 4.73 KiB INT4 payload requires ≈ 7.5 s per round; under a 1% EU ISM-band duty-cycle limit, the minimum inter-round interval is ≈ 12.5 min, consistent with predictive maintenance FL schedules where rounds are typically spaced minutes to hours apart.
8
MAE Convergence
55
C-MAPSS FD001 FP32 INT8 INT4 INT2
50
MAE (cycles)
45 40 35 30 25 20 1
5
10
FL Round
15
20
Figure 1: MAE convergence over 20 FL rounds on C-MAPSS FD001. Shaded bands: ±1 std over 10 seeds. FP32, INT8, and INT4 converge to indistinguishable final MAE; INT2 exhibits slower convergence and higher variance. Main claim. INT4 maintains accuracy statistically indistinguishable from FP32 (p > 0.05 on all comparisons, both subsets) while delivering 8× communication reduction, making it the practical operating point for bandwidth-constrained aerospace IoT deployments.
5.3
Methodological Bias of IID Partitioning
Table 4 compares FP32 and INT4 on FD001 under both partitioning strategies, evaluated over 10 seeds. Under the artificial IID partition, the NASA score variance is suppressed (std = 31k vs. 123k under Non-IID), and INT4 can appear to marginally outperform FP32. Under the realistic Non-IID partition, the true cross-seed variance is revealed, correctly establishing statistical parity rather than dominance. This finding has a broader implication: evaluation protocols that assign training data to clients by random index shuffling (IID) rather than by engine assignment (Non-IID) will systematically underestimate prediction variance and may incorrectly conclude that quantization provides an accuracy benefit, when in reality it does not. Whether gradient quantization acts as a genuine implicit regularizer under Non-IID FL [5, 12] remains an open question; the evidence presented here does not confirm this hypothesis at α = 0.05 on either subset.
5.4
INT2: Instability and Non-Reproducibility
INT2 behaviour differs qualitatively between the two subsets and cannot be characterised as uniformly degrading or uniformly beneficial. Unlike classification settings where binary or 1-bit neural networks can achieve competitive accuracy [10], INT2 proves fundamentally unsuitable for safety-critical RUL regression. 9
Table 4: Methodological bias: IID vs. Non-IID partitioning on FD001 (mean ± std over 10 seeds). IID suppresses variance, making INT4 appear to outperform FP32; Non-IID reveals statistical parity. Partition Config MAE (cycles) Score S (×103 ) IID
FP32 INT4
17.34 ± 0.36 17.28 ± 0.26
421 ± 41 440 ± 31
Non-IID
FP32 INT4
17.52 ± 0.47 17.48 ± 0.51
449 ± 123 452 ± 115
MAE by Subset and Quantization Level 30
FD001 (1 Op. Cond.) FD002 (6 Op. Cond.)
MAE (cycles)
25
*
*
20 15 10 5 0
FP32
INT8
INT4
INT2
Figure 2: MAE by subset and quantization level. Hatching indicates FD002 (6 operating conditions). Asterisk (*): p < 0.05 vs. FP32 on MAE. Warning: The lower MAE of INT2 on FD002 is an over-regularization artefact, not a genuine accuracy improvement (see Section 5.4).
10
FD001 (single operating condition). INT2 MAE is significantly worse than FP32 (19.03 ± 1.62 vs. 17.52 ± 0.47 cycles, +8.6%, p = 0.018). The NASA score is not significantly different from FP32 (p = 0.064), but the coefficient of variation is 72.0% compared to 27.3% for FP32, indicating severe seed-to-seed instability. FD002 (six operating conditions). INT2 achieves a statistically significant lower MAE than FP32 (21.53 ± 2.31 vs. 26.99 ± 1.69 cycles, −20.2%, p = 0.001). This apparent improvement is, however, an over-regularization artefact: the extreme precision constraint of INT2 forces weight updates onto the 3-level grid {−α(l) , 0, +α(l) }—effectively acting as a per-layer ternary update with a dynamic scale rather than a standard uniform 2-bit grid— preventing the model from adapting to the heterogeneous six-condition distribution of FD002 in the same way as higher-precision configurations. The result is a form of underfitting that accidentally achieves lower MAE on some seeds by predicting conservatively, not by genuinely learning the degradation pattern. The NASA score confirms this diagnosis: the mean score for INT2 is 749,000 ± 347,000 (CV = 45.8%) versus 923,000 ± 206,000 (CV = 22.3%) for FP32. While the mean score is lower for INT2, the variance is ≈ 2× higher, and individual seeds produce wildly divergent outcomes. In a safety-critical predictive maintenance context, a model with CV = 45.8% on the NASA asymmetric score is operationally unusable regardless of its average MAE. This dynamic is visually summarized in Figure 2.
NASA Score Convergence
NASA Score S (lower is better)
1e9
C-MAPSS FD001 FP32 INT8 INT4 INT2
2.0 1.5 1.0 0.5 0.0 0.5 1.0
1
5
10
FL Round
15
20
Figure 3: NASA score S convergence on C-MAPSS FD001. Lower is better. INT2 early-round values reach 109 and are off-scale; the y-axis is clipped for readability. Negative values arise when systematic under-prediction dominates; INT2 oscillates between extreme positive and negative scores, illustrating non-reproducibility.
Verdict. INT2 is unsuitable for aerospace RUL regression not because of uniform accuracy degradation, but because of fundamental non-reproducibility: the interaction between the 11
3-level quantization grid and Non-IID operating conditions produces outcomes that vary catastrophically across initializations, precluding reliable deployment.
Gradient-Distortion Proxy
FD001
10 3
priv (log scale)
10 4 10 5
INT8 INT4 INT2
10 6 10 7 10 8 1
5
10
FL Round
15
20
Figure 4: Gradient-distortion privacy proxy Lpriv on FD001 (log scale) over 20 FL rounds. Higher values indicate greater gradient distortion and higher gradient-inversion attack cost [4, 20]. FP32 is omitted (Lpriv = 0 by definition). Lpriv is not a formal DP bound; see Section 3.5.
5.5
Accuracy–Communication Trade-off
Figure 5 plots the accuracy–communication Pareto front on FD001. The FP32 → INT4 path achieves an 8× communication reduction with p = 0.802 on NASA score, confirming that the gain is not statistically distinguishable from the baseline. INT8 offers a 4× reduction at p = 0.746. INT2 achieves the lowest communication cost but is excluded from the Pareto front due to its instability.
5.6
FPGA Feasibility
Table 5 lists the analytical FPGA resource projections. The DSP count is the binding resource constraint for all configurations. FP32 requires 684% of available DSPs; INT8 requires 171%. Only INT4 and INT2 fit the ZCU102, with INT4 at 85.5% DSP utilisation and INT2 at 42.7%. INT4 leaves 366 spare DSPs, which could potentially host an NTT-based homomorphic encryption co-processor [14], enabling encrypted gradient transmission at 2 µs inference latency. The ARM Cortex-A53 on the ZCU102 PS quad-core would execute FL local training and INT4 quantization in software (PyTorch AArch64), while the PL fabric accelerates INT4 inference via hls4ml, potentially enabling a complete training–quantization–inference pipeline on a single SoC.
12
NASA Score S (lower is better)
1.4
Pareto Trade-off
1e6
FD001
1.2 1.0 0.8
INT2
0.6 INT4
0.4 0.2
0
5
p = 0.802
INT8
10
15
20
25
FP32
30
35
Communication Cost per Round (KiB)
40
45
Figure 5: Accuracy–communication trade-off on FD001. Error bars: ±1 std over 10 seeds. Arrow: FP32 → INT4 operating point. Annotated p-value from paired t-test on NASA score (INT4 vs. FP32). All figures in Table 5 are analytical projections derived from the hls4ml scaling model and have not been validated against physical ZCU102 synthesis reports. Table 5: Analytical FPGA resource projections — Xilinx ZCU102 (274 080 LUT | 2 520 DSP | 912 BRAM36). Latency at 500 MHz, sequence length 50. Comm. cost excludes per-layer scale overhead (8 × 4 B ≈ 0.03 KiB). Projections derived from hls4ml scaling model; not validated on physical silicon. Cfg LUT %LUT DSP %DSP Lat. Fit FP32 51 717 INT8 12 929 INT4 6 464 INT2 3 232
6
18.9% 4.7% 2.4% 1.2%
17 239 4 309 2 154 1 077
684.1% 16 µs 171.0% 4 µs 85.5% 2 µs 42.7% 1 µs
× × ✓ ✓
Conclusion
This paper investigated gradient quantization in a federated learning system for aerospace predictive maintenance on the NASA C-MAPSS benchmark. The primary methodological contribution is demonstrating that naı̈ve IID client partitioning artificially inflates the apparent accuracy benefit of quantization. Under correct Non-IID evaluation with ground-truth test RUL labels and a proper sliding-window test protocol, INT4 achieves accuracy parity with FP32 (p > 0.05 on all metric×subset combinations)
13
while delivering an 8× communication reduction, making it the practical operating point for bandwidth-constrained aerospace IoT deployments. INT2 exhibits qualitatively different behaviour across subsets: MAE degrades significantly on FD001 (+8.6%, p = 0.018), while an apparent MAE improvement on FD002 (−20.2%, p = 0.001) is identified as an over-regularization artefact. In both cases, INT2 is rendered operationally unusable by catastrophic NASA score instability (CV = 72.0% on FD001, 45.8% on FD002), confirming non-reproducibility under heterogeneous operating conditions. Analytical FPGA projections show that INT4 fits within the Xilinx ZCU102 at 85.5% DSP utilisation, leaving 366 spare DSPs for potential cryptographic co-design, subject to silicon validation. Future work will (i) incorporate a formal (ε, δ)-DP analysis against gradient-inversion threat models [4, 20], (ii) validate FPGA projections on physical ZCU102 silicon, (iii) quantify Non-IID severity via EMD across a broader engine-partitioning parameter sweep, and (iv) extend the evaluation to additional C-MAPSS subsets (FD003, FD004) and to federated settings with heterogeneous client hardware.
Data and Code Availability The PyTorch implementation of AeroConv1D, the full federated learning simulation framework, raw experimental logs (10-seed Non-IID and IID partitions), and FPGA estimation scripts are openly available at: https://github.com/therealdeadbeef/aerospace-fl-quantization The NASA C-MAPSS dataset is publicly available via the NASA Prognostics Data Repository [16].
References [1] D. Alistarh, D. Grubic, J. Li, R. Tomioka, and M. Vojnovic. Qsgd: Communicationefficient sgd via gradient quantization and encoding. In I. Guyon, U. V. Luxburg, S. Bengio, H. Wallach, R. Fergus, S. Vishwanathan, and R. Garnett, editors, Advances in Neural Information Processing Systems, volume 30. Curran Associates, Inc., 2017. URL https://proceedings.neurips.cc/paper_files/paper/2017/file/ 6c340f25839e6acdc73414517203f5f0-Paper.pdf. [2] J. Bernstein, Y.-X. Wang, K. Azizzadenesheli, and A. Anandkumar. signsgd: compressed optimisation for non-convex problems. In International Conference on Machine Learning, 2018. URL https://api.semanticscholar.org/CorpusID:7763588. [3] F. Fahim et al. hls4ml: An open-source codesign workflow to empower scientific lowpower machine learning devices. IEEE Transactions on Nuclear Science, 68(8):1885–1896, 2021.
14
[4] J. Geiping, H. Bau, F. Droste, and M. Moeller. Inverting gradients – how easy is it to break privacy in federated learning? In Advances in Neural Information Processing Systems (NeurIPS), volume 33, pages 16937–16947, 2020. [5] Z. He et al. Feddt: A communication-efficient federated learning via knowledge distillation and ternary compression. Electronics, 14(11):2183, 2025. [6] L. V. Hedges and I. Olkin. Statistical Methods for Meta-Analysis. Academic Press, 1985. [7] K. Khalil et al. A federated learning model based on hardware acceleration for the early detection of alzheimer’s disease. Sensors, 23(19):8272, 2023. [8] D. Landau, I. de Pater, M. Mitici, and N. Saurabh. Federated learning framework for collaborative remaining useful life prognostics: an aircraft engine case study, 2025. URL https://arxiv.org/abs/2506.00499. [9] A. Laouiti et al. Hardware acceleration of fully homomorphic encryption for edge federated learning. IEEE Internet of Things Journal, 2025. [10] S. Lee et al. Biprunefl: Computation and communication efficient federated learning with binary quantization and pruning. IEEE Access, 2025. [11] F. Li, B. Liu, X. Wang, B. Zhang, and J. Yan. Ternary weight networks, 2022. URL https://arxiv.org/abs/1605.04711. [12] X. Ma, J. Zhu, Z. Lin, Y. Qin, and S. Chen. A state-of-the-art survey on solving non-iid data in federated learning. Future Generation Computer Systems, 135, 05 2022. doi: 10.1016/j.future.2022.05.003. [13] B. McMahan, E. Moore, D. Ramage, S. Hampson, and B. A. y. Arcas. CommunicationEfficient Learning of Deep Networks from Decentralized Data. In A. Singh and J. Zhu, editors, Proceedings of the 20th International Conference on Artificial Intelligence and Statistics, volume 54 of Proceedings of Machine Learning Research, pages 1273–1282. PMLR, 20–22 Apr 2017. URL https://proceedings.mlr.press/v54/mcmahan17a. html. [14] T. D. D. Nguyen, J. Kim, and H. Lee. Ckks-based homomorphic encryption architecture using parallel ntt multiplier. In 2023 IEEE International Symposium on Circuits and Systems (ISCAS). IEEE, 2023. [15] A. A. Purkayastha et al. Federated learning for predictive maintenance: A survey of methods, applications, and challenges. In 2024 IEEE 67th International Midwest Symposium on Circuits and Systems (MWSCAS). IEEE, 2024. [16] A. Saxena, K. Goebel, D. Simon, and N. Eklund. Damage propagation modeling for aircraft engine run-to-failure simulation. International Conference on Prognostics and Health Management, 10 2008. doi: 10.1109/PHM.2008.4711414.
15
[17] C. Wang and M. Gao. Sam: A scalable accelerator for number theoretic transform using multi-dimensional decomposition. In Proceedings of the IEEE/ACM International Conference on Computer-Aided Design (ICCAD), 2023. [18] Z. Ye and M. Ikeda. Implementing homomorphic encryption-based logic locking in soc designs. IEEE Transactions on Very Large Scale Integration (VLSI) Systems, 33(7), 2025. [19] Z. Zheng, Z. Wang, X. Cui, M. Li, J. Chen, Yun, Liang, A. Li, and X. Chen. Fedhq: Hybrid runtime quantization for federated learning, 2025. URL https://arxiv.org/ abs/2505.11982. [20] L. Zhu, Z. Liu, and S. Han. Deep leakage from gradients. In Advances in Neural Information Processing Systems (NeurIPS), volume 32, 2019.
16