From Retrieval to Recognition:Knowledge-Enhanced Post-training of Time Series Foundation Models for Classification

Introduction

Time series data are widespread in critical domains such as traffic monitoring [1], medical diagnosis [2], and action recognition [3, 4]. As a core task in time series analysis, time series classification (TSC) aims to extract discriminative patterns in sequences with complex temporal dynamics to distinguish categories [5]. During the past decades, TSC methods have evolved from distance-based approaches [6, 7], to feature-engineering strategies such as the Rocket family [8, 9, 10], and to supervised deep learning models [11, 12, 13]. More recently, inspired by the success of pretraining, TSFMs have emerged as a promising research direction [14, 15, 16]. This shift advances TSC toward general-purpose modeling, utilizing large-scale pretraining to support diverse classification tasks.

Existing TSFMs for classification typically employ a pretraining paradigm that exploits extensive, multi-domain datasets [17, 18]. This process can be regarded as a critical knowledge learning stage (Figure 1a), where the model captures rich discriminative patterns from the pretraining dataset [19, 20]. Through this stage, explicit class patterns in raw time series are compressed into implicit, parameterized knowledge encoded within model weights [21, 22]. Hence, pretrained TSFMs serve as knowledge carriers, providing superior parameter initialization compared to training from scratch.

Building on pre-trained TSFMs, existing approaches [18, 19, 20] typically employ parameter fine-tuning for knowledge transfer to downstream TSC tasks (Figure 1b). This adaptation is the post-training stage of foundation models [23, 24], for which supervised fine-tuning remains the dominant instantiation in TSC. However, parameter-only fine-tuning discards pretraining data, limiting access to informative numerical patterns in the source corpus. Task-relevant knowledge remains entangled with irrelevant information in large parameter spaces, hindering precise activation of useful knowledge for transfer. Moreover, prior studies [21, 25] show that simply scaling model parameters does not consistently improve TSC performance. These observations motivate a key question: beyond parameter-based transfer, can explicit data-level knowledge from the pretraining dataset be leveraged to enable more effective transfer?

A straightforward way to incorporate data-level knowledge is to reuse pretraining data during fine-tuning. However, large-scale pretraining datasets make direct reuse inefficient for transfer. In TSC, performance mainly depends on capturing class-relevant patterns in input data, such as discriminative subsequences [26, 27, 28]. These patterns are often sparsely distributed and mixed with substantial noise and class-irrelevant variations [29, 30]. Inspired by retrieval-augmented methods in pretrained language models [31, 32], we argue that constructing query embeddings for input time series and retrieving feature-similar class patterns from pretraining datasets, yielding explicit instance-level knowledge. This retrieval process filters irrelevant samples while focusing on class-relevant patterns, providing more direct data-level knowledge than parameter-only fine-tuning.

Therefore, we propose Retrieval-to-Recognition (R2R), a plug-and-play post-training framework that advances pretrained TSFMs from retrieval to recognition (Figure 1c). R2R goes beyond parameter-based transfer by introducing a dedicated query encoder to efficiently retrieve class-relevant patterns from large-scale pretraining datasets. The query encoder captures local and global features with positional information to identify feature-level class patterns for each input time series, enabling explicit acquisition of data-level knowledge. The retrieved patterns are then integrated with the pretrained TSFM’s parameter-derived embeddings, allowing the TSFM to effectively recall task-relevant patterns from the pretraining corpus for accurate transfer. This retrieval-driven paradigm mitigates the limitations of parameter-only approaches by enabling feature-level transfer, offering a new post-training paradigm for TSC.

Our main contributions are summarized as follows:

• We introduce R2R, a plug-and-play post-training framework for TSC that enhances pretrained TSFMs by utilizing external numerical knowledge derived from a constructed pretraining knowledge base, facilitating instance-level knowledge integration beyond parameter-only transfer, without modifying the original pretraining process of TSFMs.

• We design a decoupled query encoder with a gradient-free backbone to efficiently extract and retrieve discriminative numerical patterns, enabling multi-domain inputs to access class-relevant patterns for each query instance and to bridge retrieval with downstream TSC.

• Experiments on 158 datasets demonstrate that R2R consistently improves classification performance of existing pretrained TSFMs in both supervised fine-tuning and zero-shot feature extraction, with further analyses confirming the effectiveness of each module.

Related work

Foundation models for time series classification

Deep learning has made significant progress in TSC due to its strong representation learning capability [33, 34, 35, 36, 37]. Early studies [38, 33, 11] demonstrated that end-to-end convolutional models serve as strong supervised baselines for TSC. Subsequent work [39, 40, 14] explored transfer learning, showing that pretraining improves classification performance across datasets. With the rise of large-scale pretraining, TSFMs have become a major research focus [15]. Studies [17, 18, 21] further indicate that models pretrained on large time series corpora learn more general and classification-oriented representations. Building on this paradigm, recent approaches [41, 19, 22, 20, 42] further improve pretraining strategies and model architectures, achieving strong generalization across diverse TSC tasks. However, existing TSFMs primarily rely on implicit parameter-based transfer, that is, on supervised fine-tuning as the sole post-training mechanism [24], overlooking the potential gains from explicit numerical instances inherent in the pretraining dataset.

Time series retrieval augmented models

Retrieval-augmented methods [43, 31, 32] have shown strong performance in NLP by enhancing large language models with task-relevant information retrieved from external knowledge bases. Inspired by this paradigm, recent work [44, 45] introduces retrieval mechanisms into time series modeling. For forecasting tasks, prior studies [46, 47, 48, 44] retrieve relevant historical sequences and temporal patterns to guide future value prediction, while other methods [49, 50] build structured time series knowledge bases for cross-domain retrieval and improved zero-shot forecasting. Despite these advances, retrieval-augmented methods for classification remain underexplored. This gap is non-trivial, as forecasting and classification require fundamentally different retrieval targets: forecasting extrapolates future trends from long historical observations [48], whereas classification focuses on identifying discriminative patterns within fixed-length observation windows [11]. To address this limitation, we design a dedicated query encoder to retrieve instance-level discriminative patterns from a class-relevant numerical feature space. The retrieved knowledge is integrated into the fine-tuning process of pretrained TSFMs, enabling a retrieval-to-recognition framework for TSC.

Problem definition

This work focuses on univariate TSC using TSFMs [15, 33]. Let $x \in\mathbb{R}^{L}$ denote a univariate time series sample of length $L$. The goal is to predict its corresponding class label $y \in\{1, 2, \ldots, C\}$, where $C$ represents the number of classes in the target downstream dataset $\mathcal{D}_t$. Given a pretrained TSFM denoted by $\mathcal{F}(\cdot)$, conventional paradigms facilitate knowledge transfer solely through parameter fine-tuning. In contrast, we introduce an explicit knowledge base $\mathcal{D}_k = \{x_i\}_{i=1}^{N}$ constructed from large-scale, multi-domain pretraining corpora [18]. For a given query $x$, a retrieval mechanism is designed to identify numerically similar and class-discriminative patterns from $\mathcal{D}_k$, yielding a knowledge-enhanced representation $z_{\mathrm{aug}}$. The final classification is performed by combining the implicit parametric knowledge stored in $F(\cdot)$ with the retrieved explicit numerical knowledge $\mathbf{z}_{\mathrm{aug}}$, enabling effective knowledge transfer on the target dataset $D_t$.

Methodology

Overview

As shown in Figure 2, R2R consists of three modules: knowledge extraction (§ 4.2), knowledge retrieval (§ 4.3), and knowledge enhancement (§ 4.4). The knowledge extraction module (§ 4.2) applies multi-scale downsampling to the input data and uses a gradient-free backbone to extract class-relevant features through local, global, and positional information. These features are projected into compact embeddings for both query embedding $\mathbf{z}_q$ and knowledge base construction. The knowledge retrieval module (§ 4.3) uses knowledge base embeddings as keys and $\mathbf{z}_q$ to retrieve Top-$K$ similar instances. Optimal transport [51] is applied to compute distances and produce a weighted aggregation, yielding the augmented embedding $\mathbf{z}_{\mathrm{aug}}$. The knowledge enhancement module (§ 4.4) fuses the TSFM class token $\mathbf{z}_c$, $\mathbf{z}_q$, and $\mathbf{z}_{\mathrm{aug}}$ via a fusion layer. Finally, the model is trained with a classification loss, enabling parameter transfer while incorporating retrieved numerical knowledge for downstream TSC.

Knowledge extraction

The knowledge extraction module maps both time series samples from the pretraining knowledge base $D_k$ and target query inputs $\mathbf{x} \in\mathbb{R}^{L}$ from $D_t$ into compact, class-discriminative embeddings for efficient retrieval. For this purpose, we adopt a gradient-free backbone as the core feature extractor, operating with frozen parameters to extract features from the input time series without training. Prior work [8, 9, 10] shows that convolutional models with randomly or fixed initialized parameters provide strong feature representations for TSC. Similarly, pretrained TSFMs [19, 20, 25] can produce discriminative embeddings without fine-tuning. However, these approaches primarily focus on local features from single-scale inputs, often neglecting global dependencies and positional structure. To mitigate this issue, we design the knowledge extraction module to capture discriminative numerical information from three aspects: local patterns, global patterns, and positional patterns.

Local patterns. We employ a gradient-free backbone to extract local features directly from the raw single-scale input $\hat{x} \in\mathbb{R}^{L}$, where $\hat{x}$ may originate from either the pretraining knowledge base $D_k$ or the target domain $D_t$. The backbone is model-agnostic with frozen parameters. The resulting local embedding is defined as

where $\phi(\cdot)$ denotes the gradient-free feature, which takes an input of arbitrary length and returns a fixed-dimensional vector by pooling over the temporal axis.

Although $f_{\mathrm{raw}}$ captures local temporal patterns, it may be less sensitive to variations in signal intensity and local energy distribution [52]. To address this, we introduce an instantaneous envelope feature that emphasizes amplitude-related characteristics. Specifically, given $\hat{x}$, we compute

where $l$ denotes the sliding window (or fixed-length subsequence) size, and $[\cdot]_{t}$ denotes the $t$-th pooled entry. This feature highlights local energy concentration and peak amplitude variations [53], capturing signal intensity dynamics from a feature engineering perspective.

Global patterns. To capture global temporal patterns beyond local embeddings, we construct multi-scale inputs via temporal downsampling. Existing methods [8, 19], including the local pattern module, mainly operate on the original sequence, limiting their ability to model long-range discriminative patterns. Prior studies [54, 55] indicate that downsampling generates sparse sequences that retain key temporal structures while enlarging the receptive field, facilitating global pattern learning over longer horizons. Given an input $\hat{x} \in\mathbb{R}^{L}$, we generate scale-specific embeddings as

where $\operatorname{Downsample}(\cdot,s)$ denotes a stride-based temporal subsampling operator that selects sparse time steps at interval $s$, i.e. it keeps every $s$-th sample without applying an anti-aliasing low-pass filter, so it is not a band-limited resampling operation, and $\phi(\cdot)$ is the backbone defined in Eq. (1). This design enables the model to capture broader temporal context by leveraging sparse observations over longer horizons.

However, larger downsampling scales may overlook critical transition points that capture fine-grained temporal dynamics. To mitigate this issue, we compute first-order differences $\Delta x_t = x_{t+1} - x_t$ and define a turning point indicator $\mathbb{I}((\Delta x_t \cdot\Delta x_{t+1}) < 0)$ to detect sign changes, and further introduce a turning-point density-based scalar gating mechanism:

which provides a lightweight feature extraction design that enhances global patterns.

Positional patterns. In TSC, similar discriminative patterns may correspond to different classes depending on their time point positions [56]. Hence, we construct a positional feature based on the relative peak location by combining local patterns and turning-point information as follows:

where $\oplus$ denotes concatenation and the last term denotes the normalized time index of the maximum-amplitude point. This feature captures the temporal placement of salient patterns and aids in distinguishing classes that differ primarily by pattern location.

Finally, we concatenate the local, global, and positional patterns and map them into a unified embedding space via a lightweight projection layer:

where $\psi(\cdot)$ denotes a learnable projection function. This formulation integrates class-related features into a discriminative embedding for retrieval. Notably, the computation of $f_{\mathrm{raw}}$, $f_{\mathrm{ds},s}$, $f_{\mathrm{gated}}$, $f_{\mathrm{pos}}$ do not require gradient-based optimization and can be efficiently obtained in a training-free manner.

Knowledge retrieval

Through Eq. (6) in the knowledge extraction module, the embeddings of the knowledge base $\mathcal{D}_k$ are collected into the set $\mathcal{Z}_S = \{z_{S,i} \in\mathbb{R}^{d}\}_{i=1}^{N}$, while a query input $\mathbf{x} \in\mathbb{R}^{L}$ from $\mathcal{D}_t$ is mapped to a query embedding $z_q \in\mathbb{R}^{d}$. The retrieval module aims to efficiently identify the Top-$K$ nearest neighbors of $z_q$ from $\mathcal{Z}_S$, and construct a feature-level augmented representation $z_{\mathrm{aug}}$.

To perform efficient nearest neighbor search, we first normalize the embeddings obtained from the knowledge extraction module:

The normalized embeddings are indexed via inverted file system with product quantization (IVFPQ) [57], which partitions the embedding space into $n_{\mathrm{list}}$ Voronoi cells and encodes residuals with product quantization, forming an index structure:

where $m$ denotes the number of subspaces and $b$ the number of bits per subspace. In practice, this index is implemented using a GPU-accelerated inverted file system based on Faiss [58], enabling a scalable and efficient creation. Given a query embedding, the Top-$K$ nearest neighbors are retrieved from the index $\mathcal{I}$ based on cosine similarity:

During querying, only a small subset of Voronoi cells ($n_{\mathrm{probe}} \ll n_{\mathrm{list}}$) is visited, leading to sublinear complexity with respect to the database size. Specifically, the search cost scales as $\mathcal{O}\left(n_{\mathrm{probe}} \cdot\frac{N}{n_{\mathrm{list}}} \cdot m\right)$, where $N$ is the database size and $m$ is the number of product quantization subspaces [57]. This formulation allows efficient Top-$K$ retrieval even for large-scale databases. With parallel GPU execution [58], the retrieval latency remains at the millisecond level when $N \leq10^6$.

To account for varying relevance among retrieved samples, we introduce an optimal transport (OT) weighting scheme [59]. The transport cost and normalized weights are defined as

where $\varepsilon> 0$ controls smoothness and $\epsilon$ ensures numerical stability. This formulation uses OT distances to evaluate similarity in the underlying feature distribution space [51], yielding more reliable weights for feature aggregation. The final augmented representation is computed as

which preserves both retrieved knowledge and query-specific information in a unified form.

Knowledge enhancement

This module integrates the implicit parametric embedding (class token) from pretrained TSFMs with the explicit numerical knowledge produced by the query encoder, which consists of the knowledge extraction and retrieval modules. The fused embedding is then used for supervised classification in the target domain, enabling joint transfer of parametric and retrieved numerical knowledge.

Knowledge fusion. Let $z_c \in\mathbb{R}^{d}$ denote the class token from pretrained TSFMs. Given the query embedding $z_q$ and the retrieved representation $z_{\mathrm{aug}}$ produced by the query encoder, we perform gated residual fusion:

where $\sigma(\cdot)$ is the sigmoid function, $\mathbf{W}_q, \mathbf{W}_r$ are learnable matrices, and $\odot$ denotes element-wise multiplication. This formulation adaptively integrates parametric and retrieval-based information while maintaining class-related feature fusion. The inclusion of $z_q$ further injects task-specific supervision into the projection learning in Eq. (6), improving the alignment between query-conditioned representations and discriminative patterns in the knowledge base.

Supervised fine-tuning. The fused representation $z_{\mathrm{fused}}$ is directly fed into the lightweight classifier $H(\cdot)$, and the model is optimized using the cross-entropy objective:

where $p_{i,y_i}$ denotes the predicted probability for the ground-truth class $y_i$. During fine-tuning, gradients are propagated through the pre-trained TSFM and the projection layers in the knowledge extraction module. This enables coordinated optimization of parametric representations and retrieval-based knowledge alignment for improved classification performance.

Experiments

We evaluate R2R on univariate time series classification across 128 UCR datasets [60] under a fully supervised fine-tuning setting. For the retrieval process in R2R, we construct a knowledge base from the pretraining datasets of NuTime [18], Mantis [19], and UniShape [20], which collectively comprise 1.89M (million) samples drawn from the training sets of multi-domain datasets [60, 61, 62, 63]. From this pool, we derive a class-balanced subset of 100K (thousand) samples to form the final knowledge base for efficient retrieval. Following [20], we also evaluate generalization on 30 additional univariate time series datasets [64] in a zero-shot feature extraction setting. Further details on datasets, baselines, and implementation settings are provided in Appendix § 8.

Main results

This section evaluate R2R by integrating three advanced TSFMs [18, 19, 20], denoted as R2R$_{\mathrm{NuTime}}$, R2R$_{\mathrm{Mantis}}$, and R2R$_{\mathrm{UniShape}}$, and compare them with 18 baselines, including non-deep learning (Non-DL) methods (Rocket [8], Mini-Rocket [9], RDST [55], MultiRocket-Hydra (MR-H) [65], HIVE-COTE 2.0 (HC-2) [66]), supervised neural learning (S-DL) models (Inception Time [11], TS2Vec [67], PatchTST [68], TimesNet [69], SoftShape [70], MambaSL [13]), and TSFM-based methods (GPT4TS [71], MOMENT [17], UniTS [21], NuTime [18], TS-RAG [49], Mantis [19], UniShape [20]). We report average rank based on test classification accuracy and the number of datasets with the best accuracy (Win) on 128 UCR datasets to reduce bias from abnormally high or low accuracy results on individual datasets. All baselines and R2R variants are run under the same evaluation protocol: the official UCR train/test splits, the officially released hyperparameters of each method, and the same hardware budget, so the reported ranks are not confounded by extra tuning granted to R2R (see Appendix § 8). In addition, we assess statistical significance using the Wilcoxon signed-rank test (p-value) and critical difference (CD) diagrams [72]. A p-value below 0.05 indicates significant pairwise differences, while CD diagrams provide a global comparison in which lower CD values denote better performance and methods not connected by a solid line differ significantly.

Table 1 reports the results of comparing the test classification accuracy among 21 methods (including three R2R variants) on 128 UCR datasets; detailed results are provided in Appendix § 9. $R2R$ consistently improves all three integrated TSFMs, with $R2R_{\mathrm{UniShape}}$ achieving the best overall performance, significantly outperforming all baselines as confirmed by the Wilcoxon $p$-values (all $< 0.05$) and CD diagram in Figure 3a. Similar improvements are observed for $R2R_{\mathrm{NuTime}}$ and $R2R_{\mathrm{Mantis}}$, indicating that retrieval-based knowledge enhancement provides consistent gains beyond parameter-only transfer. Among baselines, Non-DL methods (e.g., Rocket family [65], HIVE-COTE 2.0 [66]) remain strong competitors. TSFMs generally outperform S-DL methods due to large-scale pretraining, with Mantis and UniShape achieving the strongest baseline results, yet they rely solely on implicit parameter transfer. TS-RAG [49], the only retrieval-augmented baseline, ranks 9.31 with 11 wins and thus performs worse than the classification-oriented TSFMs (i.e., Mantis and UniShape) and all three R2R variants, although it retrieves from the same knowledge base as R2R. This gap therefore reflects the classification-specific retrieval and fusion design rather than the retrieved corpus, and shows that R2R improves the post-training stage without introducing a new backbone or pretraining objective. In summary, the results demonstrate that retrieval-based knowledge effectively enhances parametric representations for TSC, enabling more positive transfer and improving TSFMs under a retrieval-to-recognition paradigm.

Comparison results on zero-shot feature extraction

To further evaluate the effectiveness of retrieval-based numerical knowledge, we follow the setups of [19, 20] and assess R2R under a zero-shot feature extraction setting. Specifically, both the default training and test sets are passed through parameter-frozen TSFMs to obtain embeddings, which are then used to train and evaluate a Random Forest classifier, with no model parameter fine-tuning. We conduct experiments on 30 additional datasets and compare against 11 baselines, including a Random Forest (RF) [73] classifier on raw time series inputs and 10 TSFMs (GPT4TS [71], MOMENT [17], Chronos [74], Moirai [75], UniTS [21], NuTime [18], Mantis [19], UniShape [20], TS-RAG [49], and TSPulse [25]). R2R is built upon pre-trained UniShape in this setting. Note that the same Random Forest serves both as the shared probing classifier over TSFM embeddings and, as the RF baseline, as a classifier fitted on the raw series, so Table 2 reports one RF column (see Appendix § 8).

As shown in Table 2 and Figure 3b, R2R achieves the best performance and consistently yields statistically significant improvements over all baselines. The detailed results of Table 2 are presented in Appendix § 10. We observe that classification-oriented TSFMs (NuTime [18], Mantis [19], UniShape [20]) generally outperform forecasting-oriented models (Chronos [74], Moirai [75]), indicating the importance of task alignment. While TS-RAG [49] improves Chronos via retrieval originally proposed for forecasting tasks, it remains inferior to R2R due to its lack of a classification-specific design. As the TS-RAG method is built on the same knowledge base as R2R in this setting (Appendix § 10), the gap in average rank (3.97 vs. 1.73) is attributable to the classification-specific retrieval target and fusion rather than to the retrieved corpus. On the whole, without any task-specific parameter fine-tuning, R2R uses retrieval-based feature-level knowledge for downstream time series classification, achieving substantially better performance than TSFMs that rely solely on parameter-based transfer.

Metric	RF	GPT4TS	MOMENT	Chronos	Moirai	UniTS	NuTime	Mantis	UniShape	TS-RAG	TSPulse	R2R
Avg. Rank	5.80	9.00	6.53	6.33	9.00	11.87	5.63	5.80	5.20	3.97	5.37	1.73
Win	2	1	1	2	1	0	0	1	1	5	1	21
P-value	8.52E-06	1.28E-05	1.43E-06	1.30E-05	9.31E-08	2.05E-08	2.11E-05	2.64E-05	8.20E-07	1.33E-04	9.31E-08	-

Ablation studies

This section presents ablation studies to analyze each component of R2R under two settings: (i) w/o Feature transfer, where the query encoder is removed and only the pretrained TSFM is fine-tuned; and (ii) w/o Parameter transfer, where the pretrained TSFM is removed and classification relies solely on the query encoder, with further ablations on knowledge retrieval and gradient-free backbone selection. As shown in Table 3, removing feature transfer significantly degrades performance, indicating the importance of retrieval-based numerical knowledge. Under w/o Parameter transfer, using MiniRocket [9] as the backbone, the knowledge retrieval module (with Retrieval) improves TSC results (e.g., Avg. Rank: 4.14 vs. 5.09), while removing the retrieval module (w/o $z_{\mathrm{aug}}$) and multi-scale global and positional patterns in the knowledge extraction module (w/o ReMGP) further reduces performance, showing its role in enhancing embedding discriminability. We also compare gradient-free backbones for the query encoder, where MultiRocket [10] performs best but shows limited gains over parameter-frozen UniShape [20], while outperforming Rocket [8].

Overall, all w/o Parameter transfer variants perform substantially worse than full R2R$_{\mathrm{UniShape}}$ and even underperform w/o Feature transfer, suggesting that pretrained TSFM parameter transfer via supervised fine-tuning is the main knowledge source, while retrieval-based feature transfer provides further improvements. These variants also indicate whether the improvement is inherited from the strong Rocket-family extractors used by the query encoder: Rocket and MiniRocket rank only 7.62 and 7.75 in Table 1, well behind parameter-only UniShape (4.47) and R2R$_{\mathrm{UniShape}}$ (3.01), and here a parameter-frozen UniShape query encoder (4.52) is comparable to MultiRocket (4.06), so R2R is not tied to the Rocket family. Since every w/o Parameter transfer variant stays far behind full R2R$_{\mathrm{UniShape}}$ (1.48 with 86 wins), the gain originates from jointly fine-tuning retrieved numerical knowledge with pretrained TSFM parameters rather than from a stronger feature extractor.

Method	Avg. Rank	Win	P-value
Non-DL
Rocket	7.62	18	1.01E-13
MiniRocket	7.75	13	1.82E-13
RDST	7.38	20	1.12E-11
MR-H	6.27	22	2.04E-10
HC-2	5.16	31	3.62E-07
S-DL
InceptionTime	9.41	13	1.56E-15
TS2Vec	12.65	8	1.25E-18
PatchTST	18.19	6	1.20E-20
TimesNet	17.11	5	9.47E-21
SoftShape	9.20	14	2.03E-14
MambaSL	13.13	14	7.37E-18
TSFMs
GPT4TS	17.06	4	9.47E-21
MOMENT	17.58	2	8.47E-21
UniTS	16.74	2	5.93E-21
NuTime	10.26	15	2.21E-15
TS-RAG	9.31	11	1.44E-16
Mantis	8.07	21	8.43E-12
UniShape	4.47	31	1.68E-04
Ours
R2RNuTime	7.90	23	5.64E-12
R2RMantis	6.18	29	2.31E-07
R2RUniShape	3.01	48	-

Table 4 studies the impact of the knowledge base in R2R using 18 representative UCR datasets following [20] for efficient analysis under large-scale retrieval. A class-balanced subset of 100K samples from the pretraining dataset achieves the best trade-off between accuracy and efficiency. Here, Time (s) denotes the additional average time for knowledge extraction and retrieval with the R2R query encoder across the 18 datasets. Increasing the knowledge base from 50K to 100K introduces only minor overhead (about 4 seconds per dataset), while scaling to 1.89M samples raises the time by about 4.5×. Yet, the time cost remains manageable (within 7 minutes per dataset). Moreover, Table 4 indicates that both class diversity and distribution balance are critical for effective numerical knowledge transfer. Detailed results of Table 3 and Table 4 are provided in Appendix § 11.

Table 3: Test accuracy results of ablation study on 128 UCR time series datasets.

Method	Backbone	Avg. Rank	Win	P-value
R2R$_{\mathrm{UniShape}}$	-	1.48	86	-
w/o Feature transfer	-	2.45	48	1.68E-04
w/o Parameter transfer, with Retrieval	MiniRocket	4.14	13	3.60E-18
w/o Parameter transfer, w/o Retrieval	MiniRocket	5.09	11	1.58E-18
w/o Parameter transfer, w/o ReMGP	MiniRocket	5.59	8	4.56E-19
w/o Parameter transfer, w/o Retrieval	Rocket	5.91	8	9.56E-19
w/o Parameter transfer, w/o Retrieval	MultiRocket	4.06	18	4.69E-17
w/o Parameter transfer, w/o Retrieval	UniShape	4.52	13	5.58E-19

