acceptodds
Under review as a conference paper at ICLR 2027

FedTinyTS: An Ultra-Low-Communication One-Shot Federated Learning Framework for Long-Term Time Series Forecasting

Abstract

One-shot analytic federated learning in long-term time series forecasting remains challenging due to both high communication costs and limited local adaptation. These methods transmit dense moment matrices whose size grows quadratically with input length, while directly applying the collaboratively estimated knowledge to all clients can underperform local-only training by overlooking client-specific information. We propose FedTinyTS, a one-shot analytic protocol for a channel-independent linear forecasting backbone that removes that quadratic growth, exchanging compact summaries of temporal dependencies in a single round and fitting the model analytically rather than through repeated federated optimization. Because compression can reduce global forecasting performance, FedTinyTS uses reliability-aware aggregation to preserve the quality of the shared model. It further adapts the collaboratively learned knowledge to each client using locally retained information, improving personalized performance without further communication. Across five benchmarks and four horizons, FedTinyTS reduces the message payload by up to compared with FedAvg and up to compared with dense FedRidge. Averaged across horizons, the global model achieves lower mean squared error than FedAvg on every benchmark but SolarEnergy, and personalization lowers it further on the same four, by up to 3.75%. The dense analytic baselines, which never adapt to a client, instead fall behind a purely local fit by up to 6.31%. Mean absolute error is less favorable, a gap the dense analytic baselines share. Compact temporal summaries therefore retain enough structure to fit a federated forecaster in one round. Code is available at https://anonymous.4open.science/r/FedTinyTS.

Primary area:
other topics in machine learning (i.e., none of the above)
Keywords:
Federated learning, Time-series forecasting, Communication efficiency, One-shot learning, Personalized federated learning

Reviews

Among:
Shape:
1234this paper, Bottom 49%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.25 over 4 reviews, above 49% of the others.
Reviewer_BPT6OpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes the FedTinyTS three-stage framework to address the issues of high communication overhead and poor model adaptability in federated temporal prediction. Through three steps of compressed transmission, reliable aggregation, and local adaptation, the framework significantly reduces communication volume while maintaining good prediction performance.

Critical strengths
  1. The amount of data to be transmitted has significantly decreased, by up to several thousand times compared with FedAvg, saving bandwidth and time.
  2. With just one round trip of data transmission, a shared prediction model can be developed, and each client can adjust its own version to suit local conditions without the need for additional communication.
  3. This paper is well written and easy to follow.
Critical weaknesses
  1. The poor performance of the method on the MAE metric indicates significant limitations in predictive performance.
  2. The compression of temporal data relies on stable data patterns, but it has not been fully validated on data with changing patterns.
  3. It only uses a simple linear prediction model and cannot capture complex nonlinear relationships in the data, which limits its applicability in various scenarios.
  4. Without a dedicated privacy protection mechanism, the transmitted statistical information may still reveal information about the original data.
Questions for authors
  1. Why does FedTinyTS perform worse than some baseline methods in terms of MAE? Are the results still the same when compared under the same training loss function?
  2. Can FedTinyTS maintain its predictive performance when there are non-stationary features such as obvious trends and sudden changes in the time series? Is there any relevant experimental support?
  3. Why does FedTinyTS only use a linear prediction model? Does FedTinyTS still have advantages over federated forecasting methods that can handle nonlinear relationships?
  4. Is it possible for the transmitted statistical information to leak characteristics of a client's original data? Can you provide an experimental assessment of privacy leakage risks?
  5. In the paper's experiments, personalization is actually performed on the server. If executed on the client side according to the proposed communication protocol, will the communication cost and running time still be consistent with the reported results?
9 comments

W1 & Q1: Worse MAE than some baselines under the same training loss?

Thanks for raising this question. The MAE gap primarily reflects the mismatch in training objectives rather than lag compression, and under the same training loss FedTinyTS has the lowest MAE.

(1) Global MAE under the original training losses. The analytic methods minimize squared error, so they target the conditional mean, while the gradient baselines in the MAE column were trained with an MAE loss, which targets the median. DLSA [1] and FedRidge [2], which have no robust weighting, show the same gap to FedAvg. Our Huber weighting lowers MAE below FedRidge in 19 of 20 settings, but only slightly, since with cH=1.345c_{\mathrm H}=1.345 most windows stay in the quadratic regime.

Table R1. Global MAE, mean over horizons (Table E5), increase over FedAvg in parentheses:

DatasetFedAvgDLSAFedRidgeFedTinyTS
ETH0.40290.4122 (+2.3%+2.3\%)0.4122 (+2.3%+2.3\%)0.4069 (+1.0%+1.0\%)
Electricity0.29310.2943 (+0.4%+0.4\%)0.2969 (+1.3%+1.3\%)0.2938 (+0.2%+0.2\%)
SolarEnergy0.31340.3957 (+26.3%+26.3\%)0.3954 (+26.2%+26.2\%)0.3923 (+25.2%+25.2\%)
TW5K0.59330.5961 (+0.5%+0.5\%)0.5967 (+0.6%+0.6\%)0.5964 (+0.5%+0.5\%)
Traffic0.34820.3705 (+6.4%+6.4\%)0.3719 (+6.8%+6.8\%)0.3683 (+5.8%+5.8\%)

Finding. All three analytic methods trail FedAvg by a similar margin, so the gap belongs to the squared-error fit, not to compression.

(2) Global MAE with all methods trained on MSE. We trained the gradient baselines with MSE, the same loss as ours, and scored them on MAE (best round per seed, 3 seeds). MSE is minimized by the mean and MAE by the median [3], so an MAE column favors models trained for the median. Training everyone with MSE removes that advantage.

Table R2. Global MAE, mean over horizons, all methods trained with MSE (change of FedTinyTS vs FedAvg):

DatasetFedAvgFedLUARQATFLFedTinyTS
ETH0.40950.41120.43000.4069 (−0.6%-0.6\%)
Electricity0.30100.30230.30330.2938 (−2.4%-2.4\%)
SolarEnergy0.39470.39720.39830.3923 (−0.6%-0.6\%)
TW5K0.60310.60680.60660.5964 (−1.1%-1.1\%)
Traffic0.38110.38070.38220.3683 (−3.4%-3.4\%)

Finding. Under the same training loss, FedTinyTS has the lowest MAE on all five datasets. On SolarEnergy the gap to FedAvg goes from +25.2%+25.2\% to −0.6%-0.6\%.

(3) Personalized MAE with LocalOnly trained on MSE. LocalOnly is gradient-trained too, and its MAE in Table E6 also comes from an MAE-trained run. We scored its MSE-trained client models on MAE in the same way (3 seeds).

Table R3. Personalized MAE, mean over horizons (change of FedTinyTS vs LocalOnly):

DatasetLocalOnlyFedTinyTS
ETH0.41090.4030 (−1.9%-1.9\%)
Electricity0.29240.2873 (−1.8%-1.8\%)
SolarEnergy0.40380.3938 (−2.5%-2.5\%)
TW5K0.59080.5880 (−0.5%-0.5\%)
Traffic0.38130.3724 (−2.3%-2.3\%)

Finding. Under the same training loss, personalized FedTinyTS has lower MAE than LocalOnly in all 20 dataset-horizon settings. LocalOnly is scored on its saved best checkpoint, which the framework writes one round after the best evaluation. On ETH its MSE there is 0.3599 against the recorded 0.3557, and on the other four datasets the two agree to four decimals.

