Skip to content

Bridging Time Series and Language via Query-Adaptive Multi-Granularity Routing for Temporal Reasoning

Conference: EMNLP 2026
Paper: https://aclanthology.org/2026.emnlp-main.1397/
Code: https://github.com/hyuna0926/TiMER_paper
Area: LLM Reasoning
Keywords: Time-Series Question Answering, Multi-Granularity Encoding, Query-Adaptive Routing, Cross-Granularity Interaction, Time-to-Language Alignment

TL;DR

Addressing the mismatch between static time-series representations and query-dependent temporal evidence scopes in Time-Series Question Answering (TSQA), TiMER freezes both the LLM and the multi-granularity time encoder, employing a Query-Adaptive Granularity Router (QGR) and a Granularity-aware Temporal Experts module (GTE) to dynamically synthesize local, global, and cross-granularity features, achieving 81.02% overall accuracy on TSAQA with only 0.08% external trainable parameters.

Background & Motivation

Time-series data, prevalent across healthcare, industrial operations, environmental sensing, and financial systems, are characterized by complex temporal dynamics spanning high-frequency local fluctuations, periodic seasonal patterns, and long-term evolutionary trends. With the remarkable reasoning and instruction-following proficiencies demonstrated by modern Large Language Models (LLMs), time-series analysis is undergoing a fundamental paradigm shift from conventional single-purpose predictive tasks (e.g., forecasting, imputation, anomaly detection) toward interactive, conversational Time-Series Question Answering (TSQA). In real-world scenarios, analytical inquiries increasingly require rich semantic deduction, state diagnosis, causal attribution, and granular evidence localization expressed in free-form natural language.

However, bridging continuous numeric temporal sequences with discrete linguistic token representations presents a severe structural dilemma: the requisite temporal granularity and contextual scope vary drastically depending on the analytical intent of individual queries. For instance, answering "When did the transient voltage spike occur?" demands focusing on fine-grained residual variations, whereas identifying overall trend shifts or seasonal transitions requires macro-level global sequence dynamics. Questions involving data transformations or temporal patch ordering fundamentally require modeling cross-scale inter-granularity interactions. Existing time-series LLM architectures typically compress signals into static, pre-constructed token embeddings or rely on coarse text summaries, forcing uniform representations onto heterogeneous questions and inevitably losing critical local nuances or global trend fidelity.

Moreover, adapting LLMs to time-series tasks via full-parameter fine-tuning or even LoRA-based instruction tuning incurs heavy computational overhead and often compromises the model's intrinsic general language understanding and reasoning versatility. To resolve this tension, the authors advocate for query-conditioned temporal representation construction at the feature extraction phase rather than relying on a passive post-hoc fusion. Core idea: keep both the pretrained LLM and the multi-granularity time encoder frozen, dynamically predict routing coefficients across local, global, and cross-granularity experts via a Query-Adaptive Granularity Router (QGR), and align the modulated temporal tokens directly into the LLM input space using a lightweight Time-to-Language Alignment (TLA) module.

Method

Overall Architecture

TiMER adopts an efficient dual-frozen modular architecture (Frozen LLM + Frozen MTE) where trainable parameters constitute merely 0.08% of the total network. The inference pipeline flows through four sequential stages: First, a pretrained Multi-Granularity Time Encoder (MTE) decouples raw time-series inputs into fine-grained and coarse-grained representations. Second, the Query-Adaptive Granularity Router (QGR) extracts semantic intent from the natural language question via cross-attention with the time-series representations to estimate dynamic routing weights. Third, Granularity-aware Temporal Experts (GTE) process the decoupled streams through specialized local, global, and cross-granularity networks, performing adaptive average pooling and routing modulation. Finally, Time-to-Language Alignment (TLA) projects the aggregated temporal features into the LLM input embedding space using learnable alignment tokens, enabling the frozen LLM to generate the final response autoregressively.

