Paper deep dive
Beyond Tokenization: Direct Timestep Embedding and Contrastive Alignment for Time-Series Question Answering
Yafeng Wu, Huu Hiep Nguyen, Thin Nguyen, Hung Le
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 97%
Last extracted: 6/21/2026, 3:23:33 AM
Summary
The paper proposes CADE (Contrastive Alignment with Direct Embedding), a novel framework for Time-Series Question Answering (TSQA). CADE addresses the 'tokenization bottleneck' of standard LLMs by replacing patch-based encoders with a lightweight linear encoder and an MLP projector, allowing for direct, index-aligned timestep embedding. To bridge the semantic gap between numerical data and language, the framework introduces a one-directional supervised contrastive loss that aligns time-series embeddings with frozen class-name text anchors. CADE demonstrates superior performance across six TSQA tasks (anomaly detection, classification, multiple choice, true/false, forecasting, and imputation) on the Time-MQA benchmark.
Entities (7)
Relation Signals (4)
CADE → evaluatedon → Time-MQA
confidence 100% · Experimental results on the public Time-MQA benchmark demonstrate that our framework consistently improves performance
CADE → uses → Linear TS Encoder
confidence 100% · CADE (Contrastive Alignment with Direct Embedding), a novel framework for TSQA built upon two key components: direct timestep embedding and semantic alignment. ... (i) a linear time-series encoder
CADE → uses → MLP Projector
confidence 100% · (ii) an MLP projector that bridges the time-series and language modalities
CADE → uses → One-directional Supervised Contrastive Loss
confidence 100% · we introduce a novel one-directional supervised contrastive loss that aligns time-series embeddings with frozen class-name text anchors
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Recent advances in large language models (LLMs) have given rise to time-series question answering (TSQA), which formulates time-series analysis as natural-language question answering. However, directly feeding raw numerical series into LLMs suffers from a tokenization bottleneck: Byte Pair Encoding fragments continuous values into unstable tokens whose embeddings lack meaningful metric structure, resulting in the loss of magnitude, scale, and trend information. Prior methods use patch-based encoders that split the series into fixed windows, locking in one granularity that breaks patterns and hides exact timesteps, through a separate module that rarely transfers across datasets with different lengths or sampling rates. To address this challenge, we propose CADE (Contrastive Alignment with Direct Embedding), a novel framework for TSQA built upon two key components: direct timestep embedding and semantic alignment. The proposed framework maps each timestep directly into the LLM embedding space through a point-wise linear encoder and MLP projector, preserving exact index-level access while eliminating the need for patching and padding. To further bridge the semantic gap between time-series and language representations, we introduce a novel one-directional supervised contrastive loss that aligns time-series embeddings with frozen class-name text anchors. Experimental results on the public Time-MQA benchmark demonstrate that our framework consistently improves performance across six TSQA tasks, outperforming both open-source and proprietary LLM baselines.
Tags
Links
- Source: https://arxiv.org/abs/2606.18986v1
- Canonical: https://arxiv.org/abs/2606.18986v1
Trouble viewing inline? Open PDF directly →
Full Text
56,758 characters extracted from source content.
Expand or collapse full text
Beyond Tokenization: Direct Timestep Embedding and Contrastive Alignment for Time-Series Question Answering Yafeng Wu Huu Hiep Nguyen Thin Nguyen Hung Le Abstract Recent advances in large language models (LLMs) have given rise to time-series question answering (TSQA), which formulates time-series analysis as natural-language question answering. However, directly feeding raw numerical series into LLMs suffers from a tokenization bottleneck: Byte Pair Encoding fragments continuous values into unstable tokens whose embeddings lack meaningful metric structure, resulting in the loss of magnitude, scale, and trend information. Prior methods use patch-based encoders that split the series into fixed windows, locking in one granularity that breaks patterns and hides exact timesteps, through a separate module that rarely transfers across datasets with different lengths or sampling rates. To address this challenge, we propose CADE (Contrastive Alignment with Direct Embedding), a novel framework for TSQA built upon two key components: direct timestep embedding and semantic alignment. The proposed framework maps each timestep directly into the LLM embedding space through a point-wise linear encoder and MLP projector, preserving exact index-level access while eliminating the need for patching and padding. To further bridge the semantic gap between time-series and language representations, we introduce a novel one-directional supervised contrastive loss that aligns time-series embeddings with frozen class-name text anchors. Experimental results on the public Time-MQA benchmark demonstrate that our framework consistently improves performance across six TSQA tasks, outperforming both open-source and proprietary LLM baselines. Deakin University Correspondence to: Hung Le <<thai.le@deakin.edu.au>> https://github.com/YafengWu/CADE 1 Introduction Time series analysis underpins critical tasks such as anomaly detection, classification, forecasting, and imputation, with applications across healthcare monitoring, industrial maintenance, and financial modeling (Wen et al., 2023). Traditional deep learning models have achieved strong results in capturing temporal dependencies (Zeng et al., 2023; Wu et al., 2023; Nie et al., 2023), while the rise of Large Language Models (LLMs) has shown remarkable reasoning and generalization across diverse domains (Achiam et al., 2023; Liu et al., 2024a; Yang et al., 2025), motivating efforts to extend their capabilities to time series. Most existing approaches use LLMs as feature extractors or auxiliary modules rather than end-to-end solvers (Jin et al., 2024; Sun et al., 2024; Zhou et al., 2023). A more ambitious paradigm, time series question answering (TSQA), recasts each task as a natural-language question and lets the LLM produce the answer directly. For example, 3D gait acceleration from a wearable accelerometer can be framed as a structured question, with the LLM diagnosing whether the sample indicates freezing of gait. Yet feeding raw time series into an LLM raises a fundamental representational problem: standard tokenizers struggle to encode continuous numerical values. Figure 1: Comparison of time series representation strategies. The core difficulty lies in how LLMs represent continuous numerical values, and it originates at the level of tokenization. Byte Pair Encoding (BPE) (Sennrich et al., 2016), the standard tokenizer in most LLMs, builds its vocabulary from frequency patterns in text, where numbers are sparse and long-tailed. As a result, it merges digits according to textual co-occurrence rather than place value: a value such as 182.62 may be split into fragments like [18], [2.], [62]. This segmentation is also context-dependent, with the same digits tokenized differently across contexts, so the model never receives a stable signal that two numbers are close in magnitude. A single value is thus fractured into unstable symbols that carry no metric structure. Consequently, the model cannot recover magnitude, scale, or trend, the very properties on which time-series reasoning depends, which fundamentally limits the reliability of current methods on TSQA. To bypass tokenization, prior LLM-based time series methods (Wang et al., 2025b; Jin et al., 2024; Xie et al., 2025) adopt a patch-based encoder that segments the series into fixed-length windows and projects each window into a continuous embedding. This commits the model to a single temporal granularity fixed before training: the patch length imposes window boundaries that may cut across meaningful patterns and fold distinct timesteps into one token, so the model cannot natively identify the exact temporal index. Such an encoder for TSQA is also a separate, often pretrained module (Wang et al., 2025b) that adds parameters and a domain-specific inductive bias that need not transfer across datasets with different lengths or sampling rates. We instead propose CADE (Contrastive Alignment with Direct Embedding), which uses a linear projection to map each time-series value into a continuous embedding, illustrated in Figure 1. Unlike BPE, which fractures a value into unstable sub-tokens that carry no sense of magnitude, this direct mapping keeps each value intact as a single continuous vector and places numerically close values close in the embedding space, restoring the metric structure that text tokenization discards. Because each token corresponds one-to-one with a timestep, the model can address any individual index, which is essential for tasks such as imputation that operate on specific positions. Furthermore, this needs no patch size and no padding: with token count equal to sequence length, the same projection ingests series of arbitrary length and sampling rate without re-segmentation or per-dataset re-tuning, preserves the original temporal resolution, and lets the LLM’s attention model both local and long-range dependencies directly. To further align time-series embeddings with the LLM’s embedding space, we add an auxiliary one-directional supervised contrastive loss constructed from time-series classification data. For each classification sample, it pulls the time-series embedding toward its class-name text embedding and away from other classes, while the text anchors stay frozen so that only the time-series side moves into the LLM’s lexical space. Although this signal comes solely from classification samples, the encoder and projector it updates are shared by all six tasks; the loss therefore regularizes the shared pathway rather than fitting classification alone, yielding more discriminative and semantically grounded representations. The main contributions of this work are as follows: • To the best of our knowledge, this is among the first works to use a lightweight linear encoder, rather than a patch-based encoder, to map time-series values into continuous embeddings for multi-task time-series question answering. Despite its simplicity, this design substantially improves LLM performance across TSQA tasks. • We introduce a novel one-directional supervised contrastive loss that aligns projected time-series embeddings with frozen class-text anchors, strengthening the semantic correspondence between time-series features and the LLM’s linguistic reasoning. • Through extensive experiments on the Time-MQA datasets, we show that CADE achieves competitive or superior performance against both open-source and proprietary LLMs. The source code for CADE and all relevant baseline models are openly accessible on https://github.com/YafengWu/CADE. 2 Related Work 2.1 Large Language Models for Time Series Analysis Recent work has explored adapting LLMs for time series tasks through two main directions. First, prompt-based methods such as PromptCast (Xue and Salim, 2023) and LLMTime (Gruver et al., 2023) serialize numerical sequences into text prompts for direct forecasting. Second, multimodal architectures like Time-LLM (Jin et al., 2024) and UniTime (Liu et al., 2024c) align temporal representations with language model embeddings for cross-domain forecasting. A parallel line of work develops dedicated time-series foundation models such as TimesFM (Das et al., 2024), Chronos (Ansari et al., 2024), and Time-MOE (Shi et al., 2025) pre-train transformers specifically on temporal data for the forecasting task. These models are primarily designed for forecasting rather than text-based question answering, so they cannot be used for question answering and are not compared in our work. Among the remaining two directions, multimodal methods do not fully leverage the reasoning and generation capabilities of pretrained LLMs, while prompt-based methods suffer from imprecise numerical representation. This motivates a unified approach that enables LLMs to directly reason over time series inputs and solve diverse temporal tasks. 2.2 Temporal Question Answering Several recent works study question answering over time series data. ChatTS (Xie et al., 2025) is a time-series multimodal LLM trained on synthetic time-series–text pairs for temporal understanding and reasoning, targeting open-ended time-series reasoning rather than the task-oriented, multi-task setting we study. ChatTime (Wang et al., 2025a) is a pretrained time-series foundation model for forecasting and time-series QA. We focus on adapting general-purpose LLMs to time-series question answering and therefore compare only against existing LLM-based adaptation methods rather than time-series foundation models. Time-MQA (Kong et al., 2025) introduces the Time-MQA dataset and uses LoRA to directly fine-tune an LLM across a diverse set of temporal tasks, such as classification, anomaly detection, and forecasting. ITFormer (Wang et al., 2025b) adapts the Q-Former structure for the Time-Series Question Answering task and releases the EngineMT-QA dataset. Despite their progress, these methods inherit the representational limitations discussed above: Time-MQA feeds numerical values through the LLM’s text tokenizer and thus suffers from unstable digit segmentation and the absence of number-line geometry, while ITFormer and ChatTS rely on patch-based encoders that fix a single temporal granularity and obstruct per-timestep generation. In contrast, we map each timestep directly into the LLM’s embedding space with a lightweight linear encoder and MLP projector, avoiding both tokenization artifacts and patch-level granularity constraints. Beyond representation, aligning time series and natural language, inspired by vision–language alignment in models such as LLaVA (Liu et al., 2023) and InstructBLIP (Dai et al., 2023), is itself an active direction (Liu et al., 2025b), with approaches based on cross-attention (Jin et al., 2024; Liu et al., 2024b), contrastive learning (Chen et al., 2025; Dong et al., 2025; Sun et al., 2024), and knowledge distillation (Liu et al., 2025a). However, existing contrastive methods such as TS-CLIP (Chen et al., 2025), TimesCLIP (Dong et al., 2025), and TEST (Sun et al., 2024) either apply contrastive learning to narrow tasks (e.g., classification or forecasting) without an LLM, or treat the LLM merely as a pattern extractor by appending task-specific heads. In contrast, we align timestep embeddings with the LLM’s lexical space through a one-directional supervised contrastive loss, directly employing contrastive alignment for time-series question answering across six tasks within a unified framework. 3 Method 3.1 Problem Formulation We address time-series question answering, in which a LLM is asked to answer natural-language questions grounded in a univariate time series. Each sample is a triple (,q,τ)(x,q,τ), where =x1,x2,…,xTx=\x_1,x_2,…,x_T\ with xt∈ℝx_t is a univariate time series of length T, q is a natural-language prompt that poses a question about x and contains statistical features, and τ denotes the task type. The series length T varies across samples. We consider six task types, τ∈τ∈\anomaly detection, classification, multiple choice, true/false, forecasting, imputation\, and unify them under a single generative interface: regardless of τ, the model produces a textual response R=r1,…,rLR=\r_1,…,r_L\ autoregressively, rather than relying on task-specific output heads, where L denotes the number of tokens in the generated answer. Formally, the model defines a conditional distribution pθ(R∣,q)=∏i=1Lpθ(ri∣r<i,,q),p_θ(R ,q)= _i=1^Lp_θ\! (r_i r_<i,x,q ), (1) where θ is the parameter of the LLM. The objective is to maximize the likelihood of the textual response R given the time series and prompt. 3.2 Preprocess Normalization. z-score normalization is used for each series independently within its own question. Specifically, for a time series =x1,…,xTx=\x_1,…,x_T\, each value is normalized using the mean and standard deviation computed from that same series: xt′=xt−μσ,x _t= x_t-μσ, (2) where xtx_t is the original value at time step t, xt′x _t is the normalized value, the full normalized series is denoted ′=x1′,…,xT′x =\x _1,…,x _T\, and μ and σ are respectively, the mean and standard deviation of the time series x. Figure 2: Framework of the proposed CADE. Statistical Features. Instance-level z-score normalization removes absolute scale and offset information that can be critical for some tasks. For example, multiple choice and true/false question tasks have some questions about statistical features such as mean and maximum values. To preserve this information, we augment the text prompt with statistical summaries computed from the raw (pre-normalization) series. After the normalized series is presented, we append the following to the textual part of the prompt: The above is the normalized time series data. Its raw data has the following statistical information: mean: <mean_val>, standard deviation: <std_val>, minimum: <min_val>, maximum: <max_val>, median: <median_val>. This design lets the model reason over the shape of the normalized signal while still having access, in textual form, to the absolute statistics that normalization discards. 3.3 Architecture As illustrated in Figure 2, the proposed framework CADE consists of four components: (i) a linear time-series encoder that maps the normalized series into a continuous feature space; (i) an MLP projector that bridges the time-series and language modalities by projecting the encoded features into the LLM embedding space; (i) an LLM module: a pretrained LLM that autoregressively generates the answer from the fused time-series and text tokens; and (iv) a one-directional SupCon loss that aligns the projected time-series embeddings with frozen class-text embeddings for the classification task. We describe the first three components below, and detail the contrastive module in Section 3.4. Linear TS Encoder. Following the design philosophy of vision–language models such as LLaVA (Liu et al., 2023), which bridge a non-text modality into an LLM through an image encoder followed by a projection module, CADE maps the time series into the language model with an analogous encoder–projector pair: a linear time-series encoder produces a continuous feature sequence, and an MLP projector aligns it with the LLM embedding space. Concretely, a single linear layer maps the normalized time series ′∈ℝT×1x ^T× 1 into a dtsd_ts-dimensional continuous feature space, yielding a sequence of encoded features h∈ℝT×dtsh ^T× d_ts: h=Linear(′),h∈ℝT×dts.h=Linear(x ), h ^T× d_ts. (3) This linear TS encoder has three advantages. It is index-aligned: the one-to-one correspondence between embeddings and timesteps preserves exact positional addressability, which the generation tasks (forecasting and imputation) exploit. It is resolution-agnostic: by adopting point-wise tokenization, the encoder preserves the completeness of temporal information (Shi et al., 2025) and handles series of arbitrary length and sampling rate without patching, padding, or per-dataset re-tuning, which enhances the model’s flexibility and broad applicability to variable-length sequences while keeping the LLM’s attention operating at the signal’s native resolution. Finally, it is lightweight: a single linear layer introduces far fewer parameters than a patch-based transformer encoder and requires no separate pretraining, yet, as our experiments show, suffices to inject the time series into the LLM effectively. MLP Projector. The encoded features are then projected into the LLM embedding space with an MLP, mapping each time step embedding from dtsd_ts to dllmd_llm dimensions: Ets=MLP(h),Ets∈ℝT×dllm,E_ts=MLP(h), E_ts ^T× d_llm, (4) where dllmd_llm denotes the token-embedding dimension of the backbone LLM, so that each of the T time-series tokens is mapped into the LLM’s lexical space and can be concatenated with the text embeddings. The MLP has the following structure: =GELU(1h+1), =GELU\! (W_1\,h+b_1 ), 1 _1 ∈ℝ4dts×dts, ^4\,d_ts× d_ts, (5) Ets E_ts =LayerNorm(2+2), =LayerNorm\! (W_2\,z+b_2 ), 2 _2 ∈ℝdllm×4dts. ^d_llm× 4\,d_ts. (6) a non-linear projection provides the capacity to bridge the two modalities. The final LayerNorm stabilizes training. LLM. A pretrained LLM generates answers from the fused time-series and text tokens: R=pθ(f(Ets,Etext)),R=p_θ (f(E_ts,E_text) ), (7) where R is the generated response, pθp_θ is the LLM decoder with parameters θ, defined in formula 1, EtsE_ts is the time-series embedding, and EtextE_text is the text embedding. The sequence fusion f(⋅)f(·) depends on the task. For time-series understanding tasks (classification, anomaly detection, multiple choice, true/false), we use EtsE_ts to replace the raw time series. Raw numerical values are difficult for LLMs to interpret directly; substituting the learned embedding provides a more language-compatible representation that the model can reason over more effectively. For time-series generation tasks (forecasting and imputation), we send EtsE_ts and the raw time series together: the TS embedding provides high-level temporal understanding, while the raw values give the LLM the precise numerical grounding it needs to perform the task. 3.4 One-Directional Supervised Contrastive Loss To better regularize the projected time-series embeddings toward the semantic structure of the LLM’s embedding space, we introduce a one-directional supervised contrastive loss. Among the six tasks, only classification possesses a finite set of discrete, mutually exclusive class labels, making it uniquely suited for this objective. We therefore apply the loss exclusively to classification samples: it pulls each sample’s projected time-series embedding toward its corresponding class-text embedding and pushes it away from those of other classes. We call this loss one-directional because gradients flow only from the time-series side toward the frozen text targets, and never into the LLM’s embedding layer. The one-directional supervised contrastive Loss consists of four components, described below. Pooled TS Projection. During the forward pass, each sample is checked for whether it belongs to the classification task; non-classification samples are skipped entirely and contribute no contrastive signal. For each classification sample, we obtain the contrastive anchor by mean-pooling the projected time-series sequence Ets=ts(1),…,ts(T)E_ts=\e_ts^(1),…,e_ts^(T)\ over the time dimension: ¯ts=1T∑t=1Tts(t), e_ts= 1T _t=1^Te_ts^(t), (8) where ts(t)∈ℝdllme_ts^(t) ^d_llm is the t-th output of the MLP projector. Each pooled TS projection is paired with its class label c∈c for use in the subsequent steps. Memory Queue. In a multi-task training regime with six tasks, any given mini-batch may contain few or even zero classification samples, leaving insufficient anchors to form meaningful positive–negative contrasts. To address this, we maintain a circular memory queue Q=(¯ts(k),c(k))k=1KQ= \( e_ts^(k),\;c^(k)) \_k=1^K of capacity M, where each entry stores a detached pooled TS projection ¯ts(k) e_ts^(k) paired with its class label c(k)c^(k). Here K≤MK≤ M denotes the current occupancy, which grows until the queue reaches capacity M and is thereafter held at M by evicting the oldest entry in FIFO order. A warmup threshold MminM_ is enforced: if |Q|<Mmin|Q|<M_ , the current batch’s anchors are enqueued but the contrastive loss is not computed, ensuring a sufficiently diverse pool of negatives before the signal is applied. Following standard MoCo practice (He et al., 2020), entries are enqueued after loss computation so that a sample is never used as its own key. Frozen Label Embeddings. At training time, all class labels stored in the memory queue are mapped to their corresponding frozen label embeddings. Specifically, for each class c∈c , a single label embedding c∈ℝdllme_c ^d_llm is constructed once before training by tokenizing the lowercased label text and averaging the corresponding input-embedding vectors: c=1|tc|∑j=1|tc|Embed(tcj), _c= 1|t_c| _j=1^|t_c|Embed\! (t_c^\,j ), (9) EQ=c(k)k=1K. E_Q=\e_c^(k)\_k=1^K. (10) where tcjt_c^\,j is the j-th token of class name c and Embed(⋅)Embed(·) denotes the LLM input-embedding layer. EQE_Q denotes the set of label embeddings corresponding to the class labels stored in the memory queue. Each ce_c is detached from the computation graph and receives no gradient updates throughout training. This is precisely what makes the loss one-directional: the time-series projections learn to align with the text targets, but the text targets themselves remain fixed anchors in the shared embedding space. SupCon Loss. Given the current pooled TS projection ¯ts e_ts and the pool of frozen label embeddings EQE_Q retrieved from the queue, both sides are ℓ2 _2-normalized and cosine similarities are scaled by a temperature γ: s(k)=¯ts⋅c(k)‖¯ts‖‖c(k)‖γ,s^(k)= e_ts·e_c^(k) \| e_ts \|\; \|e_c^(k) \|\;γ, (11) yielding a similarity vector ∈ℝKs ^K. A positive mask is then constructed: entry k is marked positive if the queue entry k shares the same class label as the anchor. We then adopt the supervised contrastive (SupCon) formulation (Khosla et al., 2020), which treats all queue entries sharing the anchor’s class label as positives: ℒsc=−1||∑k∈logexp(s(k))∑j=1Kexp(s(j)),L_sc=- 1|P| _k (s^(k)) _j=1^K (s^(j)), (12) where =k:c(k)=cP=\k:c^(k)=c\ is the set of queue entries sharing the same class as the anchor, and the denominator sums over all queue entries. 3.5 Training Loss Cross-Entropy Loss. All six tasks are trained with the standard next-token cross-entropy loss. Given the model response R and the ground-truth answer A: ℒce=CrossEntropy(R,A).L_ce=CrossEntropy(R,\,A). (13) Total Loss. The final training objective combines the generative and contrastive terms: ℒ=ℒce+λτ⋅ℒsc,L=L_ce+ _τ·L_sc, (14) where λτ=λif τ=classification,0otherwise, _τ= casesλ&if τ=classification,\\ 0&otherwise, cases (15) Here λ∈[0,1]λ∈[0,1] is a scalar weight that controls the strength of the contrastive term. The contrastive branch introduces no additional trainable parameters; it reuses the encoder and projector from the main forward path. Gradients from ℒscL_sc therefore update only the TS Encoder and MLP Projector, while ℒceL_ce updates the encoder, projector, and the LLM jointly. 4 Experiments 4.1 Dataset We evaluate our method on the Time-MQA Dataset (Kong et al., 2025), a multi-task question-answering benchmark for time series understanding that covers six tasks: classification, anomaly detection (AD), true/false, multiple choice (MCQ), forecasting, and imputation. The training and testing sets are randomly sampled, with the training set containing approximately 1,400 samples per task (ranging from 1,293 for forecasting to 1,400 for classification, anomaly detection, and imputation), totaling 8,286 samples, and the test set containing approximately 400 samples per task (ranging from 379 for forecasting to 400 for classification, anomaly detection, and true/false), totaling 2,376 samples. 4.2 Baselines We compare against four external methods that represent distinct design choices for time-series question answering. Our own internal variants, which degrade individual components of CADE, are introduced separately in the architectural ablations (Section 4.6.1). Time-MQA (Kong et al., 2025): an LLM fine-tuned with LoRA, jointly trained on all six tasks as a unified multi-task model. Time-MQA (Full FT): the same Time-MQA recipe (numeric series serialized to text via the BPE tokenizer, jointly trained on all six tasks) but with full-parameter fine-tuning instead of LoRA, isolating whether more trainable capacity rescues the text-serialization interface. ITFormer (Wang et al., 2025b): a QFormer-like (Li et al., 2023) architecture designed for temporal-textual question answering on the EngineMT-QA dataset. Since its original time series encoder is a pretrained PatchTST model that requires fixed-length multivariate input, which is incompatible with the flexible-length univariate time series in Time-MQA, we replace it with a frozen Time-MOE encoder (Shi et al., 2025) and modify the cross-attention module to handle univariate time series. Frozen Time-MoE: Replaces the trainable linear time-series encoder with a pretrained, frozen Time-MoE encoder (Shi et al., 2025), while keeping the same MLP projector and LoRA-tuned LLM; only the projector and LoRA adapters are updated, under the cross-entropy loss alone. We freeze Time-MoE following the setting of LLaVA (Liu et al., 2023), where the time-series encoder is pretrained and kept frozen during QA fine-tuning, so that only the cross-modal components adapt to the task. This isolates whether a large pretrained time-series foundation model yields a stronger frozen representation than a lightweight learnable encoder. 4.3 Metrics For the forecasting and imputation tasks, we adopt three metrics. Throughout, let N denote the number of samples and [⋅]1[·] the indicator function, which is 11 when its condition holds and 0 otherwise. (1) Format Compliance Rate (FCR), defined as the ratio of predictions whose output length exactly matches the requested length to the total number of predictions: FCR=1N∑i=1N[L(^i)=Li],FCR= 1N _i=1^N1\! [L( y_i)=L_i ], (16) where LiL_i is the required output length and L(^i)L( y_i) is the length of the generated output. Table 1: Implementation details. Configuration Value Framework PyTorch GPU NVIDIA A100 (40GB) × 1 LLM Qwen-3-0.6B Batch size 32 Learning rate 5×10−55× 10^-5 LR scheduler Cosine Training steps 2,000 TS Encoder dimension dtsd_ts 384 Memory bank size 512 Contrastive loss weight (λ) 0.1 (2) Own MSE: the mean squared error computed over only those values a model actually predicts. As LLMs generate predictions as free-form text, they frequently emit fewer points than requested; for instance, producing 1010 values when 2121 are required. In such cases, Own MSE is evaluated solely on the predicted points (the first 1010): Own-MSE=1Nc∑i=1Nc1Ti∑t=1Ti(y^i,t−yi,t)2,Own -MSE= 1N_c _i=1^N_c 1T_i _t=1^T_i( y_i,t-y_i,t)^2, (17) where NcN_c denotes the number of matched-length predictions and TiT_i is the prediction length for sample i. (3) Shared MSE, the mean squared error computed on the intersection of samples for which all compared models produce correctly formatted outputs, enabling a head-to-head comparison on identical inputs: Shared-MSE=1Ns∑i=1Ns1Ti∑t=1Ti(y^i,t−yi,t)2,Shared -MSE= 1N_s _i=1^N_s 1T_i _t=1^T_i( y_i,t-y_i,t)^2, (18) where NsN_s denotes the number of samples for which all compared models produce format-compliant outputs. For the remaining four tasks (classification, anomaly detection, true/false, and multiple choice), we use Accuracy as the evaluation metric, defined as Accuracy=1N∑i=1N[c^i=ci],Accuracy= 1N _i=1^N1\! [ c_i=c_i ], (19) where c^i c_i and cic_i are the predicted and ground-truth labels for sample i, respectively. 4.4 Implementation Details Table 2: Main results on the Time-MQA benchmark. Internal variants are included for completeness and analyzed in Section 4.6.1. Method Forecasting Imputation AD Classification True/False MCQ FCR ↑ Own (MSE) ↓ Shared (MSE) ↓ FCR ↑ Own (MSE) ↓ Shared (MSE) ↓ ITFormer 0 383,107 — 0 4,284,782 — 0.84 0.7925 0.7775 0.5013 Frozen Time-MoE 0.58 311,892 40,660 0.82 27,437 5,911 0.8475 0.81 0.7575 0.5113 Frozen Random Linear 0.554 315,402 29,917 0.7975 87,578 5,798 0.82 0.825 0.7550 0.5013 Time-MQA 0.46 440,626 30,757 0.65 2,399,043 5,318 0.5975 0.72 0.6775 0.471 Time-MQA (Full FT) 0.46 1,104,244 3,479,036 0.57 2,391,803 4,313 0.62 0.735 0.7 0.4332 CADE w/o SupCon 0.596 312,649 36,852 0.777 34,532 6,004 0.835 0.8025 0.75 0.5189 CADE 0.598 296,897 32,268 0.785 25,210 5,999 0.8625 0.8075 0.7675 0.5315 Table 1 summarizes the key training configurations of our model. We build on a compact Qwen-3-0.6B backbone fine-tuned with LoRA, pairing it with a lightweight 1→3841\!→\!384 trainable linear time-series encoder and an MLP projector, and train for 2,0002,000 steps with an effective batch size of 3232 on a single NVIDIA A100. The auxiliary one-directional supervised contrastive loss uses a memory bank of size 512512 and a loss weight of λ=0.1λ=0.1. 4.5 Main Results Table 2 reports performance across all six Time-MQA tasks. Shared MSE is computed on the intersection of format-compliant predictions across all models except ITFormer, whose zero compliance rate would otherwise result in an empty shared subset. The shared subsets contain 79 forecasting samples and 148 imputation samples. CADE attains the best score on five of the ten reported metrics, forecasting FCR and own MSE, imputation own MSE, anomaly detection, and MCQ, and remains competitive on the rest, whereas no baseline is consistently strong across both the generative (forecasting, imputation) and understanding (AD, classification, judgment, MCQ) task families. Query-compression discards the resolution generative tasks require. The QFormer-style ITFormer compresses each series into a fixed, small set of learned query tokens, and this bottleneck is fatal on the generative tasks: it attains FCR=0FCR=0 on both forecasting and imputation, never emitting a single length-matched sequence. Its reported own-MSE values (383,107383,107 for forecasting, 4,284,7824,284,782 for imputation) are therefore not deployable predictions, and it admits no shared subset at all. Because a fixed number of query tokens cannot encode a variable-length series at per-timestep granularity, the model loses exactly the positional structure needed to write back an output aligned to the requested horizon, whereas our per-timestep linear encoding preserves it. On the shared-subset metric. CADE does not attain the lowest shared MSE (forecasting: 32,26832,268 vs. Frozen Random Linear’s 29,91729,917; imputation: 5,9995,999 vs. Time-MQA (Full FT)’s 4,3134,313). However, the shared subset is restricted to rows that every model formats correctly, and is therefore bottlenecked by the lowest-FCR models and dominated by the easiest cases. Read alongside the markedly higher format-compliance rates and lower own MSE of CADE, these near-identical shared-subset errors indicate that our model matches the baselines on easy inputs while additionally producing accurate, correctly formatted predictions on the substantially larger and harder set of inputs that the baselines fail to handle. 4.6 Ablation Studies We organize our ablations into two groups. Architectural ablations (Section 4.6.1) isolate the contribution of each design choice in our model, the time-series encoder and the auxiliary contrastive loss, by degrading one component at a time while holding everything else fixed. Hyperparameter ablations (Section 4.6.2) then sweep the two components introduced by the contrastive loss, the memory-bank size and the loss weight λ. 4.6.1 Architectural Ablations To attribute CADE’s gains to individual design choices, we introduce two internal variants that each degrade a single component of the full model, and analyze them against the external baselines using the numbers reported in Table 2. Frozen Random Linear: Replaces the trainable linear encoder with a randomly-initialized linear encoder that is held frozen throughout training, again updating only the projector and LoRA adapters under the cross-entropy loss. This random-feature baseline isolates the benefit of learning the time-series encoder rather than relying on a fixed random projection. CADE w/o SupCon: Our full architecture but supervised by the cross-entropy loss only. This isolates the contribution of the auxiliary contrastive loss in our final method. Table 3: Effect of memory-bank size (λ=0.1λ=0.1). The first row is the no-auxiliary-loss reference. Bold marks the best value among the swept settings per column. Memory size Forecasting Imputation AD Classification True/False MCQ FCR ↑ MSE ↓ FCR ↑ MSE ↓ None (no SupCon loss) 0.596 312,649312,649 0.777 34,53234,532 0.835 0.8025 0.75 0.5189 32 0.52 290,927290,927 0.785 33,26933,269 0.8475 0.8075 0.7625 0.5264 64 0.5171 314,575314,575 0.78 27,39127,391 0.8525 0.8025 0.77 0.5466 128 0.546 286,400286,400 0.77 39,07639,076 0.8450 0.7975 0.77 0.5214 256 0.58 278,346278,346 0.7675 29,25429,254 0.8525 0.80 0.76 0.5365 512 0.598 296,897296,897 0.785 25,210 0.8625 0.8075 0.7675 0.5315 1024 0.588 286,365286,365 0.785 30,57630,576 0.8525 0.8075 0.7625 0.5315 2048 0.572 208,202 0.7875 32,84932,849 0.84 0.8025 0.7525 0.539 Table 4: Effect of contrastive loss weight λ (memory size =512=512). The λ=0λ=0 row is the no-auxiliary-loss reference. Bold marks the best value among the active (λ>0λ>0) settings per column. λ Forecasting Imputation AD Classification True/False MCQ FCR ↑ MSE ↓ FCR ↑ MSE ↓ 0 0.596 312,649312,649 0.777 34,53234,532 0.835 0.8025 0.75 0.5189 0.01 0.591 310,394310,394 0.7875 33,92933,929 0.8575 0.80 0.7875 0.5416 0.05 0.559 293,245293,245 0.7875 33,20933,209 0.84 0.8075 0.7675 0.5491 0.1 0.598 296,897296,897 0.785 25,210 0.8625 0.8075 0.7675 0.5315 0.25 0.591 282,121 0.7825 35,35635,356 0.8525 0.795 0.7675 0.5390 0.5 0.572 313,433313,433 0.7875 29,21929,219 0.8475 0.8075 0.7425 0.5390 A continuous linear encoder substantially outperforms BPE tokenization. The sharpest contrast is between Time-MQA, which serializes the numeric series into text and feeds it through the LLM’s BPE tokenizer, and the encoder-based variants, which inject the series as continuous embeddings. Replacing BPE with our trainable linear encoder improves every task: forecasting FCR rises from 0.460.46 to 0.5960.596 and its own MSE falls from 440,626440,626 to 312,649312,649; imputation’s own MSE drops from 2,399,0432,399,043 to 34,53234,532, nearly two orders of magnitude, and with the time series understanding tasks (anomaly detection, classification, judgment, MCQ) improving in the same direction (Table 2). Crucially, these gains already hold for “CADE w/o SupCon,” which differs from Time-MQA only in the continuous encoder, isolating the BPE bypass as the dominant driver. The effect is in fact independent of learning the encoder at all: the Frozen Random Linear baseline, whose 1→3841\!→\!384 projection is randomly initialized and never trained, already surpasses BPE serialization on every task, raising forecasting FCR to 0.5540.554 and cutting its own-MSE to 315,402315,402, raising imputation FCR to 0.79750.7975 and collapsing its own-MSE from 2,399,0432,399,043 to 87,57887,578, and lifting anomaly detection (0.5975→0.820.5975→ 0.82), classification (0.72→0.8250.72→ 0.825), judgment (0.6775→0.7550.6775→ 0.755), and MCQ (0.471→0.50130.471→ 0.5013). Since a fixed random projection carries no learned temporal information, this isolates the continuous-token interface itself, rather than any encoder capacity, as the source of the improvement over BPE. The simultaneous collapse of Time-MQA’s FAR and own MSE further suggests that tokenizing long numeric strings both inflates sequence length and destroys the positional structure needed to emit length-matched predictions. Full-parameter fine-tuning of the same BPE-serialized model (Time-MQA (Full FT)) does not help and often hurts (e.g. forecasting own-MSE 440,626→1,104,244440,626→ 1,104,244, MCQ 0.471→0.43320.471→ 0.4332), confirming the bottleneck is the serialization interface, not trainable capacity. Simplicity is sufficient: a linear encoder rivals a pretrained foundation encoder. To isolate the effect of the encoder from that of the auxiliary contrastive loss, we compare “CADE w/o SupCon” against the frozen Time-MoE baseline, since neither uses the contrastive objective. Despite its minimal capacity, a single 1→3841\!→\!384 linear map, the trainable encoder is broadly competitive with the frozen pretrained Time-MoE foundation encoder: it is better on forecasting FCR (0.5960.596 vs. 0.580.58), forecasting shared MSE (29,45729,457 vs. 33,06033,060), and MCQ (0.51890.5189 vs. 0.51130.5113), essentially tied on forecasting own-MSE (312,649312,649 vs. 311,892311,892), classification (0.80250.8025 vs. 0.810.81), and true/false (0.750.75 vs. 0.75750.7575), and only somewhat behind on anomaly detection (0.8350.835 vs. 0.84750.8475) and imputation own-MSE (34,53234,532 vs. 27,43727,437); none of the gaps in either direction is large. The one-Directional SupCon loss strengthens cross-modal alignment across tasks. Comparing “CADE w/o SupCon” with the full model isolates the auxiliary one-directional supervised contrastive loss, which pulls projected time-series embeddings toward frozen class-text anchors while leaving the text side fixed. Although this signal is applied only to classification samples, the improvements are not confined to classification: anomaly detection rises from 0.8350.835 to 0.86250.8625, judgment from 0.750.75 to 0.76750.7675, MCQ from 0.51890.5189 to 0.53150.5315, and imputation own MSE falls from 34,53234,532 to 25,21025,210 (a 27%27\% reduction). This spillover indicates that anchoring time-series features to the LLM’s lexical embedding space regularizes the shared projection rather than merely sharpening the anchored task, thereby strengthening the semantic correspondence between time-series representations and the model’s linguistic reasoning across the board. 4.6.2 Hyperparameter Ablations We ablate the two hyperparameters introduced by our auxiliary contrastive loss: the memory size and the loss weight λ. Additionally, we omit Shared MSE in this section because the shared-subset MSE is inherently a cross-model metric. It is computed on the rows that all competing models format correctly, so its denominator is defined only with respect to a fixed set of distinct models. In an ablation study, the compared systems are variants of the same method rather than distinct models, making Shared MSE unsuitable for this purpose. Performance is robust across memory-bank sizes. Table 3 shows the same stability with respect to the bank capacity: across the 3232–20482048 range, anomaly detection stays within 0.840.84–0.86250.8625 and classification within 0.79750.7975–0.80750.8075, with no setting degrading the model relative to the no-loss reference on the understanding tasks. Individual metrics peak at different sizes, forecasting own-MSE is lowest at 20482048 and MCQ is highest at 6464, but these isolated extrema do not transfer to the other metrics (e.g. at 20482048 both anomaly detection and judgment fall), and several of the differences are at the scale of one or two test samples. We therefore read the sweep as evidence of robustness rather than a sharp global optimum. Turning the loss on helps; the method is not sensitive to its exact weight. The clearest signal in Table 4 is the gap between λ=0λ=0 and any positive weight on the understanding tasks: every active setting raises anomaly detection above the 0.8350.835 obtained without the loss (to 0.84750.8475–0.86250.8625), and likewise improves MCQ (0.5189→0.53150.5189→ 0.5315–0.54910.5491) and, for most settings, judgment. Because the loss is applied only to classification samples, these consistent cross-task gains indicate that anchoring time-series embeddings to the lexical space regularizes the shared projection rather than over-fitting the anchored task. Importantly, performance remains stable across two orders of magnitude in λ with no collapse, showing the contribution of the loss is robust rather than the artifact of a single fortunate weight. Table 5: Comparison against a frontier general-purpose LLM (DeepSeek-V3.2) on the Time-MQA benchmark. Method Forecasting Imputation AD Classification True/False MCQ FCR ↑ Own (MSE) ↓ Shared (MSE) ↓ FCR ↑ Own (MSE) ↓ Shared (MSE) ↓ DeepSeek-V3.2 0.984 270,979 85,688 0.91 87,334 120,663 0.5975 0.7275 0.7475 0.585 CADE 0.598 296,897 82,458 0.785 25,210 31,200 0.8625 0.8075 0.7675 0.5315 λ=0.1λ=0.1 and memory size 512512 give the best overall balance. The two sweeps agree on a single joint configuration. Anomaly detection, the most semantically structured understanding task, and the one the contrastive alignment should most directly benefit, reaches its peak of 0.86250.8625 at exactly λ=0.1λ=0.1 in Table 4 and at exactly memory size 512512 in Table 3; no other setting attains this value in either sweep. This same configuration also yields the best forecasting compliance (FCR 0.5980.598 / 0.590.59), the lowest imputation own-MSE among all swept settings (25,21025,210, a clear margin over the next-best ∼27,000 \!27,000–30,00030,000), and ties for the best classification accuracy (0.80750.8075), while remaining within noise of the best value on the remaining metrics. 4.7 Comparison with a Frontier General-Purpose LLM To situate our compact, encoder-based model against a strong text-only baseline, we additionally evaluate DeepSeek-V3.2, a frontier general-purpose LLM that ingests the numeric series via text serialization and is prompted zero-shot (no time-series encoder, no task-specific tuning). Because the two systems have very different format-compliance rates, the shared subset here is recomputed pairwise over the intersection of the two models’ format-compliant predictions (221221 samples for forecasting, 288288 for imputation), and therefore differs from the all-model shared subset in Table 2. Scale buys format compliance, not numeric accuracy. DeepSeek-V3.2 attains near-perfect format compliance (FCR 0.9840.984 on forecasting, 0.910.91 on imputation) against our 0.5980.598 and 0.7850.785, confirming that a large instruction-tuned model is far more reliable at emitting length-matched sequences. Yet once the comparison is restricted to inputs both models format correctly, this scale advantage does not translate into accuracy: on the shared subset our 0.60.6B model already edges out DeepSeek on forecasting (82,45882,458 vs. 85,68885,688) and is nearly 4×4× lower on imputation (31,20031,200 vs. 120,663120,663). The same holds for imputation own-MSE (25,21025,210 vs. 87,33487,334), while the two are roughly comparable on forecasting own-MSE (296,897296,897 vs. 270,979270,979, the latter measured over DeepSeek’s much larger compliant set). In other words, presenting the series as continuous tokens yields more accurate numeric predictions than text serialization even against a model orders of magnitude larger. Discriminative time-series understanding favors the continuous encoder. The gap widens sharply on the tasks that require reading temporal structure rather than copying numbers. CADE outperforms DeepSeek-V3.2 on anomaly detection by a wide margin (0.86250.8625 vs. 0.59750.5975), and also on classification (0.80750.8075 vs. 0.72750.7275) and true/false judgment (0.76750.7675 vs. 0.74750.7475). A frontier text model that only sees serialized digits struggles to localize anomalies, whereas the trainable encoder exposes the underlying shape of the series. This indicates that the principal bottleneck for general LLMs on time series is representation, not reasoning capacity. MCQ is the exception. The one task where DeepSeek leads is multiple choice (0.5850.585 vs. 0.53150.5315), which leans most heavily on broad reasoning and world knowledge rather than on fine-grained reading of the series. Here the limited capacity of the 0.60.6B backbone is visible, and the larger model’s general competence dominates. 4.8 Limitations and Future Work Format compliance remains a bottleneck. Although the continuous encoder markedly improves FCR over small-model BPE serialization (Table 2), our compliance still trails a frontier model by a large margin (forecasting FCR 0.5980.598 vs. 0.9840.984; imputation 0.7850.785 vs. 0.910.91). Because forecasting and imputation outputs are only usable when their length matches the request, this gap directly caps the fraction of inputs on which our model produces a deployable prediction, even though its accuracy on the compliant subset is competitive or better. Reasoning-heavy MCQ lags. CADE underperforms on MCQ, the most reasoning-intensive task, which suggests that neither the small backbone nor the current alignment signal is sufficient for multi-option discrimination that combines temporal evidence with broader inference. Alignment is too implicit. Our auxiliary one-directional supervised contrastive loss is applied only to classification samples and anchors time-series embeddings to a fixed set of class-text vectors. While this provides a useful regularizer for all tasks, the model is never explicitly taught what fundamental temporal concepts such as trend, periodicity, level shifts, or anomalies mean in language. We hypothesize that a more principled, two-stage curriculum would close both the FCR and MCQ gaps. Concretely, rather than relying on a contrastive term during QA tuning, the model should first be pretrained on large-scale time-series – text paired data that describe these basic concepts, learning to map temporal structure onto its lexical space, and only then be fine-tuned on the downstream QA tasks. Such explicit concept alignment, followed by task adaptation, would give the model a genuine semantic grounding of time-series structure instead of a narrow auxiliary signal, which we leave to future work. 5 Conclusion In this work, we presented CADE (Contrastive Alignment with Direct Embedding), a framework for multi-task time-series question answering that maps each timestep directly into the LLM’s embedding space through a linear encoder and MLP projector, and aligns these embeddings with frozen class-text anchors via a one-directional supervised contrastive loss. Experiments on the Time-MQA benchmark show that CADE consistently outperforms BPE serialization and remains competitive with or better than both a pretrained foundation encoder and a frontier general-purpose LLM across the six tasks; our ablation studies further indicate that the continuous-token interface is the dominant driver of these gains, while the auxiliary contrastive loss contributes consistent cross-task improvements, most notably on the understanding tasks. Since format compliance and reasoning-heavy questions remain the main limitations, future work will explore more explicit semantic grounding of temporal structure prior to downstream task adaptation. References J. Achiam, S. Adler, S. Agarwal, L. Ahmad, I. Akkaya, F. L. Aleman, D. Almeida, J. Altenschmidt, S. Altman, S. Anadkat, et al. (2023) GPT-4 technical report. arXiv preprint arXiv:2303.08774. Cited by: §1. A. F. Ansari, L. Stella, A. C. Turkmen, X. Zhang, P. Mercado, H. Shen, O. Shchur, S. S. Rangapuram, S. P. Arango, S. Kapoor, et al. (2024) Chronos: learning the language of time series. Transactions on Machine Learning Research 2024. Cited by: §2.1. Z. Chen, X. Zhang, and M. Zhu (2025) TS-clip: time series understanding by clip. In Proceedings of the 2025 Conference on Empirical Methods in Natural Language Processing, p. 4646–4664. Cited by: §2.2. W. Dai, J. Li, D. Li, A. Tiong, J. Zhao, W. Wang, B. Li, P. N. Fung, and S. Hoi (2023) Instructblip: towards general-purpose vision-language models with instruction tuning. Advances in neural information processing systems 36, p. 49250–49267. Cited by: §2.2. A. Das, W. Kong, R. Sen, and Y. Zhou (2024) A decoder-only foundation model for time-series forecasting. In International Conference on Machine Learning, p. 10148–10167. Cited by: §2.1. S. Dong, W. Fan, T. Wu, and Y. Fu (2025) Teaching time series to see and speak: forecasting with aligned visual and textual perspectives. arXiv preprint arXiv:2506.24124. Cited by: §2.2. N. Gruver, M. Finzi, S. Qiu, and A. G. Wilson (2023) Large language models are zero-shot time series forecasters. Advances in neural information processing systems 36, p. 19622–19635. Cited by: §2.1. K. He, H. Fan, Y. Wu, S. Xie, and R. Girshick (2020) Momentum contrast for unsupervised visual representation learning. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, p. 9729–9738. Cited by: §3.4. M. Jin, S. Wang, L. Ma, Z. Chu, J. Zhang, X. Shi, P. Chen, Y. Liang, Y. Li, S. Pan, et al. (2024) Time-llm: time series forecasting by reprogramming large language models. In International conference on learning representations, p. 23857–23880. Cited by: §1, §1, §2.1, §2.2. P. Khosla, P. Teterwak, C. Wang, A. Sarna, Y. Tian, P. Isola, A. Maschinot, C. Liu, and D. Krishnan (2020) Supervised contrastive learning. Advances in neural information processing systems 33, p. 18661–18673. Cited by: §3.4. Y. Kong, Y. Yang, Y. Hwang, W. Du, S. Zohren, Z. Wang, M. Jin, and Q. Wen (2025) Time-mqa: time series multi-task question answering with context enhancement. In Proceedings of the 63rd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), p. 29736–29753. Cited by: §2.2, §4.1, §4.2. J. Li, D. Li, S. Savarese, and S. Hoi (2023) Blip-2: bootstrapping language-image pre-training with frozen image encoders and large language models. In International conference on machine learning, p. 19730–19742. Cited by: §4.2. A. Liu, B. Feng, B. Xue, B. Wang, B. Wu, C. Lu, C. Zhao, C. Deng, C. Zhang, C. Ruan, et al. (2024a) Deepseek-v3 technical report. arXiv preprint arXiv:2412.19437. Cited by: §1. C. Liu, H. Miao, Q. Xu, S. Zhou, C. Long, Y. Zhao, Z. Li, and R. Zhao (2025a) Efficient multivariate time series forecasting via calibrated language models with privileged knowledge distillation. In 2025 IEEE 41st International Conference on Data Engineering (ICDE), p. 3165–3178. Cited by: §2.2. C. Liu, S. Zhou, Q. Xu, H. Miao, C. Long, Z. Li, and R. Zhao (2025b) Towards cross-modality modeling for time series analytics: a survey in the llm era. In Proceedings of the Thirty-Fourth International Joint Conference on Artificial Intelligence, p. 10564–10572. Cited by: §2.2. H. Liu, C. Li, Q. Wu, and Y. J. Lee (2023) Visual instruction tuning. Advances in neural information processing systems 36, p. 34892–34916. Cited by: §2.2, §3.3, §4.2. Q. Liu, X. Liu, C. Liu, Q. Wen, and Y. Liang (2024b) Time-ffm: towards lm-empowered federated foundation model for time series forecasting. Advances in Neural Information Processing Systems 37, p. 94512–94538. Cited by: §2.2. X. Liu, J. Hu, Y. Li, S. Diao, Y. Liang, B. Hooi, and R. Zimmermann (2024c) Unitime: a language-empowered unified model for cross-domain time series forecasting. In Proceedings of the ACM Web Conference 2024, p. 4095–4106. Cited by: §2.1. Y. Nie, N. H. Nguyen, P. Sinthong, and J. Kalagnanam (2023) A time series is worth 64 words: long-term forecasting with transformers. In The Eleventh International Conference on Learning Representations, Cited by: §1. R. Sennrich, B. Haddow, and A. Birch (2016) Neural machine translation of rare words with subword units. In Proceedings of the 54th annual meeting of the association for computational linguistics (volume 1: long papers), p. 1715–1725. Cited by: §1. X. Shi, S. Wang, Y. Nie, D. Li, Z. Ye, Q. Wen, and M. Jin (2025) Time-moe: billion-scale time series foundation models with mixture of experts. In International conference on learning representations, p. 34635–34667. Cited by: §2.1, §3.3, §4.2, §4.2. C. Sun, H. Li, Y. Li, and S. Hong (2024) TEST: text prototype aligned embedding to activate LLM’s ability for time series. In The Twelfth International Conference on Learning Representations, Cited by: §1, §2.2. C. Wang, Q. Qi, J. Wang, H. Sun, Z. Zhuang, J. Wu, L. Zhang, and J. Liao (2025a) Chattime: a unified multimodal time series foundation model bridging numerical and textual data. In Proceedings of the AAAI Conference on Artificial Intelligence, p. 12694–12702. Cited by: §2.2. Y. Wang, P. Lei, J. Song, Y. Hao, T. Chen, Y. Zhang, L. Jia, Y. Li, and Z. Wei (2025b) ITFormer: bridging time series and natural language for multi-modal qa with large-scale multitask dataset. In International Conference on Machine Learning, p. 63324–63344. Cited by: §1, §2.2, §4.2. Q. Wen, T. Zhou, C. Zhang, W. Chen, Z. Ma, J. Yan, and L. Sun (2023) Transformers in time series: a survey. In Proceedings of the Thirty-Second International Joint Conference on Artificial Intelligence, p. 6778–6786. Cited by: §1. H. Wu, T. Hu, Y. Liu, H. Zhou, J. Wang, and M. Long (2023) TimesNet: temporal 2d-variation modeling for general time series analysis. In The Eleventh International Conference on Learning Representations, Cited by: §1. Z. Xie, Z. Li, X. He, L. Xu, X. Wen, T. Zhang, J. Chen, R. Shi, and D. Pei (2025) ChatTS: aligning time series with llms via synthetic data for enhanced understanding and reasoning. Proceedings of the VLDB Endowment 18, p. 2385–2398. Cited by: §1, §2.2. H. Xue and F. D. Salim (2023) Promptcast: a new prompt-based learning paradigm for time series forecasting. IEEE Transactions on Knowledge and Data Engineering 36, p. 6851–6864. Cited by: §2.1. A. Yang, A. Li, B. Yang, B. Zhang, B. Hui, B. Zheng, B. Yu, C. Gao, C. Huang, C. Lv, et al. (2025) Qwen3 technical report. arXiv preprint arXiv:2505.09388. Cited by: §1. A. Zeng, M. Chen, L. Zhang, and Q. Xu (2023) Are transformers effective for time series forecasting?. In Proceedings of the AAAI conference on artificial intelligence, p. 11121–11128. Cited by: §1. T. Zhou, P. Niu, L. Sun, R. Jin, et al. (2023) One fits all: power general time series analysis by pretrained lm. Advances in neural information processing systems 36, p. 43322–43355. Cited by: §1.