(4) Revision. We added (2) and (3) to Appendix E.3 (Table E10, in red).

[1] X. Zhu, F. Li, H. Wang. Least-Square Approximation for a Distributed System. JCGS, 30(4), 2021.

[2] Z. Alsulaimawi. One-Shot Federated Ridge Regression. arXiv:2601.08216, 2026.

[3] H. Hewamalage, K. Ackermann, C. Bergmeir. Forecast Evaluation for Data Scientists: Common Pitfalls and Best Practices. DMKD, 37, 2023.

W2 & Q2: Non-stationary data with trends or sudden changes.

Thanks for raising this question. Our results support gradual drift and weak non-stationarity represented in the benchmarks, but not abrupt level shifts or sudden structural changes.

(1) The benchmarks are non-stationary. The main results in Section 4 are obtained on these series.

Table R4. Stationarity tests and train-to-test shift per dataset (definitions in (4)):

DatasetSeriesNon-stationary (ADF or KPSS, 5%)Median mean shift (train SD)Series shifting >0.5>0.5 SDMedian KS
ETH14100%0.3428.6%0.20
Electricity32198.1%0.135.6%0.11
SolarEnergy137100%0.200.0%0.09
TW5K1,00053.3%0.061.2%0.05
Traffic86279.1%0.083.3%0.07

Finding. Most series fail a stationarity test, but their drift is weak (median train/test shift 0.06 to 0.34 SD). These aggregate diagnostics are consistent with locally stationary processes [1, 2], the regime of standard long-term forecasting benchmarks [3], although they do not test stationarity within each window.

(2) Scope of the stationarity assumption. The global least-squares solve does not require global stationarity. However, accurate lag compression relies on approximate lag invariance within each window, corresponding to a weak local-stationarity condition.

(3) Sudden changes are out of scope. Level shifts and similar abrupt changes are usually handled by change detection, windowing or forgetting [6].

(4) Tests. ADF [4] counts a series as non-stationary when p≥0.05p\ge0.05, KPSS [5] when p<0.05p<0.05. Shift is (test mean −- train mean) / train SD, and KS is the two-sample Kolmogorov–Smirnov statistic.

(5) Revision. We revised the Conclusion (in red) to state that the scope is weak non-stationarity, with sudden changes such as level shifts outside it.

[1] M. B. Priestley. Evolutionary Spectra and Non-Stationary Processes. JRSS-B, 27(2), 1965.

[2] R. Dahlhaus. Fitting Time Series Models to Nonstationary Processes. Annals of Statistics, 25(1), 1997.

[3] Y. Liu, H. Wu, J. Wang, M. Long. Non-stationary Transformers. NeurIPS, 2022.

[4] S. E. Said, D. A. Dickey. Testing for Unit Roots in ARMA Models of Unknown Order. Biometrika, 71(3), 1984.

[5] D. Kwiatkowski, P. Phillips, P. Schmidt, Y. Shin. Testing the Null Hypothesis of Stationarity. J. Econometrics, 54, 1992.

[6] J. Gama et al. A Survey on Concept Drift Adaptation. ACM Computing Surveys, 46(4), 2014.

W3 & Q3: Only a linear prediction model.

Thanks for raising this question. The current formulation is intentionally scoped to a channel-independent linear forecaster. Replacing this backbone with a more expressive model is not a plug-in change, because the lag summaries and closed-form solve are derived specifically for the linear forecasting problem. Our claim concerns communication, not higher accuracy than nonlinear iterative methods.

(1) The closed-form solve is specific to the linear model. FedTinyTS is an analytic FL method, so the model is fitted in closed form, not by gradient descent, and a closed-form solve is derived for one model. Changing the backbone means deriving a different solve (scope stated at the end of Section 2 and in the Conclusion).

(2) The closed-form baselines share this restriction. The DLSA [2] and FedRidge [3] baselines in our experiments are instantiated on the same linear forecasting design. FedRidge performs exact single-round aggregation of ridge-regression sufficient statistics, whereas DLSA more generally combines local quadratic approximations. Neither provides a direct nonlinear replacement for the specific FedTinyTS lag-summary solve evaluated here.

(3) What we claim. A competitive linear forecaster [1] can be fitted in one round with an upload of L+H+2L+H+2 numbers. Fixing the backbone separates the communication comparison from backbone capacity.

(4) A route to nonlinear models. Analytic FL on a fixed or layer-wise feature map (AFL [4] and DeepAFL [5], Section 2) puts the closed-form solve on top of the features. Cross-channel lag summaries are future work (Conclusion).

(5) Revision. We revised the Conclusion (in red) to state that the results cover this backbone only and that analytic learning on a feature map is one route to nonlinear models.

[1] A. Zeng, M. Chen, L. Zhang, Q. Xu. Are Transformers Effective for Time Series Forecasting? AAAI, 2023.

[2] X. Zhu, F. Li, H. Wang. Least-Square Approximation for a Distributed System. JCGS, 30(4), 2021.

[3] Z. Alsulaimawi. One-Shot Federated Ridge Regression. arXiv:2601.08216, 2026.

[4] R. He et al. AFL: A Single-Round Analytic Approach for Federated Learning with Pre-trained Models. CVPR, 2025.

[5] J. Tang et al. DeepAFL: Deep Analytic Federated Learning. ICLR, 2026.

Reviewer_VJsoOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
3
Soundness
3
Read review
Paper summary

The paper proposes FedTinyTS for federated time-series forecasting in one communication round. Clients send compressed statistics. The server combines them to fit a linear model. Clients then adapt the model locally without further communication. The authors prove consistency and bound compression error. Experiments on five datasets compare accuracy and communication costs against iterative and one-shot methods.

Critical strengths
  1. Exploits time-series structure to compress both uploads and downloads. Communication grows as O(L+H)O(L+H).
  2. Uses one communication round. Clients personalize the model without further communication.
  3. Experiments on five datasets show MSE close to dense analytic baselines at substantially lower communication cost.
Critical weaknesses

The chosen low communication budget needs stronger motivation. This could come from practical communication constraints or a theoretical argument for this particular representation and budget. Since compression is fixed, comparisons with compressed FedRidge at different budgets would help explain the accuracy–communication tradeoff.

The ablation provides useful evidence, but only on M4Weekly, outside the main benchmark suite. The authors explain the role of each component, but ablations on the main datasets would better establish their benefits. Removing each component from the full method would complement the sequential additions. A dense baseline with the same robustness and regularization would help isolate the effect of compression.

Questions for authors
  1. What motivates such aggressive compression? Could the budget be made tunable?
  2. Why omit compressed FedRidge from the comparison?
  3. The components have intuitive explanations. Is there theoretical or empirical evidence that each is needed?
  4. Why run the ablation only on M4Weekly? Can you test removing components from the full method on the main datasets?
  5. How does dense regression perform with the same robustness and regularization?
  6. How is the number of local steps chosen to be 5?
  7. Why are even the theorem statements deferred to the appendix?
  8. How does this relate to one-shot FL methods outside forecasting and could they be used as a baseline?
11 comments

W2 & Q3 & Q4: Is each component needed? Ablation on the main datasets.

Thanks for this suggestion. We give the theoretical role of each component and ran both ablations on the five main datasets at all four horizons.

(1) Theoretical role. Each component has a stated role in the appendix. Huber bounds each window's contribution ("Fixed-fit response clipping"). The precision cap bounds any client's pooling weight by κ/(κ+⌊N/2⌋)\kappa/(\kappa+\lfloor N/2\rfloor) ("Median-cap weight bound"). Compression changes the global solve by the Toeplitz/Hankel residuals ("Lag-compression perturbation bound"). Personalization uses exactly the withheld Toeplitz complement.

