acceptodds
Under review as a conference paper at ICLR 2027

GLNet: Hierarchical Global-Local Modeling for Time Series Forecasting

Abstract

Long-term time series forecasting requires models that can capture long-range dependencies while maintaining computational efficiency. Although Transformer-based approaches have achieved strong performance, their quadratic complexity and potential overfitting issues limit scalability, while lightweight linear models often struggle to capture complex temporal dynamics. To address this gap, we propose Global-Local Network (GLNet), a unified yet branch-specialized architecture that integrates global sequence modeling with local temporal refinement. The core of GLNet is the Global-Local Block (GLB), a dimension-agnostic operator that combines pointwise linear projections for global temporal mixing with convolutions for local pattern extraction. GLNet adopts a decomposition-based dual-flow design: the Seasonal Flow applies hierarchical patch-wise GLB modeling to capture local waveform variations and long-range periodic evolution, while the Trend Flow employs an activation-free global trend operator to model smooth long-term dynamics. Extensive experiments on eight real-world datasets demonstrate that GLNet achieves leading mean forecasting accuracy while maintaining faster inference speed and lower memory consumption compared with existing approaches.

Primary area:
learning on time series and dynamical systems
Keywords:
Time Series Forecasting

Reviews

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

This paper proposes GLNet, a lightweight dual-stream forecasting model combining EMA decomposition, hierarchical patching, linear global mixing, and convolutional local refinement. The model achieves competitive results on several long- and short-term forecasting benchmarks.

Critical strengths

The architecture is simple and computationally efficient. The experiments cover multiple datasets, and the results are generally competitive with recent baselines.

Critical weaknesses

The main concern is that the central “decomposition leakage” story is not empirically validated. Figure 1 only illustrates that imperfect decomposition may occur, but the paper does not quantify leakage or demonstrate that GLNet reduces it. In particular, removing activations and using a 1×1 convolution does not necessarily make GLB* a low-pass filter, as claimed.

The novelty over xPatch also appears limited. Both methods use EMA decomposition, channel independence, patching, and separate trend and seasonal flows. GLNet mainly replaces the branch operators with a linear-convolutional block. The current ablations show that the components improve performance, but do not establish that the gains arise from handling decomposition leakage. Direct comparisons with xPatch-style variants, frequency-response analyses, and linear-only/convolution-only ablations are needed.

Finally, GLNet uses dataset- and horizon-specific architecture and lookback-window tuning, while the equivalent tuning budget for the baselines is unclear. Several improvements over xPatch are small or statistically insignificant. The efficiency discussion should also acknowledge that the inter-patch operation remains quadratic in the number of patches.

Overall, GLNet appears to be an effective engineering design, but the evidence does not sufficiently support its central mechanism or establish enough novelty for ICLR.

Questions for authors

How is “decomposition leakage” quantitatively defined and measured? Can the authors provide direct evidence that GLNet reduces such leakage, for example through frequency-response analysis or an ablation that incrementally replaces the corresponding xPatch components with GLB and GLB*?

2 comments

Q1: How is leakage defined and measured?

Leakage is not an identifiable natural rate; we measure the model's sensitivity to a controlled, information-preserving reassignment of the decomposed components. Table R1 gives the result.

Table R1. Seasonal-to-trend LSS (%, lower is better) at λ=0.5\lambda=0.5; G/X = native GLNet/native xPatch; seed 2021, full test set, native configuration.

DatasetH=96 (G / X)H=192 (G / X)H=336 (G / X)
ETTh112.72 / 9.679.83 / 6.094.60 / 2.58
ETTh21.95 / 0.150.61 / 0.24-0.01 / 0.25
ETTm118.36 / 29.348.90 / 18.818.33 / 9.38
ETTm24.91 / 5.542.20 / 3.292.52 / 4.36
Weather2.87 / 10.461.76 / 6.342.11 / 5.21
Average8.16 / 11.034.66 / 6.953.51 / 4.35
GLNet wins3/53/54/5
Average reduction26%33%19%

GLNet's average LSS is lower at all three horizons and lower on 10 of 15 dataset–horizon comparisons; the relative reductions are 26%, 33%, and 19%. The result is not uniform: xPatch is better on ETTh1 at all three horizons and on ETTh2 at H=96/192.

We define leakage as the cross-band content left by EMA. For smoothing factor α\alpha,