Table 4: Test accuracy results on 18 UCR datasets under varying knowledge base sizes and sampling strategies.

Size	Sampling	Avg. Rank	Win	Time (s)
50K	Balanced	4.11	3	88.01
100K	Balanced	2.33	8	92.11
200K	Balanced	3.28	9	119.79
500K	Balanced	3.11	6	207.49
1M	Balanced	3.17	6	361.77
1.89M	Balanced	4.17	5	414.80
100K	Random	3.17	5	92.11
100K	Unbalanced	6.50	2	92.11

Knowledge-enhanced analysis

To analyze how R2R utilizes retrieved embeddings for knowledge enhancement, we visualize target sample representations using the t-SNE [76] method. Figure 4a shows embeddings from the pretrained UniShape based on parameter fine-tuning, Figure 4b shows embeddings from the retrieval module in R2R, and Figure 4c shows the fused embeddings combining parameter- and feature-level knowledge for final TSC. In Figure 4a, classes 1 and 2 are partially mixed, whereas Figure 4b and Figure 4c exhibit clearer separation. These results indicate that R2R retrieves class-discriminative features from the pretraining knowledge base, improving inter-class separability. Additional visualizations in Appendix § 12 further confirm consistent gains across different datasets and multi-class settings.

To verify the effectiveness of R2R for retrieval-based numerical knowledge enhancement, Table 5 compares 7 representative time series data augmentation methods [77, 78]. As shown, these methods often degrade performance relative to the Raw setting (fine-tuning without augmentation), indicating negative transfer on many datasets. In contrast, R2R retrieves class-relevant embeddings from a knowledge base to help pretrained TSFMs recall pretraining knowledge for augmentation, thereby improving positive transfer in TSC. This advantage likely stems from reduced randomness compared to conventional stochastic augmentations, which may disrupt intrinsic class structures in time series.

Metric	Raw	Jitter	Time warp	Magnitude warp	Window slice	Time flip	Permutation	Scaling	R2R
Avg. Rank	2.39	5.11	5.06	4.89	4.33	5.06	5.50	4.83	2.00

Finally, we select four datasets from the 30 additional datasets, covering different numbers of classes, to evaluate R2R under continual classification fine-tuning. Table 6 compares standard parameter-only fine-tuning with R2R transfer. R2R consistently outperforms parametric fine-tuning alone on $\mathrm{Acc}_{A1}$ and $\mathrm{Acc}_{A2}$, and exhibits less forgetting after continual fine-tuning, indicating that retrieved embeddings help mitigate pre-trained knowledge forgetting and improve transfer generalization across downstream tasks. Additional results for continual fine-tuning, together with data augmentation descriptions and detailed results in Table 5, are presented in Appendix § 12. Appendix § 13 reports hyperparameter analysis, and Appendix § 14 reports a preliminary multivariate evaluation in which $\mathrm{R2R}_{\mathrm{UniShape}}$ is extended to ten UEA datasets [61] through a trainable linear channel adapter. Appendix § 15 and I provide limitations and broader impacts.

Dataset A	Dataset B	Only parameter transfer			R2R transfer
		AccA1	AccA2	Forgetting	AccA1	AccA2	Forgetting
AsphaltRegularityUni_eq	FloodModeling1_disc	0.9654	0.4887	0.4767	0.9734	0.7909	0.1825
GesturePebbleZ1_eq	Colposcopy	0.9477	0.5233	0.4244	0.9535	0.7151	0.2384
AllGestureWiimoteX_eq	AllGestureWiimoteY_eq	0.7671	0.2429	0.5242	0.7786	0.2771	0.5015
GestureMidAirD1_eq	GestureMidAirD2_eq	0.7538	0.1231	0.6307	0.7692	0.1538	0.6154

Conclusion

This paper presents R2R, a retrieval-to-recognition post-training framework that enhances pretrained TSFMs for time series classification. R2R employs a plug-and-play query encoder to retrieve class-relevant numerical knowledge and integrates it with parametric representations for downstream classification. Experiments demonstrate that R2R consistently improves pretrained TSFMs via joint parameter- and feature-level knowledge transfer, attaining the best average rank with 48 wins among 21 baselines on the 128 UCR datasets under supervised fine-tuning and 21 wins among 12 baselines on the 30 additional datasets under zero-shot feature extraction, with all gains being statistically significant ($p < 0.05$). However, R2R acts only at the post-training stage and contributes no new pretraining objective or backbone architecture, and it currently relies on a knowledge base built from univariate time series. A preliminary multivariate extension through a trainable linear channel adapter is reported in Appendix § 14, where $\mathrm{R2R}_{\mathrm{UniShape}}$ attains the best average rank on ten UEA datasets, although the retrieved knowledge itself is still univariate. Future work will explore more general retrieval module designs and build natively multivariate knowledge bases, so that inter-variable dependencies are captured by retrieval rather than by an input adapter.

Acknowledgments

We thank the anonymous reviewers for their helpful feedbacks. We thank Professor Eamonn Keogh and all the people who have contributed to the UCR archive and other time series classification datasets. This work was partially supported by the Singapore NRF AI4S project (NRF-AI4SCH-2025-0001), the Ministry of Education, Singapore, under its Academic Research Fund (AcRF) Tier 1 grant (RG16/25), the SMU-SUTD Internal Research Grant Call (SMU-SUTD 2023_02_01), the SUTD Kickstarter Initiative (SKI 2021_06_12), and AIMfg, A*STAR, Singapore, under its MTI WS Fund. This work was also partially supported by the National Natural Science Foundation of China (Grant Nos. 62272173, 62273109), the Natural Science Foundation of Guangdong Province (Grant Nos. 2024A1515010089, 2022A1515010179), the Science and Technology Planning Project of Guangdong Province (Grant No. 2023A0505050106), and the National Key R&D Program of China (Grant No. 2023YFA1011601).

Experiment setting

Datasets and knowledge base

This study employs the univariate UCR Time Series Archive [60] as the primary benchmark for classification, encompassing 128 datasets from a wide range of real-world domains. Detailed dataset statistics are reported in Table 7. All 128 UCR time series datasets are utilized for fully supervised classification fine-tuning evaluation.

ID	Dataset name	Train size	Test size	No. classes	Length	ID	Dataset name	Train size	Test size	No. classes	Length
1	ACSF1	100	100	10	1460	65	ItalyPowerDemand	67	1029	2	24
2	Adiac	390	391	37	176	66	LargeKitchenAppliances	375	375	3	720
3	AllGestureWiimoteX	300	700	10	Vary	67	Lightning2	60	61	2	637
4	AllGestureWiimoteY	300	700	10	Vary	68	Lightning7	70	73	7	319
5	AllGestureWiimoteZ	300	700	10	Vary	69	Mallat	55	2345	8	1024
6	ArrowHead	36	175	3	251	70	Meat	60	60	3	448
7	Beef	30	30	5	470	71	MedicalImages	381	760	10	99
8	BeetleFly	20	20	2	512	72	MelbournePedestrian	1194	2439	10	24
9	BirdChicken	20	20	2	512	73	MiddlePhalanxOutlineAgeGroup	400	154	3	80
10	BME	30	150	3	128	74	MiddlePhalanxOutlineCorrect	600	291	2	80
11	Car	60	60	4	577	75	MiddlePhalanxTW	399	154	6	80
12	CBF	30	900	3	128	76	MixedShapesRegularTrain	500	2425	5	1024
13	Chinatown	20	343	2	24	77	MixedShapesSmallTrain	100	2425	5	1024
14	ChlorineConcentration	467	3840	3	166	78	MoteStrain	20	1252	2	84
15	CinCECGTorso	40	1380	4	1639	79	NonInvasiveFetalECGThorax1	1800	1965	42	750
16	Coffee	28	28	2	286	80	NonInvasiveFetalECGThorax2	1800	1965	42	750
17	Computers	250	250	2	720	81	OliveOil	30	30	4	570
18	CricketX	390	390	12	300	82	OSULeaf	200	242	6	427
19	CricketY	390	390	12	300	83	PhalangesOutlinesCorrect	1800	858	2	80
20	CricketZ	390	390	12	300	84	Phoneme	214	1896	39	1024
21	Crop	7200	16800	24	46	85	PickupGestureWiimoteZ	50	50	10	Vary
22	DiatomSizeReduction	16	306	4	345	86	PigAirwayPressure	104	208	52	2000
23	DistalPhalanxOutlineAgeGroup	400	139	3	80	87	PigArtPressure	104	208	52	2000
24	DistalPhalanxOutlineCorrect	600	276	2	80	88	PigCVP	104	208	52	2000
25	DistalPhalanxTW	400	139	6	80	89	PLAID	537	537	11	Vary
26	DodgerLoopDay	78	80	7	288	90	Plane	105	105	7	144
27	DodgerLoopGame	20	138	2	288	91	PowerCons	180	180	2	144
28	DodgerLoopWeekend	20	138	2	288	92	ProximalPhalanxOutlineAgeGroup	400	205	3	80
29	Earthquakes	322	139	2	512	93	ProximalPhalanxOutlineCorrect	600	291	2	80
30	ECG200	100	100	2	96	94	ProximalPhalanxTW	400	205	6	80
31	ECG5000	500	4500	5	140	95	RefrigerationDevices	375	375	3	720
32	ECGFiveDays	23	861	2	136	96	Rock	20	50	4	2844
33	ElectricDevices	8926	7711	7	96	97	ScreenType	375	375	3	720
34	EOGHorizontalSignal	362	362	12	1250	98	SemgHandGenderCh2	300	600	2	1500
35	EOGVerticalSignal	362	362	12	1250	99	SemgHandMovementCh2	450	450	6	1500
36	EthanolLevel	504	500	4	1751	100	SemgHandSubjetCh2	450	450	5	1500
37	FaceAll	560	1690	14	131	101	ShakeGestureWiimoteZ	50	50	10	500
38	FaceFour	24	88	4	350	102	ShapeletSim	20	180	2	500
39	FacesUCR	200	2050	14	131	103	ShapesAll	600	600	60	512
40	FiftyWords	450	455	50	270	104	SmallKitchenAppliances	375	375	3	720
41	Fish	175	175	7	463	105	SmoothSubspace	150	150	3	15
42	FordA	3601	1320	2	500	106	SonyAIBORobotSurface1	20	601	2	70
43	FordB	3636	810	2	500	107	SonyAIBORobotSurface2	27	953	2	65
44	FreezerRegularTrain	150	2850	2	301	108	StarLightCurves	100	8236	3	1024
45	FreezerSmallTrain	28	2850	2	301	109	Strawberry	613	370	2	235
46	Fungi	18	186	18	201	110	SwedishLeaf	500	625	15	128
47	GestureMidAirD1	208	130	26	Vary	111	Symbols	25	995	6	398
48	GestureMidAirD2	208	130	26	Vary	112	SyntheticControl	300	300	6	60
49	GestureMidAirD3	208	130	26	Vary	113	ToeSegmentation1	40	228	2	277
50	GesturePebbleZ1	132	172	6	Vary	114	ToeSegmentation2	36	130	2	343
51	GesturePebbleZ2	146	158	6	Vary	115	Trace	100	100	4	275
52	GunPoint	50	150	2	150	116	TwoLeadECG	23	1139	2	82
53	GunPointAgeSpan	135	316	2	150	117	TwoPatterns	1000	4000	4	128
54	GunPointMaleVersusFemale	135	316	2	150	118	UMD	36	144	3	150
55	GunPointOldVersusYoung	136	315	2	150	119	UWaveGestureLibraryAll	896	3582	8	945
56	Ham	109	105	2	431	120	UWaveGestureLibraryX	896	3582	8	315
57	HandOutlines	1000	370	2	2709	121	UWaveGestureLibraryY	896	3582	8	315
58	Haptics	155	308	5	1092	122	UWaveGestureLibraryZ	896	3582	8	315
59	Herring	64	64	2	512	123	Wafer	1000	6164	2	152
60	HouseTwenty	40	119	2	200	124	Wine	57	54	2	234
61	InlineSkate	100	550	7	1882	125	WordSynonyms	267	638	25	270
62	InsectEPGRegularTrain	62	249	3	601	126	Worms	181	77	5	900
63	InsectEPGSmallTrain	17	249	3	601	127	WormsTwoClass	181	77	2	900
64	InsectWingbeatSound	220	1980	11	256	128	Yoga	300	3000	2	426

For the retrieval module in R2R, the knowledge base is constructed from the pretraining dataset adopted in prior studies [18, 19, 20]. This pretraining dataset integrates the default training sets from the UCR Time Series Archive [60], the UEA Time Series Archive [61], and eight other domain-specific time series datasets [62, 63], resulting in approximately 1.89 million univariate samples. Given the pronounced class imbalance in this aggregated dataset, directly incorporating all samples would incur substantial computational overhead and may degrade retrieval quality. To alleviate this issue, we construct a class-balanced knowledge-base sampling strategy that ensures a minimum of 50 and a maximum of 1,000 samples per class. This procedure yields a balanced subset of approximately 100,000 (100K) samples, preserving class diversity while preventing over-representation of dominant classes and reducing retrieval cost.