(2) Ablations on the main datasets. The paper used M4Weekly because its short, unequal, noisy series show each effect clearly.

Table R3. Sequential ablation (order of Table 3), MSE, mean over horizons:

DatasetFedRidge (dense, fixed ridge)+ Lag compression+ MP scale+ Huber+ Precision cap+ Adaptive ridge+ Personalization, fixed γ\gamma+ Full personalization
ETH0.36220.36400.36400.36150.36150.35880.35390.3539
Electricity0.21140.21540.21540.83260.21620.21120.19950.1995
SolarEnergy0.32420.33400.33400.33430.33430.32400.32560.3255
TW5K0.69230.69250.69250.69360.69360.69300.68250.6822
Traffic0.50740.51010.51010.50910.50910.50690.49800.4981
M4Weekly2.20783.34002.96712.13441.79751.26591.29751.2020

Table R4. Leave-one-out ablation (Q4), global MSE, mean over horizons:

DatasetFull FedTinyTS−- Lag compression−- Huber−- MP scale−- Precision cap−- Adaptive ridge
ETH0.35880.35910.36240.35830.35880.3615
Electricity0.21120.21120.21120.21120.30050.2162
SolarEnergy0.32400.32360.32430.32380.32400.3343
TW5K0.69300.69320.69320.69220.69300.6936
Traffic0.50690.50700.50700.50740.50690.5091
M4Weekly1.26591.09621.32202.57541.81871.7975

Table R5. Leave-one-out ablation of the personalization weight, personalized MSE, mean over horizons:

DatasetFull personalizationWithout ρi\rho_iWithout ηi\eta_i
ETH0.35390.35390.3539
Electricity0.19950.19950.1995
SolarEnergy0.32550.32550.3256
TW5K0.68220.68220.6825
Traffic0.49810.49810.4980
M4Weekly1.20201.21421.2943

Findings.

  • On the main datasets the adaptive ridge is needed everywhere, and removing it costs up to 3.2% (SolarEnergy 0.3240→0.33430.3240\to0.3343).
  • Without the precision cap, Electricity rises to 0.3005 (0.4686 at H=192H=192), and Huber alone is unstable there (0.2154→0.83260.2154\to0.8326).
  • Huber changes ETH by 1.0% and the others by at most 0.1%. The MP scale, ρi\rho_i and ηi\eta_i change MSE by at most 0.14%, since the clients have equal-length series.
  • Compression alone costs up to 3% and is recovered by the other components.
  • On M4Weekly every component except compression is needed. Removing the MP scale doubles the MSE, and removing the precision cap, the adaptive ridge or Huber raises it by 44%, 42% and 4.4%. Removing ηi\eta_i or ρi\rho_i raises the personalized MSE by 7.7% and 1.0%.
  • Removing compression lowers the global M4Weekly MSE by 13.4%. M4Weekly is strongly non-stationary (98% of series fail ADF or KPSS, and the median mean shift is 1.36 training SD vs ≤0.34\le0.34 on the main datasets), outside the method's scope (revised Conclusion). After personalization the effect of compression is negligible, with personalized MSE 1.2020 with compression and 1.2021 without it.

(3) Revision. We added the sequential and leave-one-out ablations of global MSE to Appendix E.3 (Tables E8 and E9, in red).

W1 & Q1: Motivation for the budget, and tunability.

Thanks for raising this question. The size is not a chosen budget but the size of the statistic the model needs.

(1) L+H+2L+H+2 is not a chosen compression ratio. It is the size of the lag-structured representation used by FedTinyTS: an input-lag profile of length LL, a cross-lag profile of length HH, a reliability scale, and a sample count. Once LL and HH are fixed, the payload size is fixed.

(2) Why it matters. Dense moments grow as L2+LHL^2+LH, so the gap widens with the history length, and at H=720H=720, FedRidge [1] sends 90.7×90.7\times as much as ours, up and down together (Table 1, with per-horizon sizes in Table R2 of our response to Q2). This matters with many low-bandwidth meters or sensors (321 clients on Electricity, 862 on Traffic).

(3) Tunability. The current formulation does not include a tunable payload parameter because the lag-profile dimensions are fixed by LL and HH. Our response to Q2 (Table R1 and Table R2) reports the accuracy–payload trade-off of projected FedRidge near this communication budget.

[1] Z. Alsulaimawi. One-Shot Federated Ridge Regression: Exact Recovery via Sufficient Statistic Aggregation. arXiv:2601.08216, 2026.

Q2: Why omit compressed FedRidge?

Thanks for raising this question. FedRidge itself would not compress in our settings, and when forced to compress at our payload it loses most of its accuracy.

(1) Why Tables 1 and 2 use dense FedRidge. FedRidge projects only when the input dimension exceeds 1,000 [1]. Here L=96L=96 and H≤720H\le720, so it runs dense, as its protocol prescribes.

(2) Forced projection near our payload. We forced the projection anyway (original protocol, shared seed) at m∈{1,2}m\in\{1,2\}, whose uplink m2+mHm^2+mH brackets our L+H+2L+H+2 at every horizon.

Table R1. Global MSE, mean over horizons (FedRidge and FedTinyTS average three seeds):

DatasetFedRidgeProj m=1m{=}1FedRidgeProj m=2m{=}2FedRidge (dense)FedTinyTS
ETH0.6560.5560.3620.359
Electricity0.8780.6660.2110.211
SolarEnergy0.6940.6080.3240.324
TW5K0.8770.8230.6920.693
Traffic1.1951.0590.5070.507

Table R2. Total message size per client, uplink plus downlink, in values (L=96L=96, 4 bytes each, matching the measured traffic). Uplink is m2+mHm^2+mH for FedRidgeProj, L2+LHL^2+LH for dense FedRidge and L+H+2L+H+2 for FedTinyTS. Downlink is LH+HLH+H for both FedRidge variants and L+HL+H for FedTinyTS.

MethodH=96H=96H=192H=192H=336H=336H=720H=720
FedRidgeProj m=1m{=}1, total9,40918,81732,92970,561
FedRidgeProj m=2m{=}2, total9,50819,01233,26871,284
FedRidge dense, total27,74446,27274,064148,176
FedTinyTS, total3865788661,634

Findings. Exact total-payload matching is not possible under the original projected FedRidge protocol because it still broadcasts the full L×HL\times H model. Even with m=1m=1, it uses 24.4–43.2$\times$ more total payload than FedTinyTS, while its one- or two-dimensional projection loses substantially more accuracy. FedTinyTS instead preserves the lag structure and remains close to dense FedRidge.

(3) Revision. We added both tables to Appendix E.3 (Table E11, in red).

[1] Z. Alsulaimawi. One-Shot Federated Ridge Regression: Exact Recovery via Sufficient Statistic Aggregation. arXiv:2601.08216, 2026.

Q5: Dense regression with the same robustness and regularization.

Thanks for this question. With the same robustness and regularization, dense regression is within 0.14% of FedTinyTS on the five main datasets and 13.4% lower on M4Weekly.

(1) The control. This is the FedTinyTS w/o compression control, the column of Table R4 in our response to W2 & Q3 & Q4 that removes lag compression. It keeps dense Huber moments with the same capped pooling, adaptive ridge and personalization, at L2+LHL^2+LH uplink values instead of L+H+2L+H+2. Global MSE differs by −0.09%-0.09\% to +0.14%+0.14\% (ETH 0.3591 vs 0.3588, SolarEnergy 0.3236 vs 0.3240).