H_S(e^{j\omega})=1-H_T(e^{j\omega}).$$ At the paper's $\alpha=0.3$, $|H_T|$ is $1.000,0.424,0.246,0.191,0.176$ at $\omega/\pi=0,1/4,1/2,3/4,1$. Nyquist-frequency content therefore still enters the trend branch with 17.6% amplitude. EMA creates this cross-band content; GLNet inherits it. Because the latent clean components are unknown, a natural leakage rate cannot be identified. We use a controlled, information-preserving reassignment instead: $$X_S^\lambda=(1-\lambda)X_S,\qquad X_T^\lambda=X_T+\lambda X_S,$$ which keeps $X_S^\lambda+X_T^\lambda=X_S+X_T=X$. Each model is trained on the clean decomposition ($\lambda=0$) and frozen; the same checkpoint is evaluated on clean and routed inputs. We report $$\operatorname{LSS}_m(\lambda)=100\cdot \frac{\operatorname{MSE}_m(X_S^\lambda,X_T^\lambda)-\operatorname{MSE}_m(X_S,X_T)} {\operatorname{MSE}_m(X_S,X_T)}.$$ Lower LSS means the forecast changes less when the same input content is reassigned. ## Q2: Direct evidence and the missing ablations The direct evidence is Table R1: under the same reassignment, xPatch's average LSS is 11.03/6.95/4.35 at H=96/192/336; GLNet's is 8.16/4.66/3.51. The missing component/activation ablations point the same way: full GLNet has the best five-dataset average, and adding GELU to GLB* hurts that average. | Variant | ETTh1 | ETTh2 | ETTm1 | ETTm2 | Weather | Avg | |---|---:|---:|---:|---:|---:|---:| | Full GLNet | 0.3901 / 0.4103 | 0.3157 / 0.3674 | 0.3550 / 0.3771 | 0.2580 / 0.3160 | 0.2181 / 0.2610 | **0.3074 / 0.3464** | | GLB linear-only | 0.3922 / 0.4129 | 0.3176 / 0.3703 | 0.3651 / 0.3827 | 0.2657 / 0.3204 | 0.2228 / 0.2648 | 0.3127 / 0.3502 | | GLB conv-only | 0.3917 / 0.4125 | 0.3145 / 0.3669 | 0.3544 / 0.3773 | 0.2607 / 0.3183 | 0.2245 / 0.2663 | 0.3092 / 0.3483 | | Trend GLB* + GELU | 0.3909 / 0.4107 | 0.3172 / 0.3680 | 0.3539 / 0.3770 | 0.2611 / 0.3196 | 0.2271 / 0.2692 | 0.3100 / 0.3489 | Across the five datasets the full configuration has the best average (0.3074 vs. 0.3092–0.3127). Linear-only is worse on every dataset; conv-only is worse on ETTh1, ETTm1, ETTm2 and Weather and 0.001 lower on ETTh2. Adding GELU to GLB* raises the average to 0.3100 and hurts Weather most (0.2271 vs. 0.2181 MSE). Cell-level differences are 0.001–0.002. Removing only the trend-flow singleton convolution is neutral or slightly better on ETTh1 (0.3866/0.4083 vs. 0.3901/0.4103), consistent with the seasonal convolution being the meaningful local operator. ## Q3: GLB* is not a low-pass filter We agree. In the trend flow the convolution operates on a singleton axis, so it is a per-channel scalar. With the activation removed, GLB* is a residual LayerNorm followed by two dense linear maps. A dense linear map can realize any frequency response, including high-pass; a 1×1 convolution and the removal of activations impose no cutoff. The only explicit low-pass stage is the EMA decomposition. We will replace "strict low-pass filter" and "complete defense against leakage" in Section 3.5 with "activation-free global trend operator," and remove the Section 4.2 sentence that attributes the attention variant's degradation to a lost low-pass property. We keep GLB* because the activation ablation supports it (Weather 0.2271 with GELU vs. 0.2181 without).

Q4: Novelty, tuning, significance, and complexity

The architectural difference from xPatch is that xPatch assigns a patch-CNN to the seasonal stream and an MLP to the trend stream, while GLNet applies the same dimension-agnostic GLB first along the intra-patch axis PP and then along the inter-patch axis NN, and uses an activation-free variant in the trend flow. The parameters are smaller: 1.03–1.46M versus 1.65–2.13M for native xPatch. The component/activation ablations above show the gains are not due to capacity.

The per-horizon deltas show where the mean advantage comes from.

Table R2. Per-horizon difference (xPatch minus GLNet), MSE / MAE. Positive is better for GLNet.

DatasetH=96H=192H=336H=720Avg
Weather+0.003 / +0.001+0.003 / 0.000+0.004 / −0.002+0.006 / +0.002+0.004 / 0.000
Traffic+0.004 / −0.019+0.008 / −0.012+0.003 / −0.022+0.011 / 0.000+0.007 / −0.013
Electricity+0.006 / +0.003+0.001 / 0.0000.000 / +0.001−0.003 / −0.006+0.001 / −0.001
ETTh1+0.007 / +0.002+0.008 / +0.002+0.008 / +0.003+0.017 / +0.007+0.010 / +0.004
ETTh2+0.010 / +0.003+0.009 / +0.004+0.009 / +0.005+0.006 / +0.002+0.008 / +0.004
ETTm1−0.002 / −0.004−0.001 / +0.0010.000 / +0.001+0.011 / +0.008+0.002 / +0.001
ETTm2+0.004 / +0.002+0.007 / +0.002+0.006 / +0.001+0.007 / +0.001+0.006 / +0.002
Solar+0.010 / +0.015+0.010 / +0.011+0.018 / +0.015+0.018 / −0.001+0.014 / +0.010

GLNet is lower on MSE in 27 of 32 dataset–horizon cells (two ties, three losses) and on MAE in 22 of 32 (three ties, seven losses). The misses are concentrated on Traffic MAE, Electricity H=720, and ETTm1 H=96/192.

The tuning protocol uses validation selection: all GLNet configurations, including the per-dataset/horizon depths and lookbacks in Table 4, were selected on the validation split; the test split was used once. Baselines were re-run over the same lookback grid; xPatch additionally uses its official batch/learning-rate search. GLNet's architecture search space is larger than the baselines' published defaults.