%%{init: {'flowchart': {'rankSpacing': 24, 'nodeSpacing': 28, 'padding': 6, 'wrappingWidth': 400}}}%%
flowchart TD
    A["Time-series input X and natural language query q"] --> B["Multi-Granularity Time Encoder MTE<br/>Trend-residual decomposition + dual-stream Transformer"]
    B --> C["Query-Adaptive Granularity Router QGR<br/>Cross-attention between query intent and multi-granularity states"]
    C --> D["Granularity-aware Temporal Experts GTE<br/>Local/Global/Cross experts + adaptive pooling & routing modulation"]
    D --> E["Time-to-Language Alignment TLA<br/>Learnable alignment tokens map temporal hints into LLM space"]
    E --> F["Autoregressive answer generation a"]

Key Designs

1. Multi-Granularity Time Encoder (MTE): Addressing single-scale representation bottlenecks
Standard patching strategies with uniform token lengths struggle to balance transient anomaly sensitivity against long-range trend coherence. MTE (built upon the Granularity Fusion Transformer and frozen after self-supervised pretraining) first applies RevIN normalization over valid timesteps of a variable-length series \(X_i\), and decomposes it via moving average into a coarse trend component \(\tau = \text{MA}(\hat{x})\) and a fine residual component \(r = \hat{x} - \tau\). The residual stream undergo FFT-based period estimation (excluding the zero-frequency DC component) to identify dominant periodicities, reshape into 2D temporal maps, and upsample via convolutions to retain local high-resolution patterns, while \(\tau\) is interpolated to match temporal resolution. Separate Transformer encoders with short and long patch configurations then project both components into decoupled token sequences: $\(H_i^f = \text{Enc}_f(E_i^f) \in \mathbb{R}^{L_i^f \times d_{\text{MTE}}}, \quad H_i^c = \text{Enc}_c(E_i^c) \in \mathbb{R}^{L_i^c \times d_{\text{MTE}}}\)$ This physical decomposition provides the foundational substrate for selective temporal retrieval conditioned on query requirements.

2. Query-Adaptive Granularity Router (QGR): Overcoming static query-agnostic representation extraction
Because distinct TSQA queries demand fundamentally different temporal perspectives, fixed representation fusion leads to severe information mismatch. QGR passes the natural language question \(q_i\) through the LLM, extracts the final hidden state of the terminal token, and projects it into the MTE dimension to obtain the query embedding \(z_i^q \in \mathbb{R}^{d_{\text{MTE}}}\). Next, \(z_i^q\) acts as an attention query against fine-grained tokens \(H_i^f\) and coarse-grained tokens \(H_i^c\) to produce granularity-specific context vectors \(c_i^f\) and \(c_i^c\): $\(c_i^{(\cdot)} = \text{Softmax}\left(\frac{Q_i^{(\cdot)} (K_i^{(\cdot)})^\top}{\sqrt{d_k}}\right) V_i^{(\cdot)}\)$ Concatenating the query vector with both summaries forms the comprehensive routing clue \(r_i = [z_i^q; c_i^f; c_i^c]\), which is fed into an MLP with Softmax activation to generate normalized routing probabilities across experts: $\(p_i = \text{Softmax}(\text{MLP}(r_i)) = (p_i^{loc}, p_i^{glob}, p_i^{cross})\)$ This guarantees that expert weighting directly reflects both the linguistic intent and the actual temporal signal properties.

3. Granularity-aware Temporal Experts (GTE): Preserving multi-scale sequence topology under adaptive aggregation
To transform routing weights into query-conditioned temporal evidence, GTE maintains three distinct expert sub-networks: a local expert \(T_{loc}\) (Self-Attention + FFN modeling local variations from \(H_i^f\)), a global expert \(T_{glob}\) (Self-Attention + FFN modeling macro trends from \(H_i^c\)), and a cross-granularity expert \(C_{cross}\) (Cross-Attention between \(H_i^f\) as query and \(H_i^c\) as key-value). Rather than collapsing full sequences into single average vectors, GTE applies adaptive average pooling to compress expert outputs into compact sequence blocks \(S_i^{loc} \in \mathbb{R}^{n_{loc} \times d_{\text{MTE}}}\), \(S_i^{glob} \in \mathbb{R}^{n_{glob} \times d_{\text{MTE}}}\), and \(S_i^{cross} \in \mathbb{R}^{n_{cross} \times d_{\text{MTE}}}\). Each block is scaled by its corresponding routing scalar (e.g., \(\bar{S}_i^{loc} = p_i^{loc} S_i^{loc}\)), while a global routed summary \(z_i^{route} = \text{Proj}(\sum_e p_i^e z_i^e)\) is appended, yielding the structured temporal representation: $\(T_i^{time} = [\bar{S}_i^{loc}; \bar{S}_i^{glob}; \bar{S}_i^{cross}; z_i^{route}] \in \mathbb{R}^{N_{time} \times d_{\text{MTE}}}\)$ With default hyperparameters \((n_{loc}, n_{glob}, n_{cross}) = (8, 4, 8)\), \(N_{time}=21\), preserving internal temporal ordering while compressing computational footprint.