Following [20], we further assess zero-shot feature extraction on 30 additional univariate time series datasets [64]. This evaluation protocol examines the capability of R2R to enhance time series classification performance without gradient-based optimization. Detailed statistics of these 30 additional time series datasets are summarized in Table 8.

ID	Dataset name	Train size	Test size	Length	No. classes	Category
1	AconityMINIPrinterLarge_eq	2403	1184	300	2	Sensor
2	AconityMINIPrinterSmall_eq	589	292	300	2	Sensor
3	AllGestureWiimoteX_eq	300	700	500	10	Motion
4	AllGestureWiimoteY_eq	300	700	500	10	Motion
5	AllGestureWiimoteZ_eq	300	700	500	10	Motion
6	AsphaltObstaclesUni_eq	390	391	736	4	Sensor
7	AsphaltPavementTypeUni_eq	1055	1056	2371	3	Sensor
8	AsphaltRegularityUni_eq	751	751	4201	2	Sensor
9	Colposcopy	99	101	180	6	Image
10	Covid3Month_disc	140	140	84	3	Other
11	DodgerLoopDay_nmv	67	77	288	7	Sensor
12	DodgerLoopGame_nmv	17	127	288	2	Sensor
13	DodgerLoopWeekend_nmv	18	126	288	2	Sensor
14	ElectricDeviceDetection	624	3768	256	2	Image
15	FloodModeling1_disc	471	471	266	2	Simulated
16	FloodModeling2_disc	466	466	266	2	Simulated
17	FloodModeling3_disc	429	429	266	2	Simulated
18	GestureMidAirD1_eq	208	130	360	26	Motion
19	GestureMidAirD2_eq	208	130	360	26	Motion
20	GestureMidAirD3_eq	208	130	360	26	Motion
21	GesturePebbleZ1_eq	132	172	455	6	Motion
22	GesturePebbleZ2_eq	146	158	455	6	Motion
23	KeplerLightCurves	920	399	4767	7	Sensor
24	MelbournePedestrian_nmv	1138	2319	24	10	Sensor
25	PhoneHeartbeatSound	424	182	3053	5	Other
26	PickupGestureWiimoteZ_eq	50	50	361	10	Motion
27	PLAID_eq	537	537	1345	11	Device
28	ShakeGestureWiimoteZ_eq	50	50	385	10	Motion
29	SharePriceIncrease	965	966	60	2	Other
30	Tools	310	134	2926	5	Other

Baselines

Supervised classification on 128 UCR datasets. We consider 18 baselines spanning non-deep learning methods, end-to-end supervised deep models, and pre-trained time series foundation models.

• Rocket²: Dempster et al. [8] propose Rocket, which applies a large collection of random convolutional kernels with random initialization parameters to extract features, followed by a ridge classifier for efficient time series classification.

• MiniRocket³: Dempster et al. [9] introduce MiniRocket, a deterministic variant of Rocket with fixed initialization parameters that significantly improves computational efficiency while maintaining similar or higher classification performance.

• RDST⁴: Guillaume et al. [55] present RDST, which extends shapelet-based methods by incorporating multi-scale dilation into randomly sampled subsequences for time series classification.

• MultiROCKET-Hydra (MR-H)⁵: Dempster et al. [65] propose Hydra, a hybrid approach that combines convolutional kernel transforms with dictionary-based representations using competing kernels.

• Hive-COTE 2.0 (HC-2)⁶: Middlehurst et al. [66] develop Hive-COTE 2.0, an ensemble framework integrating classifiers from multiple representations, including shapelets, intervals, and dictionary-based features.

• InceptionTime⁷: Ismail Fawaz et al. [11] propose InceptionTime, an ensemble of deep CNNs with Inception-style modules to capture multi-scale temporal dependencies for classification.

• TS2Vec⁸: Yue et al. [67] introduce TS2Vec, which learns robust timestamp-level representations through hierarchical contrastive learning over augmented context views.

• PatchTST{sup}8: Nie et al. {citep}[68]` propose PatchTST, which segments time series into patches as Transformer tokens and adopts channel-independent modeling for representation learning.

• TimesNet{sup}9: Wu et al. {citep}[69]` introduce TimesNet, which transforms 1D time series into 2D space based on periodic patterns for general time series modeling.

• SoftShape{sup}10: Liu et al. {citep}[70]` propose SoftShape, which replaces hard shapelet filtering with learnable soft shapelets for flexible subsequence selection and classification.

• MambaSL{sup}11: Jung et al. {citep}[13]` introduce MambaSL, which adapts selective state space models with lightweight single-layer Mamba for time series classification.