Finding. The gap to dense FedRidge comes from the robust pipeline, not from the dense statistics. Once robustness and regularization are the same, compression changes the global MSE by at most 0.14% on the main datasets while cutting the uplink from L2+LHL^2+LH to L+H+2L+H+2 values. Personalized errors match (M4Weekly 1.2021 vs 1.2020), since Phase 3 uses the client's own dense moments in both cases.

(2) M4Weekly (1.0962 vs 1.2659) is strongly non-stationary, outside the method's scope (our response to W2 & Q3 & Q4).

(3) Revision. We added this control to Appendix E.3 (in red), as the column of Table E9 that removes lag compression.

Q6: How is T=5T=5 chosen?

Thanks for this question. TT is not a number of local training steps or epochs. FedTinyTS has no gradient training and runs one communication round.

(1) What TT is. TT is the maximum number of Huber IRLS updates in Phase 1 (notation table, Algorithm 1). Each update is a closed-form weighted ridge solve, and it stops earlier when the relative change falls below τ=10−4\tau=10^{-4}.

(2) How it was chosen. We fixed T=5T=5 a priori as a small computational cap and did not tune it using validation or test performance. In practice, the recursion may stop earlier when the relative change falls below τ=10−4\tau=10^{-4}. The theoretical analysis applies to any fixed finite TT and does not require the IRLS recursion to converge (Assumption "Finite recursion and separated stopping decisions"). Local epochs and rounds apply only to the gradient baselines (100 rounds, one local epoch each).

Q7: Theorem statements deferred to the appendix.

Thanks for pointing this out. This was a space decision, and we agree the main statements belong in the main text.

Revision. The revised manuscript (in red) adds Section 3.4 (Theoretical Guarantees) with the five assumptions in compact form, Theorem 1 (consistency of the global and personalized solves, with the compression-error bound) and Corollary 1 (error decomposition into estimation, compression and estimand shift), each pointing to its proof in Appendix C.

Q8: Relation to one-shot FL outside forecasting.

Thanks for this question. They are related in round count, not in mechanism, and the closest ones are already baselines.

Table R6. Single-round and analytic FL methods and their relation to FedTinyTS:

FamilyHow the model is fittedRelation to FedTinyTS
One-shot FL (gradient)Local models trained by gradient descent, merged in one roundDifferent mechanism
DLSA [1], FedRidge [2]Closed-form least squares, general purposeBaselines in every table, applied to the forecasting design unchanged
AFL [3], APFL [4], DeepAFL [5]Closed-form solve on pretrained features (classification)With raw-window features, AFL's solve is the same federated ridge problem as FedRidge
FedTinyTSClosed-form robust least squares on L+H+2L+H+2 lag summaries

Finding. The closed-form methods closest to ours are baselines in every table. The others either reduce to FedRidge on raw windows or rely on gradient training.

[1] X. Zhu, F. Li, H. Wang. Least-Square Approximation for a Distributed System. JCGS, 30(4), 2021.

[2] Z. Alsulaimawi. One-Shot Federated Ridge Regression. arXiv:2601.08216, 2026.

[3] R. He et al. AFL: A Single-Round Analytic Approach for Federated Learning with Pre-trained Models. CVPR, 2025.

[4] K. Fan et al. APFL: Analytic Personalized Federated Learning via Dual-Stream Least Squares. arXiv:2508.10732, 2025.

[5] J. Tang et al. DeepAFL: Deep Analytic Federated Learning. ICLR, 2026.

Reviewer_7M5FOpenReview ↗
Rating
3
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

FedTinyTS is a one-round federated method for a channel-independent linear forecaster. Clients compress Huber-weighted training moments into temporal lag profiles and the server pools these profiles, and clients can combine the broadcast result with moments retained locally. Across five datasets and four horizons, its declared payload is about 85.5× smaller than dense one-shot FedRidge, with similar global MSE. Its personalized MSE is best among the reported local methods in most of the settings. The communication figures count the fields in the proposed protocol, not measured network traffic. FedTinyTS also has higher MAE than FedAvg in all 20 global settings and higher MAE than LocalOnly in all the personalized settings.

Critical strengths
  • Small one-round message. The protocol sends (L+H+2) values per client and broadcasts (L+H). Table 1 reports 85.5× less declared payload than one-shot FedRidge, while Table 2 keeps global MSE within 1% of FedRidge on each of the five datasets. That combination matters when communication is the constraint.

  • Personalization using retained information. Equation 8 describes a client-side solve using moments retained after the upload. Table E6 reports the lowest personalized MSE in 17 of 20 settings.

Critical weaknesses
  • The communication comparison needs a stronger control and a client-side measurement. A matched-payload projected FedRidge comparison and measured client-side traffic could help readers understand the paper in a better way. Section 2 notes FedRidge’s projection variant, but Tables 1 and 2 use its dense version. Appendix D says the simulator computes personalization at the server with dense moments available in memory.

  • The benefit of shared profiles is not isolated. A local solve using the same Huber-weighted moments with γi=0\gamma_i=0 could improve the contribution of the paper. Equation 8 uses those moments, while Table E6’s local references use different fitting rules. Table 3 is a single M4Weekly run and does not provide that control on the main benchmarks.

Questions for authors
  • If possible, could you compare with projected FedRidge at a matched total message size and report the accuracy-payload tradeoff?

  • How does personalization compare with a local γi=0\gamma_i=0 solve using the same robust moments across all 20 main settings?

  • Can you run Phase 3 on clients and report actual transferred bytes and end-to-end time? Appendix D says the timed simulator performs that solve on the server.

  • A minor ask, Appendix E reports a 0.016 MSE spread across the three personalized Electricity (H=96) runs despite nearly identical pooled inputs. Could you provide the per-run values, conditioning diagnostics, and the standard deviation that the text says appears in Table E6? The paper contribution will be solid if the matched controls and client-side results hold up and the unstable solve is accounted for.

8 comments

Summary: Higher MAE than FedAvg.

Thanks for this careful observation. The MAE gap primarily reflects the mismatch in training objectives rather than lag compression, and the Abstract and Conclusion state it as a limitation.

(1) Global MAE under the original training losses. The analytic methods minimize squared error, so they target the conditional mean, while the gradient baselines in the MAE column were trained with an MAE loss, which targets the median. DLSA [1] and FedRidge [2], which have no robust weighting, show the same gap to FedAvg. Our Huber weighting lowers MAE below FedRidge in 19 of 20 settings, but only slightly, since with cH=1.345c_{\mathrm H}=1.345 most windows stay in the quadratic regime.

Table R1. Global MAE, mean over horizons (Table E5), increase over FedAvg in parentheses:

DatasetFedAvgDLSAFedRidgeFedTinyTS
ETH0.40290.4122 (+2.3%+2.3\%)0.4122 (+2.3%+2.3\%)0.4069 (+1.0%+1.0\%)
Electricity0.29310.2943 (+0.4%+0.4\%)0.2969 (+1.3%+1.3\%)0.2938 (+0.2%+0.2\%)
SolarEnergy0.31340.3957 (+26.3%+26.3\%)0.3954 (+26.2%+26.2\%)0.3923 (+25.2%+25.2\%)
TW5K0.59330.5961 (+0.5%+0.5\%)0.5967 (+0.6%+0.6\%)0.5964 (+0.5%+0.5\%)
Traffic0.34820.3705 (+6.4%+6.4\%)0.3719 (+6.8%+6.8\%)0.3683 (+5.8%+5.8\%)