4. Time-to-Language Alignment (TLA): Bridging numerical latent representations to LLM embedding spaces
To project the numerical temporal tensor into the linguistic space of the frozen LLM, TLA employs \(L_{align}=25\) learnable alignment tokens \(I_{align} \in \mathbb{R}^{L_{align} \times d_{\text{LLM}}}\). The query representation \(H_i^q\) and \(I_{align}\) are concatenated and processed through self-attention, yielding query-aware alignment tokens \(I_i^*\). These tokens then query the aggregated temporal representation \(T_i^{time}\) via cross-attention: $\(O_i^{time} = \text{CrossAttn}(I_i^*, T_i^{time})\)$ The resulting representation is projected to the LLM hidden dimension to form language-aligned time tokens \(Z_i \in \mathbb{R}^{L_{align} \times d_{\text{LLM}}}\), which are framed by delimiter tokens <signal_start> Z_i <signal_end> {query} and passed into the frozen LLM for autoregressive response generation.

Loss & Training

During TSQA training, the LLM parameters \(\Theta\) and MTE parameters remain completely frozen; only parameters \(\phi\) in QGR, GTE, and TLA are updated. The primary training objective is causal language modeling cross-entropy evaluated strictly over the ground-truth answer tokens \(a_i = [a_{i,1}, \dots, a_{i,K_i}]\): $\(\mathcal{L}_{align}(\phi) = -\frac{1}{K_i} \sum_{k=1}^{K_i} \log p_{\Theta}(a_{i,k} \mid \tilde{H}_i^{in}(\phi), a_{i,<k})\)$ To prevent routing collapse—where the router degenerates into selecting a single expert regardless of input—a balance regularization loss encourages the batch-averaged expert routing distribution to match a uniform distribution: $\(\mathcal{L}_{bal} = \frac{1}{N_{exp}} \sum_{e=1}^{N_{exp}} \left( \frac{1}{B} \sum_{b=1}^B p_{b,e} - \frac{1}{N_{exp}} \right)^2\)$ The combined objective is \(\mathcal{L}_{total} = \mathcal{L}_{align} + \lambda_{bal} \mathcal{L}_{bal}\) with \(\lambda_{bal} = 10^{-3}\). Optimization runs on a single NVIDIA H200 GPU in mixed-precision BF16, with AdamW, batch size 8 (0.6B) or 4 (8B), gradient accumulation of 4, and learning rates of \(1\times 10^{-4}\) (0.6B) and \(5\times 10^{-5}\) (8B).

Key Experimental Results

Main Results

Evaluation is conducted on the large-scale TSAQA benchmark comprising 210,000 QA pairs across 13 domains, 6 task categories (Anomaly Detection A.D, Classification CLS, Characterization, Comparison, Data Transformation, Temporal Relationship), and 3 question formats (True/False TF, Multiple-Choice MC, Puzzling PZ).