The significance picture is mixed. Table 8 shows that the MSE differences over xPatch are not significant on ETTm1 (p=0.172p=0.172) or Electricity (p=0.319p=0.319); the MAE differences are not significant on Weather (p=0.543p=0.543), ETTh2 (p=0.131p=0.131), ETTm1 (p=0.151p=0.151), or Electricity (p=0.917p=0.917). On Traffic, xPatch has lower MAE (0.251 vs. 0.264), and SimpleTM has lower MSE (0.387 vs. 0.389). The manuscript's claim is "leading mean forecasting accuracy"; it does not claim GLNet is SOTA, and we will state these exceptions explicitly.

The inter-patch linear layer costs O(PN2C)O(PN^2C), with N≈L/SN\approx L/S. It is quadratic in the number of patches. Patching shortens the constant and effective sequence length; the inter-patch term stays quadratic, so GLNet and patch-level attention have the same asymptotic order. We will state this explicitly in Section 4.3 and Appendix A. The measured model cost is below; latency is normalized by channel count because one forward pass processes all variates.

Table R3. Model-only cost at H=336, batch 32, H100.

Dataset (H=336)ParamsFLOPsLatencyms / 1k channels
ETTh11.03M0.529 G1.53 ms218
ETTh21.03M0.529 G1.53 ms218
ETTm11.22M0.809 G1.39 ms199
ETTm21.46M1.051 G1.86 ms266
Weather1.18M1.905 G1.05 ms50
Electricity1.20M30.64 G6.05 ms19
Traffic2.35M252.07 G53.76 ms62
Solar1.43M15.06 G3.22 ms24

Batch 32, H100, 20 warmup + 100 timed iterations, no data loading. Raw latency grows with channel count; per-channel cost is lowest on Electricity and Solar and highest on the ETT sets.

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

This paper aims at the long-term time series forecasting problem, which demands the model capacity to capture long-range dependencies as well as computational efficiency. This work proposes the global-local network (GLNet), which adopts a dual-flow design (seasonal flow and trend flow) and a global-local design -- convolutional layers for local interactions and linear layers for global interactions. The extensive experiments showcase the competitive representative performance, and the further study demonstrates the computational efficiency of GLNet.

Critical strengths
  1. This paper proposes a simple but effective model architecture -- linear layers for global interactions and conv layers for local interactions -- for modeling time series, balancing the representative power and the computational cost.

  2. The experimental results are strong.

  3. The further analyses of the models are in-depth and comprehensive, including a ablation study, an efficiency analysis, and a sensitivity study on critical hyperparameters.