Finding. All three analytic methods trail FedAvg by a similar margin, so the gap belongs to the squared-error fit, not to compression.

(2) Global MAE with all methods trained on MSE. We trained the gradient baselines with MSE, the same loss as ours, and scored them on MAE (best round per seed, 3 seeds). MSE is minimized by the mean and MAE by the median [3], so an MAE column favors models trained for the median. Training everyone with MSE removes that advantage.

Table R2. Global MAE, mean over horizons, all methods trained with MSE (change of FedTinyTS vs FedAvg):

DatasetFedAvgFedLUARQATFLFedTinyTS
ETH0.40950.41120.43000.4069 (−0.6%-0.6\%)
Electricity0.30100.30230.30330.2938 (−2.4%-2.4\%)
SolarEnergy0.39470.39720.39830.3923 (−0.6%-0.6\%)
TW5K0.60310.60680.60660.5964 (−1.1%-1.1\%)
Traffic0.38110.38070.38220.3683 (−3.4%-3.4\%)

Finding. Under the same training loss, FedTinyTS has the lowest MAE on all five datasets. On SolarEnergy the gap to FedAvg goes from +25.2%+25.2\% to −0.6%-0.6\%.

(3) Personalized MAE with LocalOnly trained on MSE. LocalOnly is gradient-trained too, and its MAE in Table E6 also comes from an MAE-trained run. We scored its MSE-trained client models on MAE in the same way (3 seeds).

Table R3. Personalized MAE, mean over horizons (change of FedTinyTS vs LocalOnly):

DatasetLocalOnlyFedTinyTS
ETH0.41090.4030 (−1.9%-1.9\%)
Electricity0.29240.2873 (−1.8%-1.8\%)
SolarEnergy0.40380.3938 (−2.5%-2.5\%)
TW5K0.59080.5880 (−0.5%-0.5\%)
Traffic0.38130.3724 (−2.3%-2.3\%)

Finding. Under the same training loss, personalized FedTinyTS has lower MAE than LocalOnly in all 20 dataset-horizon settings. LocalOnly is scored on its saved best checkpoint, which the framework writes one round after the best evaluation. On ETH its MSE there is 0.3599 against the recorded 0.3557, and on the other four datasets the two agree to four decimals.

(4) Revision. We added (2) and (3) to Appendix E.3 (Table E10, in red).

[1] X. Zhu, F. Li, H. Wang. Least-Square Approximation for a Distributed System. JCGS, 30(4), 2021.

[2] Z. Alsulaimawi. One-Shot Federated Ridge Regression. arXiv:2601.08216, 2026.

[3] H. Hewamalage, K. Ackermann, C. Bergmeir. Forecast Evaluation for Data Scientists: Common Pitfalls and Best Practices. DMKD, 37, 2023.

W1-part1 & Q1: Projected FedRidge at a matched total message size.

Thanks for suggesting this control. Near our payload, projected FedRidge loses most of its accuracy, while ours stays at the level of dense FedRidge.

(1) Why Tables 1 and 2 use dense FedRidge. FedRidge projects only when the input dimension exceeds 1,000 [1]. Here L=96L=96 and H≤720H\le720, so it runs dense, as its protocol prescribes.

(2) Forced projection near our payload. We forced the projection anyway (original protocol, shared seed) at m∈{1,2}m\in\{1,2\}, whose uplink m2+mHm^2+mH brackets our L+H+2L+H+2 at every horizon.

Table R4. Global MSE, mean over horizons (FedRidge and FedTinyTS average three seeds):

DatasetFedRidgeProj m=1m{=}1FedRidgeProj m=2m{=}2FedRidge (dense)FedTinyTS
ETH0.6560.5560.3620.359
Electricity0.8780.6660.2110.211
SolarEnergy0.6940.6080.3240.324
TW5K0.8770.8230.6920.693
Traffic1.1951.0590.5070.507

Table R5. Total message size per client, uplink plus downlink, in values (L=96L=96, 4 bytes each, matching the measured traffic). Uplink is m2+mHm^2+mH for FedRidgeProj, L2+LHL^2+LH for dense FedRidge and L+H+2L+H+2 for FedTinyTS. Downlink is LH+HLH+H for both FedRidge variants and L+HL+H for FedTinyTS.

MethodH=96H=96H=192H=192H=336H=336H=720H=720
FedRidgeProj m=1m{=}1, total9,40918,81732,92970,561
FedRidgeProj m=2m{=}2, total9,50819,01233,26871,284
FedRidge dense, total27,74446,27274,064148,176
FedTinyTS, total3865788661,634

Findings. Exact total-payload matching is not possible under the original projected FedRidge protocol because it still broadcasts the full L×HL\times H model. Even with m=1m=1, it uses 24.4–43.2$\times$ more total payload than FedTinyTS, while its one- or two-dimensional projection loses substantially more accuracy. FedTinyTS instead preserves the lag structure and remains close to dense FedRidge.

(3) Revision. We added both tables to Appendix E.3 (Table E11, in red).

[1] Z. Alsulaimawi. One-Shot Federated Ridge Regression: Exact Recovery via Sufficient Statistic Aggregation. arXiv:2601.08216, 2026.

W1-part2 & Q3: Phase 3 on the clients, with measured bytes and end-to-end time.

Thanks for this concrete request. We implemented it and report the measured bytes and time.

(1) The reported results come from a single-process simulator with stateless client calls. All results in the paper are simulated on one machine in FedProC. It stores each client's (Gi,Ci)(G_i, C_i) in client-indexed simulator state, rather than in a persistent client process, and invokes the corresponding Phase 3 solve from the server's aggregation step (Appendix D). Only the declared fields are counted as traffic, (ri,si,σ^i2,ni)(r_i, s_i, \hat\sigma_i^2, n_i) up and (rg,sg)(r_g, s_g) down, and the Phase 3 solve for client ii reads only that client's retained moments and the pooled profiles (rg,sg)(r_g, s_g).