Model Family Model Name Backbone Size A.D (MC) CLS (MC) Char. (TF) Char. (MC) Comp. (TF) Comp. (MC) Trans. (TF) Trans. (MC) Rel. (TF) Rel. (MC) Rel. (PZ) Overall (%)
Proprietary LLMs GPT-4.1 - 55.85 50.38 92.97 89.36 83.57 76.99 54.36 51.13 65.90 79.09 45.77 62.82
Proprietary LLMs GPT-4o - 54.32 47.20 88.15 84.15 78.61 69.07 60.66 53.24 62.25 75.58 45.61 60.73
Proprietary LLMs Claude-3.5-Sonnet - 51.27 41.23 74.39 78.45 66.59 74.14 65.79 57.07 82.05 82.15 54.56 61.19
Proprietary LLMs Gemini-2.5-Flash - 52.08 49.07 85.48 81.08 77.79 72.21 63.62 60.17 75.05 84.49 60.84 65.08
Open-weight LLMs LLaMA-3.3 70B 54.23 55.78 76.76 74.17 58.57 55.35 52.40 39.16 51.56 59.97 36.04 53.35
Open-weight LLMs Qwen-2.5 72B 53.73 49.15 86.21 79.61 74.77 60.69 60.86 34.06 57.05 39.11 36.98 54.53
Open-weight LLMs Qwen-3 8B 50.60 50.52 77.35 66.87 71.04 63.21 52.43 34.46 65.22 67.14 21.93 51.04
Open-weight LLMs Qwen-3 0.6B 50.40 35.83 62.00 48.78 58.03 37.51 49.03 23.62 51.99 37.33 13.38 39.06
Time-Series LLMs ChatTime 7B 54.68 35.10 47.49 32.40 45.53 40.56 49.50 40.56 47.81 26.30 27.70 39.94
Time-Series LLMs ITFormer (Zero-shot) 7B 49.12 52.95 65.20 54.99 62.17 47.30 50.57 25.32 48.74 24.72 22.01 44.11
Time-Series LLMs ITFormer† (Fine-tuned) 7B 50.22 56.57 85.78 71.14 79.32 59.21 51.10 24.92 51.12 25.64 28.74 50.93
Proposed TiMER-0.6B 0.6B 85.90 93.82 89.88 74.21 79.93 62.03 85.64 79.42 86.72 80.01 58.75 78.45
Proposed TiMER-8B 8B 86.00 92.73 90.28 81.65 85.30 75.71 87.24 81.99 88.67 83.72 59.85 81.02

Ablation Study

Extensive ablation experiments based on the TiMER-0.6B backbone evaluate architectural component necessity, inference routing perturbations, and training/inference efficiency relative to standard LoRA instruction tuning.

Table 1: Stepwise Component Ablation (TSAQA Overall Accuracy) | Setting | MTE | GTE | QGR | TLA | Overall Accuracy (%) | Remarks | |---|---|---|---|---|---|---| | (a) | ✓ | | | | 52.59 | Raw decoupled MTE features linearly projected to LLM | | (b) | ✓ | ✓ | | | 56.09 | Multi-expert modeling added without query-aware routing (+3.50%) | | (c) | ✓ | ✓ | ✓ | | 58.96 | Router added but without cross-attention TLA alignment (+2.87%) | | (d) | ✓ | | | ✓ | 71.25 | Direct TLA alignment bypassing GTE expert aggregation (+18.66%) | | (e) | ✓ | ✓ | | ✓ | 74.60 | Multi-expert + TLA without query routing modulation (+3.35%) | | Full (Ours) | ✓ | ✓ | ✓ | ✓ | 78.45 | Complete query-adaptive multi-granularity routing pipeline (+3.85%) |

Table 2: Diagnostic Inference Routing Interventions | Routing Strategy at Inference | Overall Accuracy (%) | Impact vs Ours | Analysis | |---|---|---|---| | TiMER (Query-Conditioned) | 78.45 | Baseline | Full instance-level query-conditioned adaptive routing | | Query-shuffled Routing | 49.71 | ↓ 28.74% | Router receives query from an unrelated sample; intent mismatch | | Task-average Routing | 49.43 | ↓ 29.02% | Fixed average routing weights per task; ignores sample subtleties | | Uniform Routing | 48.72 | ↓ 29.73% | Equal weighting across all three experts (\(p^{loc}=p^{glob}=p^{cross}=1/3\)) |