Critical weaknesses
  1. The writing of the method can be improved:

    • It is not very clear whether, for the post-patching tensors of shape C×N×DC \times N \times D, NN is the number of patches and DD is the number of feature channels?
      • It is mentioned on line 197 A depthwise $1D$ convolution with kernel size $k$ is applied to the feature dimension $N$''** while on line 204 **where W1W_1 and W2W_2 are linear weights acting on dimension DD'' (for pointwise linear layers).
      • Usually, pointwise linear layers mean acting on the feature dimension and shared by tokens.
    • Sec. 3.3 uses notations and variables different from Fig. 2, which make it a bit confusing. For example.
      • The input shape is RB×C×T\mathbb{R}^{B\times C \times T} in Sec. 3.3. Fig. 2 uses C×TC \times T while the CC here shall be (B×C)(B \times C). The reuse of CC makes it a bit confusing.
      • The post-patching variable in Sec 3.3 is R(B×C)×N×P\mathbb{R}^{(B \times C) \times N \times P} while Fig. 2 uses different notations.
  2. The statement (Line 194) on Linear for Global Sequence Mixing is problematic if they are ``real'' pointwise linear layers (i.e., NN is # patches and DD is # channels) The linear layers are shared by all patches, which means the mixing is within a patch instead of global mixing. It is more like a convolutional operation with a kernel size of patch size. However, this might be correct if the NN and DD have inverse meanings. But in this case, it is not accurate to call these linear layers pointwise linear layers. I expect the authors to clarify the notation and explain this statement further.

  3. The motivation of GLB* (the removal of activation) is not well explained or backed by empirical results in the ablation study.

  4. The authors claim that We identify the decomposition leakage problem in existing dual-stream methods and address it through a unified backbone design. However, in this case, both flows use the (nearly) same layer designs. Why does GLNet still need to construct a dual-flow design? The paper lacks the ablation study to support it.

Questions for authors

As listed in Weakness.

3 comments

1. Notation and dimensions

SymbolMeaning
BBbatch size
CCnumber of variates
TTlookback length
NNnumber of patches
PPpatch length
DDthe GLB's generic last-axis size (not a separate feature dimension)
B⋅CB\cdot Cmerged batch–variate dimension for channel independence

The input is X∈RB×C×T\mathbf{X}\in\mathbb{R}^{B\times C\times T}. For channel-independent processing we reshape it to (B⋅C)×T(B\cdot C)\times T, and patching gives Z∈R(B⋅C)×N×P\mathbf{Z}\in\mathbb{R}^{(B\cdot C)\times N\times P}. Figure 2 currently writes the input as C×TC\times T and reuses CC for the merged dimension; we will use B,C,T,N,PB,C,T,N,P consistently and write the merged dimension as B⋅CB\cdot C.

The GLB treats its last axis as the sequence axis and its second-to-last axis as the feature axis. In the intra-patch GLB the last axis is PP, so D=PD=P; in the inter-patch GLB the last axis is NN, so D=ND=N. The reviewer's reading that NN and DD swap roles across the two invocations is correct; we will state this explicitly.

2. What the linear and convolution axes mix

The linear layer is local in the intra-patch GLB and global in the inter-patch GLB; the convolution acts on the second-to-last axis.

  • Intra-patch GLB, input (B⋅C)×N×P(B\cdot C)\times N\times P: the linear layers act along the last axis PP, so they mix within each patch; the depthwise convolution acts along the second-to-last axis NN, sliding over adjacent patches.
  • Inter-patch GLB, input (B⋅C)×P×N(B\cdot C)\times P\times N after transpose: the linear layers act along the last axis NN, so they mix across patches; the convolution acts along the second-to-last axis PP, sliding over adjacent time steps within a patch.

The phrase "Linear for Global Sequence Mixing" is accurate only for the inter-patch invocation. In the intra-patch invocation the same linear layer is local with respect to the full lookback, as the reviewer notes; we will qualify the text.

We also agree that "pointwise linear" is wrong here. Our linear layers act densely along the last axis, not pointwise across channels. We will replace it with "dense linear along the last axis" (or "axis-wise linear") and reserve "pointwise" for channel mixing. This removes the apparent contradiction between the paper's statement that the convolution is "applied to the feature dimension NN" and that "W1W_1 and W2W_2 are linear weights acting on dimension DD."

3. GLB*: motivation and ablation

Adding GELU to GLB* raises the five-dataset average from 0.3074 to 0.3100 and hurts Weather most (0.2271 vs. 0.2181 MSE).

VariantETTh1ETTh2ETTm1ETTm2WeatherAvg
Full GLNet (seasonal GELU, GLB* activation-free)0.3901 / 0.41030.3157 / 0.36740.3550 / 0.37710.2580 / 0.31600.2181 / 0.26100.3074 / 0.3464
Trend GLB* + GELU0.3909 / 0.41070.3172 / 0.36800.3539 / 0.37700.2611 / 0.31960.2271 / 0.26920.3100 / 0.3489
GLB conv-only0.3917 / 0.41250.3145 / 0.36690.3544 / 0.37730.2607 / 0.31830.2245 / 0.26630.3092 / 0.3483

The conv-only control is 0.001 lower on ETTh2 but 0.002 higher on average; the full average remains best. The rationale is that the EMA trend component is smooth: removing the activation avoids aggressive nonlinear deformation, and the 1×11\times1 convolution on the singleton pseudo-spatial axis reduces to per-channel scaling. LayerNorm is retained because it prevents stacked GLB* layers from collapsing into a single affine map and provides a mild nonlinearity.

The submitted ablation did not isolate this choice: "replace GLB/GLB*" (0.274 average MSE vs. 0.265 for GLNet) changes both streams. The new activation ablation above does isolate it and supports activation-free GLB*. The linear-only/convolution-only results are in our response to reviewer Lkps; both components matter in the GLB.

We will stop describing GLB* as a low-pass filter: the convolution is a per-channel scalar and the dense linear map can represent any frequency response, so the only explicit low-pass stage is the EMA decomposition. The revised text will call GLB* an activation-free global trend operator and will present the activation ablation as the evidence for keeping it.

4. Why dual-flow if both flows use similar blocks?

Table 2 supports both branches.

DatasetFull MSEFull MAEw/o Trend MSEw/o Trend MAEw/o Seasonal MSEw/o Seasonal MAE
Weather0.2110.2480.2160.2540.2140.251
Traffic0.3890.2640.4080.2750.4110.273
Electricity0.1530.2470.1580.2500.1550.248
ETTh10.3860.4080.3940.4110.3950.420
Solar0.1850.2130.2120.2250.2120.222
Average0.2650.2760.2780.2830.2770.283

The flows share the operator family. Their instantiations differ. The Seasonal Flow receives a patched 2D representation and applies two GLB stacks (intra-patch on N×PN\times P, then inter-patch on P×NP\times N) with full activation. The Trend Flow receives a whole-series linear embedding and applies k2k_2 activation-free GLB* layers with a singleton convolution. The shared family keeps the branch outputs structurally compatible for linear fusion; the routing, activation, and depth provide specialization.

The single-branch controls in Table 2 (0.278 without the Trend Flow and 0.277 without the Seasonal Flow, vs. 0.265 for full GLNet) show that one branch with the same GLB family does not reproduce the gain on any of the five datasets, including Traffic (0.408/0.411 vs. 0.389). The new component ablation is consistent with seasonal conv/linear both mattering, while the trend flow's value comes from the whole-series linear embedding. This supports branch-specific specialization.

Thank you for the detailed rebuttal.

The authors have addressed some of my concerns, particularly regarding the notation and missing ablation studies. However,

  1. The new ablation results do not fully justify the complete GLNet design (seasonal GELU and activation-free GLB*). The simplified variants achieve very similar performance. In particular, the GLB conv-only variant differs from the full model by only approximately 0.002 in average MSE and MAE. Without standard deviations or confidence intervals, it is difficult to determine whether these improvements are statistically significant or simply within the noise level.

  2. I also agree with Reviewer Lkps that, once the low-pass filtering motivation is removed, the technical contribution largely reduces to replacing xPatch's seasonal backbone with a standard linear and depthwise-convolutional mixer block without strong theoretical motivation. The performance improvements over xPatch are also relatively modest and do not sufficiently establish the benefit of the proposed architecture.

  3. Furthermore, the original theoretical claims that GLB* acts as a "strict low-pass filter" and provides a "complete defense against leakage" are not supported, as acknowledged by the authors.

Overall, I find this work interesting and potentially beneficial to the community. I appreciate the authors' efforts to address the reviewers' concerns. However, I believe that the remaining issues regarding the architectural justification, novelty, and theoretical motivation require further investigation.

Therefore, I will maintain my original score.

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

GLNet is a channel-independent forecaster built on EMA trend–seasonal decomposition and RevIN.

  • Seasonal flow. The seasonal part is patched and processed by stacked Global-Local Blocks (GLBs). Each GLB applies a linear layer along the last dimension followed by a depthwise convolution along the other dimension. The blocks are applied first within patches and then across patches.
  • Trend flow. The trend part is linearly embedded and passed through activation-free GLB* layers followed by LayerNorm.
  • Fusion. The outputs of the two flows are concatenated and mapped to the horizon by a linear layer.

The paper motivates this design with "decomposition leakage". It reports the best average MSE/MAE on 7 of 8 LTSF benchmarks with searched lookbacks, the best weighted average on M4, and lower memory use and faster inference than the baselines.

Critical strengths
  1. Thorough experiments. The paper reruns 12 baselines with lookback search, reports three seeds with pooled standard deviations and ANOVA tests, and includes M4 short-term forecasting, a RevIN ablation, and sensitivity studies on patch length, kernel size, depth, and the EMA factor.
  2. Consistent, if small, gains. GLNet is at or near the top on most datasets, with low memory use on the smaller benchmarks.
  3. Clear and reproducible. The method is easy to follow and to reimplement, and the per-dataset configurations are listed in Table 4.
Critical weaknesses
  1. The contribution is incremental over xPatch.

    • Most of the design is inherited. xPatch already uses EMA decomposition with a patch-based nonlinear stream for the seasonal part and a linear stream for the trend, and GLNet reuses xPatch's training scheme (Appendix D). The new element is the GLB, which is a standard mixer block: linear mixing along one axis followed by a depthwise convolution along the other.
    • The closest prior work is missing. Intra-/inter-patch mixing and depthwise-convolution patch models are known, e.g., TSMixer (Ekambaram et al., KDD 2023) and ModernTCN (ICLR 2024). They are neither discussed nor compared. TimeMixer++ and DUET are cited in the introduction as strong lightweight models but are also absent from the experiments.
  2. The leakage motivation is never tested, and the argument for GLB* does not hold.

    • Leakage is not obviously a problem. EMA is a fixed linear split, and the two components sum back to the input. Since both flows are trained jointly and fused linearly, information that "leaks" into the other component is not lost. The paper never shows that leakage hurts any model, nor that GLNet reduces its effect.
    • GLB* is not a low-pass filter. In the trend flow, the convolution acts on a singleton dimension, so it reduces to a per-channel scalar. GLB* is therefore a linear map plus LayerNorm, and a linear embedding of the whole series can pass any frequency. Any smoothing comes from the EMA itself, which does not support the "strict low-pass filter" or "complete defense against leakage" claims (Section 3.5).
    • The core design is never ablated component-wise. No experiment removes the convolution or the linear layer inside the GLB, or uses the full GLB (with activation) in the trend flow. The kernel-size study shows almost no effect between K = 3 and K = 31 (Table 7), so the "local" half of the global–local block remains unverified.
  3. The gains over xPatch are small and often not significant.

    • Small margins. The MSE gap to xPatch is 0.001–0.014 per dataset (Table 1). This is comparable to the variation caused by depth choices alone (e.g., 0.388–0.398 on Traffic in Figure 5).
    • Weak significance by the paper's own tests. In Table 8, 6 of the 16 comparisons with xPatch are not significant (both metrics on Electricity and ETTm1, MAE on Weather and ETTh2), and xPatch is significantly better on Traffic MAE (0.251 vs. 0.264).
    • Ties are counted as wins. The "7 of 8 best" count includes ties: MSE on ETTm1 with PDF and MAE on Electricity with xPatch. On Traffic, GLNet ranks fourth in MSE.
    • The tuning budget is unclear. GLNet tunes depth and lookback separately for each dataset and horizon (Table 4). The paper does not say whether this selection used validation or test data, or whether the baselines received a comparable tuning budget.
  4. The efficiency claims are not supported by the measurements.

    • The timings are overhead-dominated. On ETTm2 (Figure 3), most models, including DLinear (134.0 ms), take between about 126 and 138 ms/iter, so the measurement reflects pipeline overhead rather than model cost.
    • GLNet is not the fastest. On Traffic, GLNet (507.1 ms) is slower than DLinear, xPatch, iTransformer, SimpleTM, and PDF.
    • GLNet does not use the least memory. On ETTm2, iTransformer, CARD, and DLinear all use less memory than GLNet (13.6, 14.4, and 16.0 MB vs. 26.8 MB).
    • No asymptotic advantage over patch Transformers. The inter-patch linear layer costs O(PN2C)O(PN^2C) (Appendix B), which is the same order as patch-level attention in PatchTST.
    • Consequence. The abstract's claim of "faster inference speed and lower memory consumption compared with existing approaches" does not hold as stated.
  5. Several claims contradict the paper's own tables.

    • RevIN robustness. Appendix I claims that GLNet has "intrinsic robustness against non-stationarity" that distinguishes it from other baselines. Yet without RevIN, GLNet's ETTh2 MSE rises from 0.299 to 0.629, compared with 0.458 for xPatch* and 0.343 for CARD*. On ETTm2, GLNet* (0.270) is also worse than CARD* (0.248).
    • Traffic MAE at H = 720. Figure 3 places xPatch and iTransformer clearly above GLNet in Traffic MAE at H = 720, but Table 6 reports 0.276 for xPatch, 0.274 for iTransformer, and 0.276 for GLNet.
    • PatchTST on M4. In Table 11, PatchTST's quarterly MASE (0.866) is inconsistent with its SMAPE and with every other model's MASE (1.17–1.38).
Questions for authors
  1. Were the lookbacks and depths in Table 4 selected on the validation set or the test set? What search budget did the baselines receive beyond lookback?
  2. Please report ablations that remove only the convolution or only the linear layer inside the GLB, and a variant that uses the full GLB (with activation) in the trend flow. Can you show directly that leakage hurts a baseline and that GLNet reduces this effect?
  3. Please report model-only latency (excluding data loading), FLOPs, and parameter counts. Which settings were used for Figure 3, and why does it differ from Table 6 for Traffic MAE at H = 720?
  4. How does GLNet compare with TSMixer (Ekambaram et al., 2023), ModernTCN, TimeMixer++, and DUET under the same protocol?
4 comments

Q1: Tuning protocol, gains, ties, and significance

The gains are small (MSE gap 0.001–0.014), 6/16 comparisons with xPatch are not significant, two of the "7 out of 8" entries are ties, and tuning is validation-selected.

DatasetΔMSE (G−X)ΔMAE (G−X)MSE pMAE p
Weather−0.0040.0000.0010.543
Traffic−0.007+0.0130.0000.000
Electricity−0.0010.0000.3190.917
ETTh1−0.009−0.0040.0000.000
ETTh2−0.008−0.0040.0210.131
ETTm1−0.002−0.0010.1720.151
ETTm2−0.006−0.0020.0000.000
Solar−0.014−0.0110.0000.002

Negative Δ means GLNet is lower. The p-values are the Type II ANOVA tests from Table 8. Six of the 16 GLNet–xPatch comparisons are not significant at 0.05: ETTm1 MSE, Electricity MSE, Weather MAE, ETTh2 MAE, ETTm1 MAE, and Electricity MAE. On Traffic, xPatch is significantly better on MAE. The remaining nine favor GLNet at the 0.05 level, including Solar on both metrics.

The MSE gap is 0.001–0.014 per dataset, comparable to the variation caused by depth alone (0.388–0.398 on Traffic in Figure 5). We will not describe these as large. The paper's exact sentence is "securing the lowest mean MSE on 7 out of 8 datasets and the lowest mean MAE on 7 out of 8 datasets." Two of these are ties: ETTm1 MSE (0.343, tied with PDF) and Electricity MAE (0.247, tied with xPatch). On Traffic, GLNet ranks fourth in MSE (iTransformer 0.384, CARD 0.385, SimpleTM 0.387, GLNet 0.389), and xPatch has the best MAE (0.251 vs. 0.264). The paper does not claim GLNet is SOTA; the word SOTA appears only for the baselines and for "the previous SOTA xPatch." We will keep the "lowest mean ... on 7 out of 8" claim, state the ties and ranks explicitly, and avoid counting ties as outright wins. On Traffic MAE, xPatch is significantly better (p=0.000p=0.000).

All GLNet configurations, including the per-dataset/horizon depths and lookbacks in Table 4, were selected on the validation split; the test split was used once. The search space covers lookback, depth, dropout, and learning rate. Baselines were re-run over the same lookback grid; beyond lookback, xPatch uses its official batch/learning-rate search, and the other baselines use their published/default hyperparameters. GLNet's architecture search space is larger than the baselines' published defaults, so the comparison is not budget-identical.

Q2: Leakage, GLB*, and component-wise ablations

Leakage is not information loss. The controlled diagnostic below gives GLNet a lower average LSS, winning 10 of 15 dataset–horizon cells; Table R1 lists the five cells where xPatch is lower. GLB* is not a low-pass filter, and the new component/activation ablations show that both GLB operators contribute while activating GLB* hurts.

Table R1. Seasonal-to-trend LSS (%, lower is better) at λ=0.5\lambda=0.5; G/X = native GLNet/native xPatch; seed 2021, full test set, native configuration.

DatasetH=96 (G / X)H=192 (G / X)H=336 (G / X)
ETTh112.72 / 9.679.83 / 6.094.60 / 2.58
ETTh21.95 / 0.150.61 / 0.24-0.01 / 0.25
ETTm118.36 / 29.348.90 / 18.818.33 / 9.38
ETTm24.91 / 5.542.20 / 3.292.52 / 4.36
Weather2.87 / 10.461.76 / 6.342.11 / 5.21
Average8.16 / 11.034.66 / 6.953.51 / 4.35
GLNet wins3/53/54/5
Average reduction26%33%19%

GLNet's average LSS is lower at all three horizons and lower on 10/15 comparisons. The effect is not uniform: xPatch is better on ETTh1 at all three horizons and on ETTh2 at H=96/192. Reverse routing degrades both models; an xPatch-style reimplementation is mixed.

EMA is a fixed linear split and the two components sum back to the input. With joint training and linear fusion, information is not destroyed. We no longer describe leakage as information loss or claim a complete defense. The narrower issue is a frequency-role mismatch: high-frequency residuals in the trend component can bias a smooth trend extractor, and low-frequency drift in the seasonal component can be absorbed by a high-capacity patch model.

To measure the forecasting impact, we use an information-preserving reassignment XSλ=(1−λ)XS,XTλ=XT+λXS,X_S^\lambda=(1-\lambda)X_S,\qquad X_T^\lambda=X_T+\lambda X_S, which keeps XSλ+XTλ=XS+XT=XX_S^\lambda+X_T^\lambda=X_S+X_T=X. Each model is trained only on the clean decomposition (λ=0\lambda=0), frozen, and evaluated on the same checkpoint under clean and routed inputs. We report

\frac{\operatorname{MSE}_m(X_S^\lambda,X_T^\lambda)-\operatorname{MSE}_m(X_S,X_T)} {\operatorname{MSE}_m(X_S,X_T)}.$$ GLB* is not a low-pass filter. In the trend flow the convolution operates on a singleton axis, so it is a per-channel scalar. With the activation removed, GLB* is a residual LayerNorm followed by two dense linear maps. A dense linear map can realize any frequency response, including high-pass; a 1×1 convolution and the removal of activations impose no cutoff. The only explicit low-pass stage is EMA. We will replace "strict low-pass filter" and "complete defense against leakage" in Section 3.5 with "activation-free global trend operator," and remove the Section 4.2 attribution of the attention variant's degradation to a lost low-pass property. The component and activation ablations are below. Full GLNet has the best five-dataset average, and adding GELU to GLB* hurts that average. | Variant | ETTh1 | ETTh2 | ETTm1 | ETTm2 | Weather | Avg | |---|---:|---:|---:|---:|---:|---:| | Full GLNet | 0.3901 / 0.4103 | 0.3157 / 0.3674 | 0.3550 / 0.3771 | 0.2580 / 0.3160 | 0.2181 / 0.2610 | **0.3074 / 0.3464** | | GLB linear-only | 0.3922 / 0.4129 | 0.3176 / 0.3703 | 0.3651 / 0.3827 | 0.2657 / 0.3204 | 0.2228 / 0.2648 | 0.3127 / 0.3502 | | GLB conv-only | 0.3917 / 0.4125 | 0.3145 / 0.3669 | 0.3544 / 0.3773 | 0.2607 / 0.3183 | 0.2245 / 0.2663 | 0.3092 / 0.3483 | | Trend GLB* + GELU | 0.3909 / 0.4107 | 0.3172 / 0.3680 | 0.3539 / 0.3770 | 0.2611 / 0.3196 | 0.2271 / 0.2692 | 0.3100 / 0.3489 | Across the five datasets the full configuration has the best average (0.3074 vs. 0.3092–0.3127). Linear-only is worse on every dataset; conv-only is worse on ETTh1, ETTm1, ETTm2 and Weather and 0.001 lower on ETTh2. Adding GELU to GLB* raises the average to 0.3100 and hurts Weather most (0.2271 vs. 0.2181 MSE). Cell-level differences are 0.001–0.002. Removing only the trend-flow convolution is neutral or slightly better on ETTh1 (0.3866/0.4083 vs. 0.3901/0.4103), consistent with the reviewer's observation that this convolution is a per-channel scalar. This pattern is consistent with the seasonal convolution being the meaningful local operator; we will simplify the trend operator and no longer present it as a filter. The linear-only and conv-only variants use 1.03M/0.57M parameters and 0.525/0.257 GFLOPs on ETTh1, respectively, versus 1.03M parameters and 0.529 GFLOPs for full GLNet. The two flows share the operator family but not the instantiation: the Seasonal Flow uses patched 2D inputs and two GLB stacks with full activation; the Trend Flow uses a whole-series embedding and activation-free GLB* layers. Table 2 supports both branches: removing the Trend or Seasonal Flow raises average MSE from 0.265 to 0.278/0.277 (Traffic: 0.389 to 0.408/0.411).

Q3: Efficiency and the Figure 3/Table 6 discrepancy

Figure 3 is an end-to-end measurement of the inference pipeline, including data loading, at H=720 and batch 32. The reviewer is right that on Traffic GLNet (507.1 ms) is slower than DLinear (433.4), xPatch (438.6), iTransformer (466.6), SimpleTM (468.3), and PDF (502.8), and that on ETTm2 its 26.8 MB is higher than iTransformer (13.6), CARD (14.4), and DLinear (16.0). The caption and text should say this directly; "most Pareto-efficient" should be scoped to the ETTm2 trade-off shown, not to every dataset.

To separate kernel cost from pipeline overhead, we measured model-only forward latency with CUDA events on a H100 (batch 32, 20 warmup + 100 timed iterations, no data loading), plus FLOPs and parameters. The last column normalizes latency by channel count, since a single forward pass processes all variates.

Dataset (H=336)ParamsFLOPsLatencyms / 1k channels
ETTh11.03M0.529 G1.53 ms218
ETTh21.03M0.529 G1.53 ms218
ETTm11.22M0.809 G1.39 ms199
ETTm21.46M1.051 G1.86 ms266
Weather1.18M1.905 G1.05 ms50
Electricity1.20M30.64 G6.05 ms19
Traffic2.35M252.07 G53.76 ms62
Solar1.43M15.06 G3.22 ms24

The raw latency rises with 862 channels on Traffic, while the per-channel cost is 62 ms per 1k channels, lower than the ETT datasets. All entries are far below the 126–138 ms/iter in Figure 3; the difference is the data-loading and pipeline overhead included in the figure.

Figure 3 was produced by a separate profiling pass at H=720 and batch 32. Its MAE labels for GLNet, xPatch, and SimpleTM are 0.269/0.271/0.292 on Traffic H=720, while Table 6 reports 0.276/0.276/0.291; the other models match. This is consistent with the profiling pass using different checkpoints for those three models.

The inter-patch linear layer is O(PN2C)O(PN^2C) with N≈L/SN\approx L/S: quadratic in the number of patches. Patching reduces the constant and effective sequence length; the inter-patch term stays quadratic, so GLNet and patch-level attention have the same asymptotic order. We will state this explicitly in Section 4.3 and Appendix A.

Q4: TSMixer, ModernTCN, TimeMixer++, and DUET

These methods are relevant and their absence is a gap. We will add a discussion in Related Work: TSMixer mixes along time and feature axes with MLPs; ModernTCN uses large-kernel convolutional token mixing; TimeMixer++ uses multi-scale decomposition and mixing; DUET uses dual clustering. GLNet is channel-independent and uses a unified GLB/GLB* family over EMA-decomposed streams.

Other factual corrections

The statement in Appendix I that GLNet "exhibits intrinsic robustness against non-stationarity" and "maintains highly competitive performance even when RevIN is removed, distinguishing it from other baselines" is not supported by Table 9. Without RevIN, GLNet's ETTh2 MSE rises to 0.629, compared with 0.458 for xPatch* and 0.343 for CARD*; on ETTm2, GLNet* (0.270) is worse than CARD* (0.248). The isolated ETTm1/Weather cases do not support a general robustness claim. We will remove the sentence and state that RevIN remains necessary for GLNet on strongly non-stationary datasets.

The Quarterly MASE 0.866 and OWA 0.824 in Table 11 are transcription errors. Our PatchTST runs give MASE [1.207, 1.197, 1.223] (mean 1.209) and OWA [0.906, 0.899, 0.917] (mean 0.907); the GLNet entries in the same file match Table 11 exactly, confirming the source. We will correct both entries and the best/second-best highlighting.

Thank you for the detailed and remarkably candid rebuttal, as well as the additional component-wise ablations, LSS diagnostics, and model-only latency measurements. I genuinely appreciate your transparency in verifying the mathematical properties of GLB*, auditing the table and figure discrepancies, and clarifying the hyperparameter search protocol. However, after carefully weighing these updates against ICLR's acceptance bar, I have decided to maintain my original score of 2 for the following reasons:

First, the rebuttal confirms that several central claims of the submitted manuscript do not hold and must be retracted—including the core theoretical framing of GLB* as a "strict low-pass filter" and "complete defense against leakage," the broad inference speed and memory superiority claims, and the RevIN-free robustness claim. Indeed, removing the singleton-axis convolution in GLB* slightly improves ETTh1 (0.3866 vs. 0.3901 MSE), and the new LSS diagnostic remains mixed, with xPatch outperforming GLNet across all horizons on ETTh1 and two horizons on ETTh2. Stripping away these pillars alters the paper's fundamental motivation and requires a ground-up rewrite rather than minor camera-ready revisions.

Second, once the filter framing is set aside, the technical contribution reduces to replacing xPatch's seasonal backbone with a standard linear and depthwise-convolutional mixer block, yet key empirical comparisons remain missing. Despite my request for head-to-head evaluations under the same protocol, no experimental results were added for the closest prior mixer and convolutional architectures (TSMixer, ModernTCN, TimeMixer++, and DUET), leaving a critical positioning gap that text discussion in Related Work alone cannot resolve. Similarly, the new CUDA-event latency table reports GLNet in isolation without corresponding model-only measurements for the baselines.

Third, the empirical edge over xPatch is too narrow and confounded by tuning asymmetry to justify a purely empirical acceptance at ICLR. As clarified in Q1, GLNet searched a larger architecture and hyperparameter space (including per-configuration depth and dropout) than the baselines, making the comparison non-budget-identical. Given that the MSE gains over xPatch are only 0.001 to 0.014 (with 6 of 16 comparisons non-significant and xPatch winning Traffic MAE), and that the conv-only ablation in Q2 comes within 0.0018 average MSE of full GLNet (0.3092 vs. 0.3074, even edging out full GLNet on ETTh2 and ETTm1 at roughly half the parameters and FLOPs), it remains unclear how much of the reported gain stems from the proposed global-local design versus the expanded tuning budget.

While I commend the rigor and honesty of your response, the scope of conceptual reframing and budget-matched re-evaluation required goes beyond a rebuttal revision cycle. I encourage the authors to incorporate these simplifications and fair baseline comparisons into a reworked future submission.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.