(2) A new implementation in which each party runs its own phase. We added FedTinyTSSafeguardStateful.py to the anonymous repository linked in the abstract (https://anonymous.4open.science/r/FedTinyTS), whose README shows how to run it. It uses FedProC's stateful client API, where each client is a persistent object.

  • Each client runs Phase 1 and keeps (Gi,Ci)(G_i, C_i) as attributes of its own object.
  • The client serializes (ri,si,σ^i2,ni)(r_i, s_i, \hat\sigma_i^2, n_i) and sends only those bytes. After deserialization, the server receives only an LL-dimensional lag profile, an HH-dimensional cross-lag profile, and two scalars. No dense L×LL\times L or L×HL\times H matrix is included in the message or stored by the server.
  • The server runs Phase 2 and sends back the serialized (rg,sg)(r_g, s_g).
  • Each client runs Phase 3 from its own (Gi,Ci)(G_i, C_i) and the received profiles.

(3) Equivalence to the reported results. We reran all 20 settings with MSE and MAE. 78 of the 80 global and personalized MSE/MAE values equal Tables E5 and E6 to four decimals. The other two (Electricity, H=96H=96, personalized: MSE 0.1842 vs 0.1843, MAE 0.2695 vs 0.2696) differ by 0.0001. The reported values come from the stateless simulator of (1) and the rerun from the stateful implementation of (2). Both solve the same system and differ only in floating-point details (the stateful one serializes float32 statistics and accumulates the pooled profiles in a different order), and this cell contains a near-singular client whose solve amplifies such differences. The global values agree to 10−810^{-8}. Thus, moving Phase 3 to the clients does not change any of the paper's conclusions.

(4) Measured bytes per client. We measured the bytes on the ETH runs, where the server's check passed at every horizon. The size depends only on HH.

Table R6. Bytes per client and message at L=96L=96:

H=96H=96H=192H=192H=336H=336H=720H=720
Uplink payload, 4(L+H+2)4(L+H+2)7761,1601,7363,272
Uplink serialized message2,7213,1053,6815,217
Downlink payload, 4(L+H)4(L+H)7681,1521,7283,264
Downlink serialized message2,5332,9173,4935,029

Finding. The serialized message adds a fixed container overhead of about 1.9 KB (torch.save), while a raw float32 encoding needs only the payload.

(5) Client-side runtime. We measured each phase on a single machine with an Intel i9-13900K CPU, excluding network latency. Phases 1 and 3 report the slowest client time. The parallel critical path is estimated as max⁡iT1,i+T2+max⁡iT3,i\max_iT_{1,i}+T_2+\max_iT_{3,i}, while the final column reports the measured sequential wall-clock time.

Table R7. Time per phase, with each range covering H=96H=96 to 720720:

DatasetClientsPhase 1, slowest client (s)Phase 2, server (ms)Phase 3, slowest client (ms)Parallel critical path (s)Sequential wall-clock (s)
ETH20.30 – 0.990.6 – 0.90.27 – 0.460.30 – 0.990.6 – 1.9
Electricity3210.22 – 0.861.8 – 2.10.23 – 0.590.23 – 0.8761 – 220
SolarEnergy1370.41 – 1.161.2 – 1.40.24 – 0.340.41 – 1.1650 – 148
TW5K2001.20 – 4.841.5 – 1.60.29 – 0.391.20 – 4.85220 – 815
Traffic8620.16 – 0.393.9 – 4.30.23 – 0.330.16 – 0.39101 – 297

Finding. Phase 1 dominates the computation, while client-side Phase 3 requires one L×LL\times L solve and takes less than 1 ms per client. Thus, moving personalization to the clients adds negligible computation relative to local moment construction.

(6) Revision. We revised Appendix D (in red) to state that the simulator runs all parties in one process and calls each client's Phase 3 solve from the server's aggregation step, a solve that reads only that client's own retained moments and the pooled profiles. We also added the equivalence check of (3) and the time per phase of (5) to Appendix E.3 (Table E12, in red).

Reviewer_1WKvOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
1
Read review
Paper summary

The paper proposes FedTinyTS, a one-shot federated learning method for channel-independent linear time series forecasting. Clients construct robust local moment matrices and compress them into temporal lag profiles. The server pools these profiles using capped precision weights and reconstructs the matrices needed for an analytic global solve. Clients then combine the shared profiles with retained local moments to obtain personalized models without further communication. The evaluation covers five forecasting benchmarks and four prediction horizons, with an additional ablation on M4Weekly. The paper reports substantial reductions in declared message payload while maintaining broadly comparable MSE to dense analytic baselines.

Critical strengths
  1. The paper addresses a clear communication bottleneck in analytic federated forecasting. Replacing dense moment matrices with lag profiles reduces the complete per-client exchange from quadratic-size statistics to 2L+2H+22L+2H+2 values.

  2. The evaluation includes substantially more than a small-client demonstration. Four main benchmarks contain between 137 and 862 clients. The paper also reports participation rules, local training budgets, and comparisons with both federated and purely local methods.

Critical weaknesses
  1. Appendix D states that the archived simulator returns dense local moments in memory and performs personalization at the server, while the communication logger counts only the declared compressed fields. The payload formulas therefore describe the proposed message schema, but the runtime experiments do not validate an implementation that exchanges only those messages and keeps the dense moments on clients.

  2. FedTinyTS combines robust reweighting, precision-based pooling, adaptive regularization, and personalization, whereas FedRidge uses a fixed ridge coefficient of 0.1. Table 3 itself shows that compression alone substantially worsens performance and that later additions recover the loss. However, this ablation uses a different dataset and window configuration, with only one execution per row.

  3. All main experiments use a small channel-independent linear model with L=96L=96. Using the same backbone is a reasonable way to isolate communication, but the results do not establish applicability to nonlinear models or models that exploit cross-channel dependencies.

Questions for authors
  1. Did any experiments keep the dense matrices on the clients and perform personalization locally, sending only the compressed summaries to the server? If so, which results used this setup?

  2. Could you provide results with larger or more expressive models? The current experiments use very small linear models, which makes it hard to judge how useful the method would be in more demanding forecasting tasks.

7 comments

W1 & Q1: Were the dense moments kept and personalization run on the clients?

Thanks for the careful reading of Appendix D. We answer with what the paper used and a new client-side implementation.

(1) The reported results come from a single-process simulator with stateless client calls. All results in the paper are simulated on one machine in FedProC. It stores each client's (Gi,Ci)(G_i, C_i) in client-indexed simulator state, rather than in a persistent client process, and invokes the corresponding Phase 3 solve from the server's aggregation step (Appendix D). Only the declared fields are counted as traffic, (ri,si,σ^i2,ni)(r_i, s_i, \hat\sigma_i^2, n_i) up and (rg,sg)(r_g, s_g) down, and the Phase 3 solve for client ii reads only that client's retained moments and the pooled profiles (rg,sg)(r_g, s_g).

(2) A new implementation in which each party runs its own phase. We added FedTinyTSSafeguardStateful.py to the anonymous repository linked in the abstract (https://anonymous.4open.science/r/FedTinyTS), whose README shows how to run it. It uses FedProC's stateful client API, where each client is a persistent object.

  • Each client runs Phase 1 and keeps (Gi,Ci)(G_i, C_i) as attributes of its own object.
  • The client serializes (ri,si,σ^i2,ni)(r_i, s_i, \hat\sigma_i^2, n_i) and sends only those bytes. After deserialization, the server receives only an LL-dimensional lag profile, an HH-dimensional cross-lag profile, and two scalars. No dense L×LL\times L or L×HL\times H matrix is included in the message or stored by the server.
  • The server runs Phase 2 and sends back the serialized (rg,sg)(r_g, s_g).
  • Each client runs Phase 3 from its own (Gi,Ci)(G_i, C_i) and the received profiles.

(3) Equivalence to the reported results. We reran all 20 settings with MSE and MAE. 78 of the 80 global and personalized MSE/MAE values equal Tables E5 and E6 to four decimals. The other two (Electricity, H=96H=96, personalized: MSE 0.1842 vs 0.1843, MAE 0.2695 vs 0.2696) differ by 0.0001. The reported values come from the stateless simulator of (1) and the rerun from the stateful implementation of (2). Both solve the same system and differ only in floating-point details (the stateful one serializes float32 statistics and accumulates the pooled profiles in a different order), and this cell contains a near-singular client whose solve amplifies such differences. The global values agree to 10−810^{-8}. Thus, moving Phase 3 to the clients does not change any of the paper's conclusions.

(4) Measured bytes per client. We measured the bytes on the ETH runs, where the server's check passed at every horizon. The size depends only on HH.

Table R1. Bytes per client and message at L=96L=96:

H=96H=96H=192H=192H=336H=336H=720H=720
Uplink payload, 4(L+H+2)4(L+H+2)7761,1601,7363,272
Uplink serialized message2,7213,1053,6815,217
Downlink payload, 4(L+H)4(L+H)7681,1521,7283,264
Downlink serialized message2,5332,9173,4935,029

Finding. The serialized message adds a fixed container overhead of about 1.9 KB (torch.save), while a raw float32 encoding needs only the payload.

(5) Client-side runtime. We measured each phase on a single machine with an Intel i9-13900K CPU, excluding network latency. Phases 1 and 3 report the slowest client time. The parallel critical path is estimated as max⁡iT1,i+T2+max⁡iT3,i\max_iT_{1,i}+T_2+\max_iT_{3,i}, while the final column reports the measured sequential wall-clock time.

Table R2. Time per phase, with each range covering H=96H=96 to 720720:

DatasetClientsPhase 1, slowest client (s)Phase 2, server (ms)Phase 3, slowest client (ms)Parallel critical path (s)Sequential wall-clock (s)
ETH20.30 – 0.990.6 – 0.90.27 – 0.460.30 – 0.990.6 – 1.9
Electricity3210.22 – 0.861.8 – 2.10.23 – 0.590.23 – 0.8761 – 220
SolarEnergy1370.41 – 1.161.2 – 1.40.24 – 0.340.41 – 1.1650 – 148
TW5K2001.20 – 4.841.5 – 1.60.29 – 0.391.20 – 4.85220 – 815
Traffic8620.16 – 0.393.9 – 4.30.23 – 0.330.16 – 0.39101 – 297

Finding. Phase 1 dominates the computation, while client-side Phase 3 requires one L×LL\times L solve and takes less than 1 ms per client. Thus, moving personalization to the clients adds negligible computation relative to local moment construction.

(6) Revision. We revised Appendix D (in red) to state that the simulator runs all parties in one process and calls each client's Phase 3 solve from the server's aggregation step, a solve that reads only that client's own retained moments and the pooled profiles. We also added the equivalence check of (3) and the time per phase of (5) to Appendix E.3 (Table E12, in red).

W2: Gap to FedRidge, and an ablation on one dataset with one run per row.

Thanks for pointing this out. We ran a dense control with the same pipeline and the ablation on the five main datasets at all four horizons.

(1) FedTinyTS without compression. To isolate the effect of compression from that of the robust pipeline, we disabled only the compression step while retaining the Huber-weighted moments, capped pooling, adaptive ridge, and personalization of the full method. This control therefore uploads the dense moments using L2+LHL^2+LH values, while FedRidge [1] uses a fixed ridge.

Table R3. Global MSE, mean over horizons:

DatasetFedTinyTS w/o compressionFull FedTinyTSFull −- w/o compression
ETH0.35910.3588−0.0003-0.0003
Electricity0.21120.21120.0000
SolarEnergy0.32360.3240+0.0004+0.0004
TW5K0.69320.6930−0.0002-0.0002
Traffic0.50700.5069−0.0001-0.0001
M4Weekly1.09621.2659+0.1697+0.1697

Finding. On the five main datasets, compression changes the global MSE by at most 0.0004, while reducing the uplink from L2+LHL^2+LH to L+H+2L+H+2 values. This shows that the accuracy difference between FedTinyTS and the standard FedRidge baseline comes primarily from the robust pipeline rather than compression. On M4Weekly, which exhibits a substantially larger train-to-test mean shift than the main datasets, compression increases the global MSE, whereas the personalized result remains essentially unchanged (1.2020 with compression versus 1.2021 without it) because Phase 3 retains each client's dense local moments.

(2) Ablation on the main datasets. We ran sequential and leave-one-out ablations on the five main datasets at all four horizons. FedTinyTS has no random component, so with fixed data splits and configurations, repeated runs differ only by floating-point rounding, at most 2.6×10−72.6\times10^{-7} relative in the pooled quantities, so one run per row suffices.

Table R4. Sequential ablation (order of Table 3), MSE, mean over horizons:

DatasetFedRidge (dense, fixed ridge)+ Lag compression+ MP scale+ Huber+ Precision cap+ Adaptive ridge+ Personalization, fixed γ\gamma+ Full personalization
ETH0.36220.36400.36400.36150.36150.35880.35390.3539
Electricity0.21140.21540.21540.83260.21620.21120.19950.1995
SolarEnergy0.32420.33400.33400.33430.33430.32400.32560.3255
TW5K0.69230.69250.69250.69360.69360.69300.68250.6822
Traffic0.50740.51010.51010.50910.50910.50690.49800.4981
M4Weekly2.20783.34002.96712.13441.79751.26591.29751.2020

Table R5. Leave-one-out ablation, global MSE, mean over horizons:

DatasetFull FedTinyTS−- Lag compression−- Huber−- MP scale−- Precision cap−- Adaptive ridge
ETH0.35880.35910.36240.35830.35880.3615
Electricity0.21120.21120.21120.21120.30050.2162
SolarEnergy0.32400.32360.32430.32380.32400.3343
TW5K0.69300.69320.69320.69220.69300.6936
Traffic0.50690.50700.50700.50740.50690.5091
M4Weekly1.26591.09621.32202.57541.81871.7975

Findings. Compression alone costs up to 3% (SolarEnergy), and the later components recover it. Without the precision cap, Huber is unstable on Electricity (0.2154→0.83260.2154\to0.8326), and removing the cap from the full method gives 0.3005. Removing the adaptive ridge raises MSE on every dataset, by up to 3.2% on the main datasets and 42% on M4Weekly. The MP bulk scale changes the main datasets by at most 0.14% because their clients have equal-length series, but removing it doubles the M4Weekly MSE.

(3) Revision. We added the control in (1) and both ablation tables to Appendix E.3 (Tables E8 and E9, in red).

[1] Z. Alsulaimawi. One-Shot Federated Ridge Regression: Exact Recovery via Sufficient Statistic Aggregation. arXiv:2601.08216, 2026.

W3 & Q2: Larger or more expressive models.

Thanks for raising this question. The current formulation is intentionally scoped to a channel-independent linear forecaster. Replacing this backbone with a more expressive model is not a plug-in change, because the lag summaries and closed-form solve are derived specifically for the linear forecasting problem.

(1) The closed-form solve is specific to the model. FedTinyTS is an analytic FL method, which fits the model in closed form, not by gradient descent, and a closed-form solve is derived for one model, here the channel-independent linear forecaster. Changing the backbone means deriving a different solve.

(2) The closed-form baselines share this restriction. The DLSA [2] and FedRidge [3] baselines in our experiments are instantiated on the same linear forecasting design. FedRidge performs exact single-round aggregation of ridge-regression sufficient statistics, whereas DLSA more generally combines local quadratic approximations. Neither provides a direct nonlinear replacement for the specific FedTinyTS lag-summary solve evaluated here.

(3) The backbone is fixed on purpose. It separates the communication comparison from backbone capacity, and linear forecasters are competitive on these benchmarks [1].

(4) A route to nonlinear models. Analytic FL on a fixed or layer-wise feature map (AFL [4] and DeepAFL [5], Section 2) puts the closed-form solve on top of the features. Extending the lag summaries to cross-channel dependencies is future work (Conclusion).

(5) Revision. We revised the Conclusion (in red) to state that the results cover this backbone only, that analytic learning on a feature map is one route to nonlinear models, and that the scope is weak non-stationarity, with sudden changes such as level shifts outside it.

[1] A. Zeng, M. Chen, L. Zhang, Q. Xu. Are Transformers Effective for Time Series Forecasting? AAAI, 2023.

[2] X. Zhu, F. Li, H. Wang. Least-Square Approximation for a Distributed System. JCGS, 30(4), 2021.

[3] Z. Alsulaimawi. One-Shot Federated Ridge Regression. arXiv:2601.08216, 2026.

[4] R. He et al. AFL: A Single-Round Analytic Approach for Federated Learning with Pre-trained Models. CVPR, 2025.

[5] J. Tang et al. DeepAFL: Deep Analytic Federated Learning. ICLR, 2026.

Comments on the paper

2 comments

We sincerely thank all the reviewers for their insightful comments and valuable suggestions, which have greatly helped us improve our paper.

This paper introduces FedTinyTS, a single-round analytic FL framework for long-term time series forecasting. Each client compresses its robust local moments into lag profiles of L+H+2L+H+2 values, the server solves the global model in closed form, and each client personalizes it without further communication. Across five benchmarks and four horizons, FedTinyTS reduces the message payload by up to 8,548 times compared with FedAvg and up to 90.7 times compared with dense FedRidge.

The reviewers noted that the paper "addresses a clear communication bottleneck in analytic federated forecasting", "exploits time-series structure to compress both uploads and downloads", and achieves a combination that "matters when communication is the constraint". The paper was also described as "well written and easy to follow".

The reviewers also provided many insightful comments. We have made every effort to address all the concerns. Below is a summary of the major revisions:‾\underline{\text{Below is a summary of the major revisions:}}

  • Stateful execution with the safeguard, measured bytes and running time (Reviewer 1WKv & Reviewer 7M5F & Reviewer BPT6):

    (1) We implemented a stateful version in which each client keeps its dense moments and runs the safeguarded personalization locally.

    (2) Across 20 settings, 78 of the 80 values match the paper, and the other two differ by 0.0001.

    (3) We measured the messages (2.7 to 5.2 KB uplink) and the time per phase. Client-side personalization takes less than 1 ms per client.

    Newly added→Stateful version (code repository), Appendix E.3 (Table E12)‾\text{Newly added} \rightarrow \underline{\text{Stateful version (code repository), Appendix E.3 (Table E12)}}

    Revised→Appendix D‾\text{Revised} \rightarrow \underline{\text{Appendix D}}

  • Ablations on the five main datasets and a dense control (Reviewer 1WKv & Reviewer 7M5F & Reviewer VJso):

    (1) We ran sequential and leave-one-out ablations on all main datasets and horizons. Removing the adaptive ridge raises MSE on every dataset.

    (2) A dense control with the same robust pipeline differs from FedTinyTS by at most 0.14% on the five main datasets, so the gap to FedRidge comes from the robust pipeline, not from compression.

    (3) A local γi=0\gamma_i=0 solve shows that most of the personalized gain is local, with a clear gain from the global prior on Traffic only.

    Newly added→Appendix E.3 (Tables E8 and E9)‾\text{Newly added} \rightarrow \underline{\text{Appendix E.3 (Tables E8 and E9)}}

  • Comparison with projected FedRidge (Reviewer 7M5F & Reviewer VJso): We forced FedRidge's projection at m∈{1,2}m\in\{1,2\}, which brackets our uplink. Even at m=1m=1 it sends 24.4 to 43.2 times our total payload, with much higher global MSE.

    Newly added→Appendix E.3 (Table E11)‾\text{Newly added} \rightarrow \underline{\text{Appendix E.3 (Table E11)}}

  • MAE under a matched training loss (Reviewer 7M5F & Reviewer BPT6):

    (1) The gradient baselines in the MAE columns were trained on MAE.

    (2) With every method trained on MSE, FedTinyTS has the lowest global MAE on all five datasets, and personalized FedTinyTS has lower MAE than LocalOnly in all 20 settings.

    Newly added→Appendix E.3 (Table E10)‾\text{Newly added} \rightarrow \underline{\text{Appendix E.3 (Table E10)}}

  • Stability of the personalized solve (Reviewer 7M5F): One near-singular Electricity client caused the spread. We added an εI\varepsilon I floor as a safeguard. Its spread fell from 0.0068 to 0.000003, and FedTinyTS now leads in 18 of the 20 personalized rows.

    Revised→Section 3.3, Algorithm 3, Appendix B.3, Table 2 and Table E6‾\text{Revised} \rightarrow \underline{\text{Section 3.3, Algorithm 3, Appendix B.3, Table 2 and Table E6}}

  • Non-stationarity, model scope and privacy (Reviewer 1WKv & Reviewer BPT6):

    (1) Most benchmark series fail stationarity tests but drift weakly. Sudden level shifts are out of scope.

    (2) The closed-form solve is specific to the linear model, and analytic FL on a feature map is one route to nonlinear models.

    (3) In an identifiability test on all 1,522 clients, the dense upload reveals a subspace containing both boundary segments, while under ours every segment is non-identifiable. We make no formal privacy claim.

    Revised→Section 5: Conclusion‾\text{Revised} \rightarrow \underline{\text{Section 5: Conclusion}}

  • Theory in the main text (Reviewer VJso): We added the assumptions, main theorem and corollary to the main text.

    Newly added→Section 3.4: Theoretical Guarantees‾\text{Newly added} \rightarrow \underline{\text{Section 3.4: Theoretical Guarantees}}

We have added a stateful implementation, ablations on all main datasets, and new comparisons to address the above concerns. The revisions are highlighted in red.‾\underline{\text{red.}}

More than two days have passed since we submitted our rebuttal, and we would like to encourage the reviewers to share any further comments or questions at their earliest convenience. We would be more than happy to address any questions and engage in further discussion.

We look forward to your feedback.

Dear Area Chairs and Reviewers,

As the discussion period ends, we briefly summarize its outcome, following our general response of 14 November.

Reviewer feedback. One reviewer wrote that the client-side rerun, measured message sizes, projected-FedRidge comparison and Electricity stability fix "address my main concerns", and requested two clarifications, which we made (below). Another found the new ablations and matched dense control "very useful" and asked four follow-up questions, which we answered with the analyses below.

Key results.

  • Stateful execution: the stateful version reproduces 78 of the 80 reported values, and the other two differ by 0.0001, with a serialized message of 2.7 to 5.2 KB per client (Appendix E.3).
  • MAE: with every method trained on MSE, FedTinyTS has the lowest global MAE on all five datasets (Table E10).
  • Dense control: with the same robust pipeline, sending the dense moments changes global MSE by at most 0.14% on the five main datasets (Table E9).
  • Accuracy-communication tradeoff: projected FedRidge needs 45 to 96 times our uplink to come within 1% of FedTinyTS.
  • One-shot baseline: WONDER uploads 87 to 1,124 times as much as FedTinyTS and is less accurate on all five datasets.
  • Communication constraint: a FedTinyTS upload fits in 15 LoRaWAN messages per client, versus 1,412 for dense FedRidge.
  • Theory: we added a compact version of the guarantees to the main text (Section 3.4) and explained the role of each component in them.

The last four results are detailed in our replies to the follow-up questions.

Further revisions. Section 4.3 now separates the gain from local fitting from the added benefit of the shared model, mainly on Traffic (Table E13), and the timing tables state that they exclude network latency.

In short, we addressed the main concerns with new experiments, analyses and clarifications in the revision. We sincerely thank all reviewers and Area Chairs for their time and constructive feedback, which have substantially strengthened the paper.

Best regards, The Authors

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.