Table 3: LoRA Instruction Tuning vs TiMER Alignment Cost and Performance | Backbone Model | Adaptation Scheme | Overall Accuracy (%) | 10 Epochs Training Time (h) | Per-sample Inference Time (s) | |---|---|---|---|---| | LLaMA-3.2-1B | Instruction Tuning (LoRA) | 73.48 | 30.96 | 2.21 | | LLaMA-3.2-1B | TiMER (External Alignment) | 77.04 (↑3.56) | 16.0 (↓48.3%) | 1.04 (↓52.9%) | | Qwen-3-0.6B | Instruction Tuning (LoRA) | 78.32 | 51.80 | 1.39 | | Qwen-3-0.6B | TiMER (External Alignment) | 78.45 (↑0.13) | 29.3 (↓43.4%) | 1.25 (↓10.1%) |

Key Findings

  1. Dynamic query-level routing is critical, not a simple task-level prior: Modifying inference routing weights through task-average routing (49.43%) or query-shuffled routing (49.71%) triggers a catastrophic performance drop of ~29% compared to TiMER (78.45%). This rigorously proves that QGR actively extracts nuanced evidence requirements from individual queries rather than overfitting to coarse task categories.
  2. Cross-granularity interaction dominates complex analytical tasks: When evaluating individual representations in isolation (Table A.4), cross-granularity features achieve 71.25%, outperforming raw (62.25%), fine (56.61%), and coarse (69.24%) representations. Empirical routing weight statistics (Table A.1) reveal that Anomaly Detection and Classification assign 0.810 of total weight to the Cross expert, whereas Characterization and Comparison assign over 0.93 to the Global expert, verifying that TiMER adaptively allocates capacity in complete accordance with task semantics.
  3. External alignment is faster and superior to instruction tuning: Training only 0.08% external alignment parameters avoids the disruption of internal LLM attention maps, cutting training time by 43.4% - 48.3% and inference latency by up to 52.9%, while surpassing LoRA fine-tuning by 3.56% on LLaMA-3.2-1B.

Highlights & Insights

  • Decoupled multi-scale decomposition with intention-driven routing: Rather than forcing time-series sequences into uniform 1D token embeddings, decomposing signals into physical trend and residual components prior to routing provides an intuitive, robust foundation for question answering.
  • Extreme parameter efficiency with zero catastrophic forgetting: By freezing both the base LLM and the feature extractor, TiMER avoids corrupting linguistic reasoning faculties and achieves SOTA performance on 210K multimodal queries using minimal computational overhead.
  • Generalization across diverse external benchmarks: Beyond TSAQA, TiMER demonstrates superior zero-shot transferability and consistency on Time-MQA (Table 4), outperforming ITFormer across Anomaly Detection (65.16 vs 60.90 Macro-F1), Classification (32.53 vs 26.54), and Reasoning QA.

Limitations & Future Work

  • Omission of regression-style continuous numerical prediction: The framework is specifically formulated for natural language TSQA. It does not output continuous high-precision numerical forecasts or probabilistic bounds common in classic quantitative time-series modeling.
  • Fixed token length heuristics: The numbers of adaptive pooling blocks (\(n_{loc}=8, n_{glob}=4, n_{cross}=8\)) and alignment tokens (\(L_{align}=25\)) are currently tuned as static hyperparameters. Exploring dynamic, sequence-length-adaptive token compression warrants future investigation.
  • vs Time-LLM & GPT4TS: Prior reprogramming approaches adapt language models strictly for conventional forecasting via fixed patching and prompt reprogramming, offering zero query-adaptive flexibility for interactive open-domain reasoning.
  • vs ITFormer & ChatTime: While ITFormer relies on end-to-end multimodal fine-tuning and struggles to generalize across diverse QA tasks (achieving only 50.93% even after in-domain fine-tuning), TiMER demonstrates that routing decoupled temporal granularities via frozen LLM alignment delivers a +27.5% performance leap.

Rating

  • Novelty: ⭐⭐⭐⭐ [Clean separation of multi-granularity time encoding and query-adaptive routing]
  • Experimental Thoroughness: ⭐⭐⭐⭐⭐ [Exhaustive evaluation spanning 210K samples, 13 domains, 6 tasks, and comprehensive routing diagnostics]
  • Writing Quality: ⭐⭐⭐⭐⭐ [Clear mathematical formulations, well-designed figures, and meticulous ablation reporting]
  • Value: ⭐⭐⭐⭐⭐ [Presents an efficient, highly practical blueprint for connecting frozen LLMs with complex numerical time series]