• GPT4TS{sup}12: Zhou et al. {citep}[71]` propose GPT4TS, a framework that leverages pre-trained language models with patch-based tokenization for time series modeling.

• MOMENT¹⁴: Goswami et al. [17] introduce MOMENT, a family of Transformer models pre-trained via masked time series prediction on large-scale time series datasets.

• UniTS¹⁵: Gao et al. [21] propose UniTS, a unified Transformer framework that integrates multiple time series tasks through task tokenization.

• NuTime¹⁶: Lin et al. [18] introduce NuTime, which employs multi-scale numerical embeddings to support effective pre-training on diverse time series data.

• TS-RAG¹⁷: Ning et al. [49] propose TS-RAG, which augments a pre-trained time series foundation model with patterns retrieved from an external knowledge base through an adaptive retrieval mixer. As TS-RAG is originally designed for zero-shot forecasting, we adapt it to supervised classification by attaching a classification head to its retrieval-augmented representations and fine-tuning it under the same protocol as the other TSFM baselines, with the retrieval knowledge base constructed in the same way as in R2R.

• Mantis¹⁸: Feofanov et al. [19] propose Mantis, a ViT-based foundation model pre-trained via contrastive learning for time-series classification.

• UniShape¹⁹: Liu et al. [20] introduce UniShape, a shape-aware foundation model that integrates adaptive subsequence selection and prototype-based pretraining.

In summary, among the 18 baselines, 14 methods (Rocket, MiniRocket, RDST, MR-H, InceptionTime, TS2Vec, PatchTST, TimesNet, SoftShape, GPT4TS, MOMENT, UniTS, NuTime, and Mantis) follow the same setup as UniShape [20], while Hive-COTE 2.0 [66], MambaSL [13], and TS-RAG [49] are additionally introduced for comparison.

Zero-shot feature extraction on 30 additional datasets. We evaluate 11 baselines for zero-shot feature extraction, including a Random Forest [73] classifier on raw inputs and 10 pre-trained TSFSMs.

• Random Forest²⁰: A classical machine learning classifier without gradient-based optimization [73] that directly operates on raw time series, rather than using representations obtained from pre-trained TSFMs. Two roles of the Random Forest should be distinguished, since a single classifier configuration is used throughout. As the probing classifier, it is fitted on the frozen embeddings produced by each TSFM-based method and applied to the corresponding test embeddings; this is the shared evaluation protocol of the zero-shot setting and is not itself a competing method. As the RF baseline, the same classifier is fitted on the raw series $\mathbf{x} \in\mathbb{R}^{L}$, i.e. the degenerate case in which no pretrained model is involved and the $L$ time steps of a series are passed directly as $L$ ordered input features. Table 2 therefore contains a single RF column, and comparing it against the remaining columns isolates whether TSFM embeddings are more discriminative than the raw series under an identical classifier.

• Chronos²¹: Ansari et al. [74] propose Chronos for time series forecasting, a probabilistic Transformer that tokenizes time series into discrete vocabularies for large-scale pre-training.

• Moirai²²: Woo et al. [75] introduce Moirai, a masked Transformer pre-trained on large multi-domain time series corpora for time series forecasting.

• TS-RAG²³: Ning et al. [49] propose TS-RAG, a retrieval-augmented framework that integrates external patterns through an adaptive retrieval mixer module for zero-shot time series forecasting.

• TSPulse²⁴: Vijay et al. [25] introduce TSPulse for time-series analysis, a lightweight pre-trained model using hybrid masked reconstruction across temporal, spectral, and semantic embedding spaces.

The remaining baselines (GPT4TS, MOMENT, UniTS, NuTime, Mantis, and UniShape) follow the same configurations as in the supervised setting. Compared to existing work [20], we additionally include TS-RAG [49] and TSPulse [25] as new baselines for zero-shot feature extraction classification evaluation.

Implementation details

For supervised fine-tuning, we integrate R2R with three representative pre-trained time series foundation models, namely NuTime [18], Mantis [19], and UniShape [20], and evaluate them on all 128 datasets from the UCR archive. For R2R combined with NuTime and Mantis, the maximum number of training epochs is set to 500 following the original recommendations, while UniShape is trained for up to 300 epochs. For multi-scale feature extraction in Eq. (3), we employ three downsampling factors $\{1, 2, 4\}$ following [54]. The sliding window length $l$ in Eq. (2) is set to 11. In Eq. (8), the $n_{\mathrm{list}}$ is fixed at 256, $m$ is set to 16, and $b$ is set to 8. The number of nearest neighbors $K$ in Eq. (10) is set to 20. For the gradient-free backbone in R2R’s knowledge extraction module, we conduct model selection on each UCR dataset using a validation set sampled from the original training set. The gradient-free backbone is then selected from MiniRocket [9], MultiRocket [10], and the corresponding R2R-enhanced pre-trained TSFM [18, 19, 20] based on validation performance. For zero-shot feature extraction on the additional 30 datasets, we fix the gradient-free backbone to MultiRocket across all experiments to ensure a zero-shot evaluation setting without parameter or model selection. Following prior work [11, 20], we directly use the default training and test splits from the UCR archive for classification evaluation. Model selection is based on the minimum training loss due to the absence of a default validation set. To mitigate potential overfitting, we adopt an ensemble strategy during fine-tuning following [11, 18], where five independently trained models are aggregated to improve generalization with different learning ratios. This ensembling convention is applied consistently to R2R and most supervised deep learning and TSFM-based baselines, following the setting in [20]; MambaSL [13] is reported as a single model because ensembling degraded its accuracy. The Non-DL baselines are gradient-free and follow their official single-model protocols, one of which, HIVE-COTE 2.0 [66], is itself an ensemble of about thirty algorithms drawn from four representation families. For both R2R and all supervised baselines, the reported performance corresponds to the average test accuracy over five runs. All experiments are conducted on a server with two NVIDIA RTX A6000 GPUs, running Ubuntu 20.04.3 with Python 3.9 and PyTorch 1.12.

Knowledge-base provenance and target-data usage. No test sample and no test label of any target dataset is used at any stage of R2R, including pretraining, knowledge-base construction, gradient-free backbone selection, and fine-tuning: the 1.89M source pool aggregates only the default training splits of the datasets listed in Appendix § 8.§ 1. The class-balanced sampler retains source classes with at least 50 samples and caps each class at 1,000, so whether a target dataset can contribute to the knowledge base at all is determined by its per-class training counts. Across the 128 UCR default training splits, no class reaches the 50-sample threshold in 72 datasets, 14 datasets are partly eligible, and 42 have every class eligible; retrieval is therefore strictly cross-dataset on those 72 datasets, whereas for the remaining 56 the knowledge base may contain training samples of the target task. Three controls indicate that the reported gains do not rest on this overlap. First, the full 1.89M pool, which contains every target training split, ranks below the 100K class-balanced subset in Table 4 (4.17 versus 2.33), so adding target training data does not by itself improve R2R. Second, restricting Table 1 to the 72 strictly cross-dataset targets leaves all three improvements intact and slightly larger: the average rank moves from 10.40 to 8.00 for NuTime, from 7.42 to 5.60 for Mantis, and from 4.97 to 3.07 for UniShape, with win/tie/loss counts of 40/15/17, 44/11/17, and 41/16/15. Third, rebuilding a 100K knowledge base that keeps only source classes with at least 381 training samples removes every target class of the 18 datasets in Table 4, whose largest per-class training count is 378, and reduces source-class coverage from 419 to 139; accuracy then changes by only −0.26 and −0.40 percentage points for R2RNuTime and R2RUniShape, with win/tie/loss counts of 7/4/7, that is, no significant difference. We note that this last control excludes target classes by a size threshold rather than by provenance, because the released 1.89M pool does not carry dataset-of-origin labels, which makes a strict leave-one-dataset-out knowledge base infeasible. We also note that pretraining on the target training split alone is standard practice in self-supervised TSC [62, 67], where, as here, the test split remains untouched.

Details of results on 128 UCR datasets

R2RNuTime, R2RMantis, and R2RUniShape, together with the 18 selected baselines, are evaluated under the fully supervised classification setting on 128 UCR time series datasets. The detailed test classification accuracy results are reported in Table 9.

ID	Dataset	Rocket	MiniRocket	RDST	MR-HC	HC2	Inception	TS2Vec	PatchTST	TimesNet	SoftShape	MambaSL	GPT4TS	MOMENT	UniTS	NuTime	TS-RAG	Mantis	UniShape	R2RNuTime	R2RMantis	R2RUniShape
1	ACSF1	0.8600	0.9100	0.9300	0.8600	0.9100	0.9400	0.8800	0.7300	0.3900	0.8800	0.8600	0.6100	0.5000	0.7700	0.6700	0.7500	0.9000	0.8000	0.8200	0.8600	0.9300
2	Adiac	0.7903	0.8235	0.7136	0.8344	0.8184	0.8107	0.7545	0.6675	0.6292	0.8159	0.8777	0.7626	0.1458	0.5115	0.5115	0.8235	0.8159	0.8289	0.8184	0.8440	0.8144
3	All	0.7629	0.7429	0.7714	0.7800	0.7671	0.7729	0.6729	0.2643	0.4529	0.7786	0.6114	0.5029	0.5157	0.6329	0.7086	0.7600	0.7914	0.7743	0.7893	0.7829	0.7786
4	ArrowHead	0.7647	0.7571	0.7371	0.7600	0.7618	0.7729	0.6712	0.2253	0.4529	0.7786	0.6114	0.5029	0.5157	0.6329	0.7086	0.7600	0.7914	0.7743	0.7893	0.7829	0.7786
5	ArticularyWordRecognition	0.8086	0.7314	0.6860	0.8629	0.9086	0.7771	0.7371	0.6971	0.4486	0.8457	0.5900	0.4071	0.4886	0.5700	0.6614	0.7300	0.586	0.7429	0.6743	0.7300	0.7657
6	BME	0.8000	0.8667	0.8333	0.8667	0.8667	0.8333	0.8000	0.9733	0.6400	0.8540	0.7429	0.8057	0.5657	0.7543	0.8343	0.8971	0.8667	0.8867	0.9567	0.9200	0.8333
7	Beef	0.5000	0.8667	0.8333	0.8667	0.8667	0.8333	0.7333	0.6667	0.6667	0.9200	0.6000	0.5000	0.5333	0.7333	0.8333	0.8333	0.8333	0.8667	0.8667	0.6667	0.8333
8	BeetleFly	0.9000	0.8500	0.9500	0.8400	0.9000	0.9000	0.8500	0.7000	0.6500	0.9000	0.7500	0.8500	0.9500	0.7000	0.7500	0.9500	0.9000	0.8500	0.7000	0.9000	0.9500
9	Bird	0.9000	0.9000	0.9000	0.9000	0.9000	0.9000	0.9000	0.9000	0.9000	1.0000	0.8000	0.5000	0.8500	0.8000	0.9000	0.8000	1.0000	0.9500	0.9000	0.9000	1.0000
10	BME	1.0000	0.9933	0.9933	1.0000	1.0000	1.0000	0.9800	0.9733	0.9933	0.9867	0.9933	0.9533	0.9883	0.9773	0.9933	0.9500	0.9800	1.0000	1.0000	1.0000	1.0000
11	Car	0.9167	0.9333	0.9333	0.9233	0.9000	0.8833	0.7833	0.7167	0.7667	0.8667	0.8167	0.8333	0.6667	0.7833	0.8333	0.8833	0.8833	0.9333	0.9333	0.9167	0.9167
12	CBF	1.0000	0.9989	0.9922	0.9956	1.0000	0.9960	0.7489	0.7489	0.9567	0.9978	0.9944	0.8278	0.9700	0.8767	0.978	0.9978	1.0000	1.0000	0.9956	1.0000	1.0000
13	Chl.	0.9826	0.9855	0.9855	0.9947	0.9825	0.9855	0.9768	0.9072	0.9084	0.9982	0.9767	0.9652	0.9855	0.8767	0.9780	0.9797	0.9782	0.9985	0.9959	0.9985	0.9982
14	Chln.	0.8156	0.7630	0.7576	0.8193	0.7622	0.8654	0.6523	0.6523	0.8229	0.8971	0.7216	0.8242	0.5564	0.8578	0.7630	0.8526	0.7633	0.8539	0.7622	0.7495	0.8635
15	Cin.	0.8304	0.8688	0.9335	0.9288	0.9993	0.6638	0.7931	0.7457	0.8159	0.9036	0.6283	0.7558	0.5655	0.8058	0.9609	0.8686	0.8469	0.9502	0.9623	0.9043	0.9732
16	Coffee	1.0000	1.0000	1.0000	1.0000	1.0000	1.0000	0.9643	1.0000	1.0000	1.0000	0.9643	1.0000	0.8929	1.0000	1.0000	1.0000	1.0000	1.0000	1.0000	1.0000	1.0000
17	Coms.	0.7720	0.7360	0.7360	0.7618	0.7680	0.7880	0.6600	0.5080	0.5680	0.6560	0.7760	0.5760	0.6480	0.5480	0.7920	0.7320	0.7400	0.7680	0.7920	0.7360	0.7800
18	CrX.	0.8282	0.8103	0.8026	0.8026	0.8308	0.7923	0.7923	0.5205	0.5385	0.8256	0.5821	0.5333	0.6949	0.6872	0.7821	0.8282	0.8179	0.8282	0.8077	0.8205	0.8308
ID	Dataset	Rocket	MiniRocket	RDST	MR-H	HC2	IncTime	TS2Vec	PatchTST	TimesNet	SoftShape	MambaSL	GPT4TS	MOMENT	UniTS	NuTime	TS-RAG	Mantis	UniShape	R2R+NuTime	R2R+Mantis	R2R+UniShape
19	CriY.	0.8564	0.8385	0.8308	0.8251	0.8410	0.7974	0.7564	0.6026	0.5538	0.8051	0.7154	0.5615	0.6564	0.6692	0.8026	0.8385	0.8308	0.8333	0.7821	0.8590	0.8487
20	CriZ.	0.8590	0.8282	0.8462	0.8385	0.8436	0.8282	0.8128	0.5615	0.6026	0.8462	0.6846	0.5564	0.7308	0.6949	0.7974	0.8410	0.8590	0.8436	0.8205	0.8599	0.8462
21	Crop	0.7574	0.7622	0.7637	0.7678	0.7602	0.7727	0.7540	0.0766	0.7197	0.7733	0.2406	0.6665	0.6605	0.6548	0.7888	0.7730	0.7877	0.7725	0.7891	0.7842	0.7839
22	Dian.	0.9771	0.9281	0.9248	0.9641	0.9641	0.9150	0.9869	0.9902	0.9150	0.9771	0.9739	0.9542	0.7222	0.9118	0.9085	0.9837	0.9739	0.9706	0.9575	0.9281	0.9739
23	Disp.	0.7410	0.7338	0.7842	0.7626	0.7554	0.7482	0.7122	0.7338	0.6763	0.7770	0.7698	0.7482	0.6691	0.7122	0.7266	0.7194	0.7050	0.7698	0.7338	0.7770	0.7914
24	Dist.	0.7609	0.7681	0.7717	0.7616	0.7609	0.7536	0.7572	0.6848	0.7681	0.7790	0.7428	0.7391	0.6775	0.7246	0.7609	0.7826	0.7681	0.7899	0.7717	0.8116	0.7862
25	DisW.	0.7050	0.6763	0.7266	0.6978	0.7122	0.7122	0.6978	0.6331	0.6547	0.6835	0.6763	0.6043	0.6619	0.6547	0.6835	0.6619	0.6547	0.7194	0.7194	0.6978	0.7050
26	Dody.	0.6125	0.6875	0.6750	0.5750	0.6500	0.6000	0.5500	0.4250	0.2500	0.6500	0.5750	0.4500	0.3000	0.5125	0.5125	0.5250	0.5750	0.6250	0.5375	0.6875	0.7250
27	Dode.	0.8696	0.8768	0.8478	0.8986	0.9203	0.9348	0.8986	0.6522	0.5145	0.8696	0.8333	0.6884	0.8333	0.8261	0.8623	0.9348	0.8406	0.9203	0.8333	0.9565	0.9420
28	Dodd.	0.9710	0.9855	0.9783	0.9755	0.9783	0.9783	0.9638	0.9348	0.7609	0.9783	0.9855	0.9710	0.9493	0.9710	0.9710	0.9710	0.9783	0.9855	0.9783	0.9855	0.9855
29	Ears.	0.7554	0.7626	0.7338	0.7338	0.7482	0.7554	0.7482	0.7266	0.7554	0.7482	0.7338	0.7410	0.7482	0.6978	0.7482	0.7482	0.7482	0.7554	0.7626	0.7554	0.7770
30	ECG2.	0.9051	0.9100	0.9000	0.9100	0.8600	0.9100	0.8700	0.8400	0.8300	0.9150	0.8800	0.8500	0.8700	0.8800	0.8000	0.8900	0.9000	0.9200	0.8800	0.9300	0.9400
31	ECG5.	0.9478	0.9449	0.9429	0.9460	0.9478	0.9453	0.9404	0.9209	0.8993	0.9436	0.9369	0.9309	0.9424	0.9376	0.9440	0.9453	0.9422	0.9498	0.9418	0.9456	0.9462
32	ECGs.	1.0000	1.0000	0.9977	1.0000	1.0000	1.0000	1.0000	0.7689	0.8920	0.9965	0.7352	0.9547	0.8281	0.8211	0.9768	1.0000	0.9570	1.0000	0.9640	0.9884	1.0000
33	Eles.	0.7312	0.7496	0.7408	0.7424	0.7605	0.7256	0.7255	0.3167	0.6457	0.6676	0.7024	0.5774	0.6388	0.6090	0.7506	0.7574	0.7373	0.7248	0.7475	0.7574	0.7926

Details of results on 30 additional datasets

R2R, together with a Random Forest (RF) classifier applied directly to raw time series, and ten pre-trained TSFMs without any parameter fine-tuning, are evaluated for zero-shot feature extraction on 30 additional time series datasets. Specifically, embeddings extracted from each pre-trained TSFM are used as inputs to a Random Forest classifier for classification evaluation. The detailed test accuracy results are reported in Table 10. Notably, TS-RAG [49] is originally designed for zero-shot time series forecasting and achieves strong performance when combined with the pre-trained Chronos [74] model. In this work, we adapt TS-RAG for zero-shot feature-extraction classification using Chronos, in which the knowledge base used for retrieval is constructed consistently within R2R.

ID	Dataset name	RF	GPT4TS	Moment	Chronos	Moirai	UniTS	NuTime	Mantis	UniShape	TS-RAG	TSPulse	R2R
1	AconityMINIPrinterLarge_eq	0.9096	0.6596	0.8660	0.9265	0.8049	0.5819	0.8438	0.8710	0.8691	0.9206	0.9215	0.9417
2	AconityMINIPrinterSmall_eq	0.9486	0.7158	0.9589	0.9315	0.8562	0.6575	0.8562	0.9315	0.9486	0.9555	0.9692	0.9863
3	AllGestureWiimoteX_eq	0.5286	0.4186	0.5343	0.4100	0.2929	0.0800	0.5414	0.4943	0.5343	0.5786	0.5341	0.6571
4	AllGestureWiimoteY_eq	0.5571	0.4157	0.5857	0.3829	0.3014	0.0971	0.5129	0.5086	0.5771	0.6200	0.5729	0.7000
5	AllGestureWiimoteZ_eq	0.4643	0.3871	0.5286	0.4343	0.2614	0.1029	0.4543	0.4757	0.5557	0.5700	0.4886	0.6943
6	AsphaltObstaclesUni_eq	0.7366	0.7417	0.7647	0.8159	0.4731	0.2379	0.7954	0.7980	0.8235	0.8568	0.8210	0.8261
7	AsphaltPavementTypeUni_eq	0.7794	0.7992	0.7670	0.6960	0.4830	0.3598	0.8239	0.7367	0.7860	0.7045	0.6894	0.8636
8	AsphaltRegularityUni_eq	0.9228	0.9414	0.9174	0.8935	0.6591	0.4807	0.9534	0.9534	0.9627	0.8961	0.9048	0.9694
9	Colposcopy	0.4059	0.4059	0.3762	0.4257	0.3267	0.3168	0.4158	0.4257	0.3960	0.3564	0.3861	0.4158
10	Covid3Month_disc	0.6393	0.6066	0.5410	0.6885	0.6885	0.4754	0.6066	0.6721	0.5738	0.7049	0.6393	0.6721
11	DodgerLoopDay_nmv	0.6883	0.1818	0.3377	0.4286	0.4026	0.1948	0.4286	0.4286	0.5455	0.5714	0.5414	0.5714
12	DodgerLoopGame_nmv	0.7638	0.6063	0.7717	0.7165	0.8346	0.4803	0.6772	0.7044	0.6614	0.7795	0.7717	0.8740
13	DodgerLoopWeekend_nmv	0.9841	0.4841	0.9444	0.7540	0.7460	0.5476	0.9524	0.9562	0.9206	0.9365	0.9841	0.9762
14	ElectricDeviceDetection	0.8758	0.8559	0.8559	0.8646	0.8766	0.8299	0.8697	0.8612	0.8607	0.8652	0.8615	0.8620
15	FloodModeling1_disc	0.8119	0.7475	0.7673	0.7871	0.7624	0.7030	0.8218	0.7475	0.7871	0.7970	0.8168	0.8812
16	FloodModeling2_disc	0.9353	0.9303	0.9254	0.9303	0.9254	0.9204	0.9303	0.9254	0.9254	0.9204	0.9254	0.9502
17	FloodModeling3_disc	0.7609	0.6957	0.6793	0.6630	0.6685	0.6304	0.7065	0.6567	0.6793	0.7065	0.7174	0.9022
18	GestureMidAirD2_eq	0.5154	0.3000	0.6231	0.4231	0.2846	0.0385	0.4846	0.5077	0.6615	0.7615	0.7700	0.7692
19	GestureMidAirD2_eq	0.4154	0.0923	0.6015	0.5769	0.2154	0.1000	0.4769	0.4923	0.6077	0.6846	0.6462	0.6846
20	GestureMidAirD3_eq	0.2231	0.1615	0.4308	0.2462	0.1923	0.0385	0.2538	0.2846	0.3923	0.5077	0.4846	0.5077
21	GesturePebbleZ1_eq	0.6570	0.6453	0.7500	0.6337	0.4767	0.1628	0.7442	0.8447	0.8488	0.8547	0.8198	0.9012
22	GesturePebbleZ2_eq	0.6646	0.5190	0.7785	0.6962	0.5823	0.1329	0.7848	0.8608	0.7722	0.7911	0.8101	0.9114
23	KeplerLightCurves	0.7143	0.2982	0.9349	0.8897	0.8296	0.2682	0.7268	0.7945	0.8296	0.8296	0.7744	0.8521
24	MelbournePedestrian_nmv	0.8906	0.7861	0.6270	0.8185	0.7628	0.1035	0.8952	0.8323	0.8991	0.8711	0.8758	0.9560
25	PhoneHeartbeatSound_nmv	0.5989	0.5824	0.6429	0.6978	0.6209	0.5165	0.6538	0.6923	0.6978	0.6648	0.6264	0.6538
26	PickupGestureWiimoteZ_eq	0.6800	0.5200	0.5200	0.6800	0.3400	0.0600	0.6800	0.7800	0.8000	0.7400	0.6700	0.8800
27	PLAID_eq	0.7933	0.4562	0.7263	0.7858	0.5605	0.1415	0.6648	0.6909	0.7393	0.7896	0.7349	0.8771
28	ShakeGestureWiimoteZ_eq	0.7800	0.7200	0.8400	0.8000	0.5600	0.1200	0.8800	0.8900	0.8600	0.9000	0.7800	0.8800
29	SharePriceIncrease	0.6884	0.6915	0.6781	0.6801	0.6718	0.6387	0.6894	0.6822	0.6822	0.6863	0.6814	0.6915
30	Tools	0.4552	0.4328	0.6418	0.7015	0.6119	0.2761	0.6269	0.6567	0.5896	0.6567	0.6189	0.7164
	Avg. Rank	5.80	9.00	6.53	6.33	9.00	11.87	5.63	5.80	5.20	3.97	5.37	1.73
	Win	2	1	1	2	1	0	0	1	1	5	1	21

Details of ablation results

The detailed ablation study results for R2R on feature- and parameter-transfer settings across all 128 UCR time series datasets are reported in Table 11. In addition, Table 12 presents an analysis of the constructed knowledge base in R2R, examining the impact of its size and different sampling strategies applied to the original 1.89M pre-training samples. These experiments are conducted on a selected subset of 18 UCR datasets. Following prior work [20], the 18 UCR datasets are selected based on criteria such as dataset size, sequence length, application domain, and number of classes, ensuring diversity while keeping the computational cost of large-scale knowledge base evaluation manageable.

ID	Dataset name	R2R+ UniShape	w/o Feature transfer	MiniRocket with Retrieval	MiniRocket w/o Retrieval	MiniRocket w/o ReMGP	Rocket w/o Retrieval	MultiRocket w/o Retrieval	UniShape w/o Retrieval
1	ACSF1	0.9300	0.8000	0.9100	0.9000	0.8900	0.6800	0.8700	0.7500
2	Adiac	0.8414	0.8289	0.7612	0.7570	0.7428	0.6880	0.8338	0.8312
3	AllGestureWiimoteX	0.7743	0.7743	0.6714	0.6657	0.6186	0.5129	0.6600	0.7357
4	AllGestureWiimoteY	0.8086	0.7929	0.7271	0.7257	0.6400	0.6600	0.7300	0.7729
5	AllGestureWiimoteZ	0.7657	0.7429	0.6857	0.6643	0.6143	0.7300	0.6986	0.7400
6	ArrowHead	0.9257	0.8857	0.8986	0.8914	0.8800	0.8229	0.8571	0.8571
7	Beef	0.8333	0.8667	0.7500	0.6667	0.8333	0.5000	0.7667	0.7667
8	BeetleFly	0.9500	0.8500	0.9500	0.9500	0.9000	0.9000	0.9000	0.9500
9	BirdChicken	0.9000	0.9500	0.9000	0.9000	0.9000	0.9000	0.9500	0.9000
10	BME	1.0000	1.0000	0.9767	0.9800	0.9733	0.9933	1.0000	1.0000
11	Car	0.9167	0.9333	0.9197	0.9167	0.9167	0.8667	0.8500	0.8833
12	CBF	1.0000	1.0000	0.9899	0.9989	0.9967	0.9889	0.9933	1.0000
13	Chinatown	0.9855	0.9565	0.9739	0.9768	0.9723	0.9623	0.9565	0.9449
14	ChlorineConcentration	0.8635	0.9539	0.6764	0.6641	0.6146	0.6401	0.7063	0.7456
15	CinCECGTorso	0.9732	0.9500	0.8739	0.8667	0.7761	0.8420	0.9623	0.8717
16	Coffee	1.0000	1.0000	1.0000	1.0000	1.0000	1.0000	1.0000	1.0000
17	Computers	0.7800	0.7600	0.7140	0.7360	0.7340	0.6320	0.7280	0.7600
18	CricketX	0.8308	0.8282	0.8126	0.8026	0.7949	0.7769	0.7846	0.7974
ID	Dataset name	R2R-UniShape	w/o Feature transfer	MiniRocket with Retrieval	MiniRocket w/o Retrieval	MiniRocket w/o ReMGP	Rocket w/o Retrieval	MultiRocket w/o Retrieval	UniShape w/o Retrieval
19	CricketY	0.8487	0.8333	0.8308	0.8205	0.8077	0.8205	0.8154	0.8179
20	CricketZ	0.8462	0.8436	0.7667	0.7282	0.6692	0.8128	0.6821	0.8410
21	Crop	0.7839	0.7725	0.7776	0.7679	0.7673	0.7784	0.7804	0.7623
22	DiatomSizeReduction	0.9739	0.9706	0.9281	0.9183	0.8791	0.9542	0.9575	0.9183
23	DistalPhalanxOutlineAgeGroup	0.7914	0.7698	0.7914	0.7626	0.7410	0.7410	0.7698	0.7482
24	DistalPhalanxOutlineCorrect	0.7862	0.7899	0.7981	0.7862	0.7717	0.7681	0.8080	0.7862
25	DistalPhalanxTW	0.7050	0.7194	0.6863	0.6763	0.6735	0.6403	0.6906	0.6763
26	DodgerLoopDay	0.7250	0.6250	0.6695	0.6625	0.7125	0.6125	0.6250	0.6625
27	DodgerLoopGame	0.9420	0.9203	0.8879	0.8841	0.8813	0.9275	0.9203	0.9203
28	DodgerLoopWeekend	0.9855	0.9855	0.9783	0.9783	0.9783	0.9565	0.9783	0.9783
29	Earthquakes	0.7770	0.7554	0.7422	0.7050	0.7022	0.7194	0.7554	0.7986
30	ECG200	0.9400	0.9200	0.9300	0.9300	0.9200	0.9100	0.9200	0.8900
31	ECG5000	0.9462	0.9498	0.9353	0.9322	0.9317	0.9464	0.9453	0.9402
32	ECGFiveDays	1.0000	1.0000	0.9844	0.9826	0.9919	0.9849	0.9954	0.9373
33	ElectricDevices	0.7567	0.7248	0.7339	0.7236	0.7145	0.7082	0.7485	0.7712
34	EOGHorizontalSignal	0.6796	0.6796	0.6133	0.6105	0.6022	0.5884	0.6105	0.6105
35	EOGVerticalSignal	0.5442	0.5193	0.4558	0.4337	0.4254	0.5580	0.5138	0.5276
36	EthanolLevel	0.8140	0.8500	0.6020	0.5040	0.4440	0.5480	0.6220	0.5680
37	FaceAll	0.7852	0.8994	0.7721	0.7556	0.7504	0.8728	0.7385	0.7373
38	FaceFour	0.9773	0.9545	0.9177	0.9091	0.9091	0.8068	0.9318	0.9432
39	FacesUCR	0.9566	0.9620	0.9351	0.9346	0.9298	0.9259	0.9429	0.9054
40	FiftyWords	0.8462	0.8462	0.8264	0.8154	0.8142	0.7780	0.8374	0.8154
41	Fish	0.9829	0.9886	0.9429	0.9314	0.8686	0.9086	0.9714	0.9543
42	FordA	0.9644	0.9629	0.9371	0.9356	0.9500	0.9341	0.9553	0.9402
43	FordB	0.8704	0.8605	0.7952	0.7901	0.7914	0.7975	0.8395	0.8123
44	FreezerRegularTrain	0.9993	0.9972	0.9877	0.9895	0.9816	0.9975	0.9982	0.9940
45	FreezerSmallTrain	0.9846	0.9828	0.9465	0.9396	0.9282	0.8912	0.9554	0.9958
46	Fungi	1.0000	1.0000	0.9624	0.9624	0.9624	0.9570	0.9409	0.9677
47	GestureMidAirD1	0.8077	0.8000	0.7200	0.7000	0.7000	0.7308	0.7385	0.7538
48	GestureMidAirD2	0.7231	0.7231	0.6400	0.6308	0.5923	0.6077	0.5923	0.6615
49	GestureMidAirD3	0.5385	0.4692	0.4738	0.4692	0.5154	0.4231	0.4615	0.4462
50	GesturePebbleZ1	0.9419	0.9477	0.8953	0.8721	0.8895	0.8023	0.9186	0.8663
51	GesturePebbleZ2	0.9557	0.9747	0.8328	0.8291	0.7975	0.8544	0.8797	0.8861
52	GunPoint	1.0000	1.0000	0.9933	0.9867	0.9933	0.9933	0.9933	0.9800
53	GunPointAgeSpan	1.0000	0.9968	0.9715	0.9715	0.9620	0.9905	1.0000	0.9968
54	GunPointMaleVersusFemale	1.0000	1.0000	1.0000	1.0000	1.0000	0.9968	1.0000	0.9968
55	GunPointOldVersusYoung	1.0000	1.0000	1.0000	1.0000	1.0000	0.9937	1.0000	1.0000
56	Ham	0.7333	0.7619	0.6486	0.6476	0.6476	0.7810	0.6381	0.5810
57	HandOutlines	0.9703	0.9649	0.9316	0.9270	0.9189	0.9135	0.9324	0.9486
58	Haptics	0.5747	0.5682	0.5487	0.5487	0.5714	0.5519	0.5584	0.5649
59	Herring	0.7656	0.7969	0.6406	0.5781	0.6406	0.6250	0.6250	0.6406
60	HouseTwenty	0.9916	0.9832	0.9244	0.9244	0.9328	0.8992	0.9328	0.9580
61	InlineSkate	0.5200	0.4909	0.4527	0.4509	0.4345	0.4473	0.4673	0.4218
62	InsectEPGRegularTrain	1.0000	1.0000	1.0000	1.0000	1.0000	0.9960	1.0000	1.0000
63	InsectEPGSmallTrain	1.0000	1.0000	0.9679	0.9679	0.9679	0.9598	0.9920	1.0000
64	InsectWingbeatSound	0.6737	0.6682	0.6625	0.6535	0.6566	0.6273	0.6601	0.5889
65	ItalyPowerDemand	0.9650	0.9640	0.9514	0.9475	0.9640	0.9660	0.9670	0.9359
66	LargeKitchenAppliances	0.9200	0.9253	0.8253	0.8213	0.8161	0.8187	0.8400	0.8907
67	Lightning2	0.8361	0.8525	0.7705	0.7377	0.7869	0.8361	0.7377	0.8033
68	Lightning7	0.8356	0.8630	0.8082	0.7808	0.7534	0.7671	0.8493	0.7808
69	Mallat	0.9898	0.9659	0.9284	0.9484	0.8601	0.9407	0.9134	0.9267
70	Meat	0.9833	0.9590	0.9533	0.9500	0.9667	0.9667	0.9167	0.9667
71	MedicalImages	0.8066	0.8039	0.8100	0.8053	0.8053	0.7855	0.7974	0.7829
72	MelbournePedestrian	0.9751	0.9702	0.9580	0.9571	0.9633	0.9416	0.9416	0.9649
73	MiddlePhalanxOutlineAgeGroup	0.6039	0.5714	0.3592	0.2273	0.5260	0.4221	0.3701	0.3831
74	MiddlePhalanxOutlineCorrect	0.8763	0.8660	0.8482	0.8454	0.7801	0.8385	0.8557	0.8660
75	MiddlePhalanxTW	0.5714	0.5074	0.5625	0.5584	0.5909	0.5779	0.5065	0.4935
76	MixedShapesRegularTrain	0.9761	0.9753	0.9693	0.9518	0.9485	0.9530	0.9633	0.9546
77	MixedShapesSmallTrain	0.9435	0.9509	0.8664	0.7918	0.7410	0.8169	0.9027	0.9423
78	MoteStrain	0.9457	0.9305	0.9641	0.9593	0.9165	0.8355	0.9665	0.9073
79	NonInvasiveFetalECGThorax1	0.9598	0.9511	0.8943	0.8768	0.8224	0.9125	0.9247	0.9354
80	NonInvasiveFetalECGThorax2	0.9664	0.9517	0.9688	0.9644	0.9567	0.9608	0.9649	0.9511
81	OliveOil	0.9667	0.8667	0.9667	0.9333	0.9667	0.8000	0.9667	0.9333
82	OSULeaf	0.9917	0.9835	0.9298	0.9298	0.9174	0.8802	0.9132	0.9380
83	PhalangesOutlinesCorrect	0.8485	0.8590	0.8380	0.8240	0.8228	0.8089	0.8660	0.8392
84	Phoneme	0.3877	0.3729	0.3501	0.3075	0.2948	0.2590	0.3755	0.3539
85	PickupGestureWiiMoteZ	0.8800	0.8600	0.8700	0.8800	0.8600	0.7600	0.7600	0.7800
86	PigAirwayPressure	0.4663	0.3510	0.5096	0.5192	0.4663	0.3462	0.4712	0.3798
87	PigArtPressure	0.9952	0.9856	0.9519	0.9423	0.9279	0.8221	0.9183	0.8558
88	PigCVP	0.8654	0.7500	0.8558	0.8221	0.7981	0.7788	0.7837	0.7404
89	PLAID	0.9050	0.8939	0.8585	0.6965	0.7300	0.3408	0.4376	0.6127
90	Plane	1.0000	0.9905	1.0000	1.0000	1.0000	1.0000	1.0000	1.0000
91	PowerCons	0.9944	1.0000	0.9944	0.9889	0.9944	0.9667	0.9944	0.9778
92	ProximalPhalanxOutlineAgeGroup	0.8585	0.8585	0.8146	0.8146	0.8293	0.8488	0.8488	0.8488
93	ProximalPhalanxOutlineCorrect	0.9278	0.9347	0.8763	0.8454	0.9072	0.8900	0.9107	0.8832
94	ProximalPhalanxTW	0.8390	0.8341	0.7951	0.8244	0.8195	0.7805	0.8146	0.7707
95	RefrigerationDevices	0.6800	0.6667	0.5273	0.5200	0.4800	0.5413	0.5360	0.5387
96	Rock	0.9000	0.8600	0.8600	0.8600	0.7600	0.8200	0.8400	0.8400
97	ScreenType	0.5813	0.5653	0.5187	0.5173	0.4987	0.4293	0.4987	0.4987
98	SemgHandGenderCh2	0.9650	0.9600	0.9533	0.9500	0.9017	0.8383	0.9500	0.9250
99	SemgHandMovementCh2	0.8667	0.8422	0.7689	0.7467	0.6289	0.6178	0.7800	0.8356
100	SemgHandSubjectCh2	0.9267	0.9333	0.8778	0.8511	0.8267	0.7289	0.9067	0.8556
101	ShakeGestureWiiMoteZ	0.9400	0.9400	0.9600	0.9800	0.9400	0.9200	0.9400	0.8800
102	ShapelesSin	1.0000	1.0000	0.9833	0.9833	1.0000	0.9944	1.0000	1.0000
103	ShapesAll	0.9217	0.9050	0.9000	0.8883	0.9000	0.8733	0.9033	0.9117
104	SmallKitchenAppliances	0.8347	0.8427	0.7867	0.8080	0.7707	0.7733	0.8187	0.8293
105	SmoothSubspace	0.9867	0.9800	0.9133	0.9067	0.8867	0.9333	0.9333	0.9533
106	SonyAIBORobotSurface1	0.9418	0.9368	0.9368	0.9334	0.9567	0.9584	0.9301	0.9085
107	SonyAIBORobotSurface2	0.9559	0.8909	0.9433	0.9402	0.9339	0.9465	0.8909	0.9328
108	StarLightCurves	0.9834	0.9815	0.9823	0.9811	0.9823	0.9766	0.9820	0.9809
109	Strawberry	0.9784	0.9811	0.9595	0.9757	0.9027	0.9081	0.9676	0.9622
110	SwedishLeaf	0.9696	0.9776	0.9492	0.9440	0.9264	0.9616	0.9728	0.9616
111	Symbols	0.9950	0.9940	0.9859	0.9839	0.9809	0.9729	0.9829	0.9839
112	SyntheticControl	1.0000	1.0000	0.9933	0.9933	0.9900	0.9967	0.9933	0.9833
113	ToeSegmentation1	0.9693	0.9561	0.9561	0.9518	0.9518	0.9605	0.9342	0.9649
114	ToeSegmentation2	0.9462	0.9538	0.9154	0.9154	0.8769	0.8615	0.9000	0.9231
115	Trace	1.0000	1.0000	1.0000	1.0000	1.0000	1.0000	1.0000	1.0000
116	TwoLeadECG	1.0000	1.0000	0.9798	0.9833	0.9728	0.9991	0.9991	0.9851
117	TwoPatterns	1.0000	1.0000	1.0000	0.9998	0.9998	1.0000	1.0000	0.9998
118	UMD	0.9931	1.0000	0.9444	0.9306	0.9275	0.8819	0.8681	0.9861
119	UWaveGestureLibraryAll	0.9799	0.9796	0.9673	0.9648	0.9562	0.9724	0.9796	0.9648
120	UWaveGestureLibraryX	0.8811	0.8786	0.8509	0.8492	0.8300	0.8437	0.8571	0.8663
ID	Dataset name	R2R-UniShape	w/o Feature transfer	MiniRocket with Retrieval	MiniRocket w/o Retrieval	MiniRocket w/o ReMGP	Rocket w/o Retrieval	MultiRocket w/o Retrieval	UniShape w/o Retrieval
121	UWaveGestureLibraryY	0.8275	0.8269	0.7920	0.7842	0.7753	0.7753	0.7962	0.8074
122	UWaveGestureLibraryZ	0.8370	0.8361	0.8093	0.8032	0.7856	0.7822	0.8138	0.8227
123	Wafer	1.0000	0.9997	1.0000	1.0000	0.9985	1.0000	1.0000	0.9994
124	Wine	0.9074	0.7963	0.8333	0.8148	0.8519	0.5000	0.6481	0.7407
125	WordSynonyms	0.7492	0.7492	0.7273	0.7116	0.7194	0.7210	0.7539	0.7335
126	Worms	0.8182	0.7922	0.7662	0.7403	0.7532	0.7403	0.7792	0.7792
127	WormsTwoClass	0.8442	0.8831	0.7662	0.7662	0.7792	0.7792	0.8182	0.7922
128	Yoga	0.9127	0.9197	0.8900	0.8810	0.8823	0.8570	0.8967	0.9087
Avg. Rank		1.48	2.45	4.14	5.09	5.59	5.91	4.06	4.52
Win		86	48	13	11	8	8	18	13

ID	Dataset name	Balanced 50K	Balanced 100K	Balanced 200K	Balanced 500K	Balanced 1M	Balanced 1.89M	Random 100K	Unbalanced 100K
1	ArrowHead	0.8628	0.8857	0.8857	0.8800	0.8571	0.8685	0.8857	0.8628
2	CBF	1.0000	1.0000	1.0000	1.0000	1.0000	1.0000	1.0000	1.0000
3	CricketX	0.8077	0.8282	0.8205	0.8205	0.8205	0.8154	0.8203	0.7997
4	DistalPhalanxOutlineAgeGroup	0.7698	0.7698	0.7626	0.7842	0.7914	0.8058	0.7698	0.7483
5	DistalPhalanxOutlineCorrect	0.7826	0.7899	0.7754	0.8152	0.7826	0.7826	0.7863	0.7790
6	ECG5000	0.9445	0.9498	0.9500	0.9498	0.9498	0.9487	0.9474	0.9403
7	EOGVerticalSignal	0.5082	0.5193	0.5165	0.5054	0.5054	0.5220	0.5082	0.4916
8	EthanolLevel	0.8520	0.8500	0.8660	0.8260	0.8380	0.8520	0.8360	0.8280
9	Fish	1.0000	0.9886	1.0000	1.0000	1.0000	1.0000	1.0000	0.9829
10	GunPoint	0.9970	1.0000	1.0000	0.9934	1.0000	0.9934	1.0000	0.9934
11	InsectWingbeatSound	0.6612	0.6682	0.6637	0.6773	0.6566	0.6587	0.6647	0.6531
12	ItalyPowerDemand	0.9679	0.9640	0.9737	0.9689	0.9456	0.9640	0.9669	0.9611
13	MelbournePedestrian	0.9698	0.9702	0.9690	0.9694	0.9718	0.9653	0.9702	0.9669
14	MiddlePhalanxTW	0.5520	0.5974	0.5195	0.5650	0.5715	0.5260	0.5520	0.5440
15	MixedShapesRegularTrain	0.9745	0.9753	0.9745	0.9741	0.9749	0.9737	0.9749	0.9704
16	OSULeaf	0.9635	0.9835	0.9629	0.9753	0.9753	0.9753	0.9794	0.9711
17	Trace	1.0000	1.0000	1.0000	1.0000	1.0000	1.0000	1.0000	1.0000
18	WordSynonyms	0.7476	0.7492	0.7555	0.7555	0.7555	0.7414	0.7398	0.7398
Avg. Rank		4.11	2.33	3.28	3.11	3.17	4.17	3.17	6.50
Win		3	8	9	6	6	5	5	2

Details of knowledge-enhanced results

We first present t-SNE visualizations [76] to examine the discriminative quality of embeddings learned by R2R across UCR time series datasets with varying domains and class cardinalities. Figures 5, 6, 7, and 8 illustrate the results on four representative UCR datasets, namely Chinatown, ArrowHead, UWaveGestureLibraryAll, and MelbournePedestrian. These datasets differ in application domains and number of classes, enabling a comprehensive analysis. The results demonstrate that incorporating retrieved embeddings improves class separability compared to embeddings obtained solely via parameter fine-tuning.

Furthermore, we compare R2R with seven commonly used time series data augmentation methods on the same 18 UCR datasets used in Table 12. This experiment evaluates whether retrieval-based numerical embeddings can provide more effective knowledge transfer than conventional data augmentation strategies. Those seven time series data augmentation methods [77, 78] are summarized as follows:

• Jitter: Adds random Gaussian noise to the original time series.

• Time warp: Randomly distorts the temporal axis by varying the speed of the sequence.

• Magnitude warp: Applies smooth, non-linear changes to the amplitude of the series.

• Window slice: Extracts a subsegment via downsampling and resizes it back to the original length.

• Time flip: Reverses the temporal order of the sequence.

• Permutation: Divides the series into segments and randomly shuffles their order.

• Scaling: Multiplies the entire series by a random scaling factor.

The detailed classification accuracy results of R2R and the seven augmentation methods on the 18 datasets are reported in Table 13. Additionally, Table 14 compares R2R’s transfer paradigm with conventional fine-tuning-based transfer across datasets with different numbers of classes (2, 6, 10, and 26), under a continual fine-tuning setting.

ID	Dataset name	Raw	Jitter	Time warp	Magnitude warp	Window slice	Time flip	Permutation	Scaling	R2R
1	ArrowHead	0.8857	0.8629	0.8457	0.8686	0.8629	0.8857	0.8400	0.8743	0.9257
2	CBF	1.0000	1.0000	1.0000	1.0000	1.0000	0.8389	1.0000	1.0000	1.0000
3	CricketX	0.8282	0.8154	0.8205	0.8128	0.8179	0.8308	0.8308	0.8179	0.8308
4	DistalPhalanxOutlineAgeGroup	0.7698	0.7698	0.7698	0.7554	0.7842	0.7842	0.7482	0.7338	0.7914
5	DistalPhalanxOutlineCorrect	0.7899	0.7935	0.7899	0.7971	0.7609	0.7609	0.7971	0.7935	0.7862
6	ECG5000	0.9498	0.9464	0.9387	0.9458	0.9444	0.9442	0.9464	0.9451	0.9462
7	EOGVerticalSignal	0.5193	0.5387	0.5608	0.5276	0.5718	0.4613	0.5110	0.5110	0.5442
8	EthanolLevel	0.8500	0.7520	0.7140	0.7260	0.8100	0.7580	0.7980	0.7560	0.8140
9	Fish	0.9886	0.9486	0.9714	0.9657	0.9771	0.9771	0.9657	0.9714	0.9829
10	GunPoint	1.0000	1.0000	1.0000	0.9867	0.9867	0.9933	0.9933	0.9867	1.0000
11	InsectWingbeatSound	0.6682	0.6515	0.6399	0.6611	0.6283	0.6667	0.6540	0.6551	0.6737
12	ItalyPowerDemand	0.9640	0.9660	0.9534	0.9621	0.9534	0.9621	0.9563	0.9611	0.9650
13	MelbournePedestrian	0.9702	0.9610	0.9668	0.9668	0.9672	0.9631	0.9606	0.9639	0.9751
14	MiddlePhalanxTW	0.5974	0.5649	0.5714	0.5260	0.5649	0.5714	0.5390	0.5779	0.5714
15	MixedShapesRegularTrain	0.9753	0.9654	0.9699	0.9761	0.9773	0.9695	0.9736	0.9765	0.9761
16	OSULeaf	0.9835	0.9545	0.9628	0.9669	0.9835	0.9711	0.9504	0.9669	0.9917
17	Trace	1.0000	1.0000	1.0000	1.0000	1.0000	1.0000	1.0000	1.0000	1.0000
18	WordSynonyms	0.7492	0.7241	0.7320	0.7414	0.7320	0.6771	0.7116	0.7288	0.7492
	Avg. Rank	2.39	5.11	5.06	4.89	4.33	5.06	5.50	4.83	2.00
	Win	8	4	3	3	4	2	4	2	10

Dataset A	Dataset B	Only Parameter transfer			R2R transfer
		Acc$_{A1}$	Acc$_{A2}$	Forgetting	Acc$_{A1}$	Acc$_{A2}$	Forgetting
AconityMINIPrinterSmall_eq	AsphaltRegularityUni_eq	0.9795	0.8048	0.1747	0.9829	0.8253	0.1576
Colposcopy	GesturePebbleZ1_eq	0.3564	0.2574	0.0990	0.3762	0.2970	0.0792
AllGestureWiimoteY_eq	AllGestureWiimoteZ_eq	0.7971	0.2829	0.5142	0.8071	0.3286	0.4785
GestureMidAirD2_eq	GestureMidAirD3_eq	0.6923	0.1769	0.5154	0.7000	0.2308	0.4692

Details of hyperparameter analysis results

Table 15 presents the classification performance of R2R under three distance metrics used for retrieval index construction, evaluated on the same 18 UCR datasets as in Table 12. We consider Inner Product (IP), Euclidean Distance (L2), and Cosine Similarity. These metrics differ in both formulation and geometric properties. Specifically, IP computes similarity as $\langle x,y\rangle= \sum_{i=1}^{d} x_i y_i$, favoring vectors with large aligned magnitudes; L2 measures dissimilarity as $\lVert x-y\rVert_2^2 = \sum_{i=1}^{d}(x_i-y_i)^2$, capturing absolute geometric distance; while Cosine similarity evaluates angular similarity as $\frac{\langle x,y\rangle}{\lVert x\rVert_2\lVert y\rVert_2}$, effectively normalizing vector magnitudes and focusing on directional alignment. As shown in Table 15, Cosine similarity achieves the best average rank, indicating its superiority in retrieving semantically aligned embeddings. Therefore, R2R adopts Cosine similarity as the default distance metric for nearest neighbor retrieval.

ID	Dataset name	IP	L2	Cosine
1	ArrowHead	0.8800	0.8743	0.9257
2	CBF	1.0000	1.0000	1.0000
3	CricketX	0.8257	0.8257	0.8308
4	DistalPhalanxOutlineAgeGroup	0.7554	0.7339	0.7914
5	DistalPhalanxOutlineCorrect	0.7754	0.8080	0.7862
6	ECG5000	0.9400	0.9420	0.9462
7	EOGVerticalSignal	0.5332	0.5497	0.5442
8	EthanolLevel	0.8360	0.8080	0.8140
9	Fish	0.9658	0.9658	0.9829
10	GunPoint	1.0000	1.0000	1.0000
11	InsectWingbeatSound	0.6727	0.6646	0.6737
12	ItalyPowerDemand	0.9620	0.9591	0.9650
13	MelbournePedestrian	0.9763	0.9730	0.9751
14	MiddlePhalanxTW	0.5130	0.5325	0.5714
15	MixedShapesRegularTrain	0.9736	0.9765	0.9761
16	OSULeaf	0.9834	1.0000	0.9917
17	Trace	1.0000	1.0000	1.0000
18	WordSynonyms	0.7461	0.7570	0.7492
	Avg. Rank	2.11	1.89	1.39
	Win	5	8	11

Tables 16 and 17 further examine the influence of retrieval hyperparameters, including the index partition size $n_{\mathrm{list}}$ and the number of retrieved neighbors $K$. The results demonstrate that $n_{\mathrm{list}} = 256$ and $K = 20$ yield the best average rank, and are thus selected as default settings. Additionally, comparing $K = 1$ and $K = 20$ in Table 17 shows that using only a single nearest neighbor significantly degrades performance, as it effectively removes the optimal transport-based weighted fusion mechanism. In contrast, aggregating multiple retrieved neighbors ($K = 20$) improves both average rank and win rate, highlighting the effectiveness of multi-neighbor retrieval combined with optimal transport-based weighting.

ID	Dataset name	K=1	K=5	K=10	K=20	K=32	K=64
1	ArrowHead	0.9128	0.9543	0.9371	0.9257	0.9428	0.9486
2	CBF	1.0000	1.0000	1.0000	1.0000	1.0000	1.0000
3	CricketX	0.8287	0.8461	0.8385	0.8308	0.8410	0.8461
4	DistalPhalanxOutlineAgeGroup	0.7626	0.7770	0.7914	0.7914	0.7770	0.7842
5	DistalPhalanxOutlineCorrect	0.7608	0.7789	0.7681	0.7862	0.7789	0.7391
6	ECG5000	0.9409	0.9398	0.9467	0.9462	0.9495	0.9438
7	EOGVerticalSignal	0.5470	0.5359	0.5387	0.5442	0.5470	0.5497
8	EthanolLevel	0.8060	0.8280	0.8200	0.8140	0.8280	0.8060
9	Fish	0.9715	0.9715	0.9658	0.9829	0.9772	0.9715
10	GunPoint	1.0000	0.9934	1.0000	1.0000	1.0000	1.0000
11	InsectWingbeatSound	0.6666	0.6697	0.6757	0.6737	0.6732	0.6762
12	ItalyPowerDemand	0.9601	0.9572	0.9640	0.9650	0.9523	0.9620
13	MelbournePedestrian	0.9682	0.9727	0.9723	0.9751	0.9731	0.9715
14	MiddlePhalanxTW	0.5259	0.5714	0.5519	0.5714	0.5454	0.5064
15	MixedShapesRegularTrain	0.9741	0.9720	0.9736	0.9761	0.9774	0.9732
16	OSULeaf	0.9793	0.9917	0.9793	0.9917	0.9834	0.9917
17	Trace	1.0000	1.0000	1.0000	1.0000	1.0000	1.0000
18	WordSynonyms	0.7429	0.7492	0.7398	0.7492	0.7351	0.7445
	Avg. Rank	4.11	3.00	3.17	2.06	2.67	2.89
	Win	3	8	4	11	6	7

ID	Dataset name	$n_{\mathrm{list}}=128$	$n_{\mathrm{list}}=256$	$n_{\mathrm{list}}=512$	$n_{\mathrm{list}}=1024$	$n_{\mathrm{list}}=2048$	$n_{\mathrm{list}}=4096$	$n_{\mathrm{list}}=8192$
1	ArrowHead	0.9200	0.9257	0.9314	0.9314	0.9314	0.9543	0.9486
2	CBF	1.0000	1.0000	1.0000	1.0000	1.0000	1.0000	1.0000
3	CricketX	0.8283	0.8308	0.8026	0.8232	0.8283	0.7975	0.8283
4	DistalPhalanxOutlineAgeGroup	0.7842	0.7914	0.7842	0.7886	0.7770	0.7698	0.7555
5	DistalPhalanxOutlineCorrect	0.8007	0.7862	0.8079	0.8043	0.7971	0.8007	0.8079
6	ECG5000	0.9444	0.9462	0.9462	0.9509	0.9431	0.9480	0.9391
7	EOGVerticalSignal	0.5415	0.5442	0.5497	0.5332	0.5470	0.5111	0.5055
8	EthanolLevel	0.8040	0.8140	0.8160	0.8020	0.8120	0.7880	0.7920
9	Fish	0.9772	0.9829	0.9772	0.9772	0.9829	0.9886	0.9943
10	GunPoint	1.0000	1.0000	1.0000	1.0000	1.0000	1.0000	1.0000
11	InsectWingbeatSound	0.6576	0.6737	0.6712	0.6641	0.6682	0.6732	0.6727
12	ItalyPowerDemand	0.9708	0.9650	0.9582	0.9660	0.9670	0.9621	0.9689
13	MelbournePedestrian	0.9731	0.9751	0.9747	0.9763	0.9735	0.9751	0.9759
14	MiddlePhalanxTW	0.6078	0.5714	0.5559	0.6143	0.5689	0.5624	0.5819
15	MixedShapesRegularTrain	0.9761	0.9761	0.9761	0.9765	0.9765	0.9761	0.9761
16	OSULeaf	0.9917	0.9917	0.9917	0.9917	0.9917	0.9876	0.9876
17	Trace	1.0000	1.0000	1.0000	1.0000	1.0000	1.0000	1.0000
18	WordSynonyms	0.7492	0.7492	0.7492	0.7461	0.7477	0.7539	0.7571
	Avg. Rank	3.39	2.72	3.11	2.94	3.33	3.67	3.11
	Win	5	7	7	8	5	4	6

Details of multivariate time series classification results

R2R is designed for univariate TSC, and both the query encoder and the knowledge base operate on univariate series. To examine whether the framework also transfers to multivariate time series, we follow the channel-adapter protocol of Mantis [19] and evaluate on the same ten UEA datasets [61] reported in Appendix Table 12. A trainable linear adapter maps the $d$ input channels of each dataset to ten mixed channels before the R2R$_{\mathrm{UniShape}}$ pipeline, so that heterogeneous channel counts and cross-channel mixing are handled by the adapter, while the per-channel query embeddings are averaged before retrieval to keep the retrieval module identical to the univariate case.

Table 18 reports the detailed multivariate time series classification results. The three Mantis columns correspond to the None, PCA, and Linear channel adapters and are copied directly from Appendix

ID	Dataset name	Mantis: None	Mantis: PCA	Mantis: Linear	UniShape-based (ours): UniShape (Linear)	UniShape-based (ours): R2R$_{\mathrm{UniShape}}$ (Linear)
1	CharacterTrajectories	0.976	0.977	0.988	0.995	0.995
2	DuckDuckGeese	0.540	0.580	0.600	0.600	0.627
3	EigenWorms	0.814	0.863	0.855	0.898	0.906
4	FaceDetection	0.549	0.553	0.592	0.664	0.657
5	HandMovementDirection	0.297	0.338	0.338	0.351	0.446
6	Handwriting	0.281	0.315	0.514	0.464	0.503
7	MotorImagery	0.467	0.480	0.500	0.570	0.520
8	NATOPS	0.889	0.939	0.906	0.909	0.926
9	SelfRegulationSCP2	0.517	0.533	0.533	0.494	0.546
10	SpokenArabicDigits	0.937	0.955	0.987	0.995	0.995
	Avg. Rank	4.90	3.30	2.80	2.10	1.40
	Win	0	1	1	4	6

Table 12 of [19]. The two remaining columns are obtained in this work and differ only in whether retrieval is used: UniShape (Linear) applies the same adapter and backbone without the query encoder, whereas $R2R_{\mathrm{UniShape}}$ (Linear) additionally retrieves numerical knowledge; the two share the same adapter, backbone, ensembling, training budget, and model-selection protocol. Both Mantis and the two UniShape-based settings are trained on the default UEA training splits and evaluated on the default test splits, and neither uses the test set during training or for weight selection, so the comparison is fair with respect to data usage.

As in the main text, we report the average rank of the test classification accuracy and the number of datasets on which each method is best (Win). $R2R_{\mathrm{UniShape}}$ obtains the best average rank (1.40) and the most wins (6 of 10), improving over the parameter-only UniShape (Linear) variant (2.10 with 4 wins) as well as over all three Mantis channel adapters. These results indicate that the retrieval-to-recognition paradigm remains effective once a channel adapter supplies multivariate inputs. We regard this as a preliminary extension rather than a full multivariate design, since it covers ten datasets and the retrieved knowledge itself is still univariate.

Limitations

R2R is specifically positioned at the post-training stage of TSFMs: it improves how an already pretrained model is adapted to downstream classification, and therefore contributes neither new pretraining objectives and backbone architectures nor evidence about pretraining scale. R2R relies on a knowledge base constructed from large-scale pretraining datasets to retrieve class-relevant embeddings for downstream time series classification. In this work, both the retrieval mechanism and the knowledge base are designed for univariate time series, and thus do not explicitly account for multivariate settings, where modeling inter-variable dependencies and handling high-dimensional channels are important. Appendix G reports a preliminary extension in which a trainable linear channel adapter precedes the R2R pipeline on ten UEA datasets; there, inter-variable dependencies are absorbed by the adapter and the retrieved knowledge remains univariate, so the extension does not yet constitute a native multivariate design. Extending R2R to multivariate scenarios, including efficient channel selection and cross-variable representation learning, is a promising direction for future work. In addition, the effectiveness of retrieval-based enhancement depends on the quality of learned embeddings and the composition of the knowledge base. In particular, imbalanced class distributions in the sampled knowledge base may reduce the benefit of retrieval, indicating that diversity and balance of class patterns are important for robust knowledge transfer. This suggests future efforts on designing more robust retrieval strategies and knowledge base construction methods to further improve generalization in complex real-world settings.

Broader impacts

This work proposes R2R, a retrieval-to-recognition post-training framework that enhances pretrained time series foundation models (TSFMs) by incorporating retrieved numerical knowledge from a constructed pretraining knowledge base. By combining implicit parameter knowledge in TSFMs with explicit retrieved feature-level knowledge, R2R provides a plug-and-play mechanism to improve time-series classification across diverse real-world scenarios. It can be seamlessly integrated with existing TSFMs and applied to applications such as activity recognition, healthcare monitoring, and industrial fault diagnosis. The framework relies solely on time-series representations and publicly available benchmark datasets, without involving any personal or sensitive information, and therefore does not introduce additional ethical risks beyond standard machine learning practice.