acceptodds
Under review as a conference paper at ICLR 2027

FlashRocket: Archive-Scale Time Series Classification in Seconds

Abstract

As wearables and the Internet of Things proliferate, AI systems will increasingly need to process many different sensors at once and adapt quickly, ideally within seconds, as those sensors drift. One time series foundation model may seem like the natural answer, but it still needs a classification head trained for every task. In our experiments, training and testing these classifiers takes from 15 minutes to an estimated 7.5 hours, far too slow for quick adaptation. Training and testing hundreds of classifiers in seconds on one GPU is hard: the tasks differ by orders of magnitude in size, length and channel count, so most are too small to keep the GPU busy while a few are large enough to stall the rest. We present FlashRocket, a system that trains and tests classifiers on MiniRocket features at archive scale as one GPU workload. It extracts features in a single fused on-chip pass, tiling long series so that the longest few do not become the bottleneck, and fits a cheaper ridge classification head. On 188 datasets spanning four archives (UCR, UEA, Bake Off Redux and Multiverse-core), with 279,247 training and 249,041 test series, FlashRocket trains and tests all 188 classifiers, from raw series to predicted labels, in 3.07 seconds on one L40S GPU with 16 CPUs. This is 242x faster than MiniRocket in tsai at matching accuracy (83.07% against 83.10%), and 298x faster and 1.34 points more accurate than MantisV2. FlashRocket makes it possible to retrain and test archive-scale collections of classifiers in seconds.

Primary area:
learning on time series and dynamical systems
Keywords:
time series classification, MiniRocket, GPU kernels, kernel fusion, efficient machine learning, time series foundation models, ridge regression

Reviews

Among:
Shape:
1234this paper, Top 4%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 3.33 over 3 reviews, above 96% of the others.
Reviewer_nH6QOpenReview ↗
Rating
3(+1)
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

The authors present FlashRocket, a specialised implementation of MiniRocket, which performs efficient training and inference over multiple datasets/tasks in a single "run" via executing three work streams or queues concurrently on GPU, including (training set) feature extraction, ridge classifier training, and (inference/prediction) feature extraction and classifier inference, following an initial preparation stage performed on CPU. Broadly speaking, the approach involves maximising GPU usage when performing training and inference over multiple datasets.

The authors claim substantial overall speedups in terms of training and inference time over other methods, on a collection of datasets drawn from the UCR (including Redux), UEA, and MultiVerse archives, specifically: a reference GPU implementation of MiniRocket (per tsai), as well as the MantisV2 and MOMENT foundation models. In particular, the method is reported as achieving a ~250x or more speedup over MiniRocket and MantisV2 (MOMENT is considerably slower).

Critical strengths
  • The paper is refreshingly clear and straightforward. It "does what it says on the tin". The paper is well written and easy to follow. The paper provides an accurate, thorough description and explanation of the MiniRocket method, the tsai implementation, and the various components of the proposed method. The results are well organised and presented clearly.

  • The method does provide impressive overall training and inference wall clock time speedups over the baseline methods, even if only in a relatively narrow or niche context. With the caveat in relation to the broader applicability and generalisability noted elsewhere, the proposed method does appear to produce significant overall speedups in terms of wall clock training and inference times over both MatisV2 (and MOMENT), as well as the tsai reference implementation of MiniRocket.

Critical weaknesses
  • The broader significance of this approach, it's broader applicability and generalisability, are unclear.

On the one hand, the broader motivation/use case provided by the authors in terms of training/retraining (and performing inference/prediction) for data from, e.g., a large number of disparate sensors, makes sense in isolation. On the other hand, however, in practice the work, as presented, seems quite "niche", and arguably more like a speed-run of prominent time series classification datasets, rather than something that would have broader application. In particular, choices around regularisation would appear to limit the real world application of this approach.

I think the choice of a single alpha (ridge parameter) value for all datasets is strange. I think some reasons why it might still appear to "work" reasonably well are, e.g.: (a) the smaller datasets (most of the datasets included in the study) still benefit from over-parameterisation (i.e., an effect something like double descent), providing something similar to a ridge penalty; and/or (b) the true effect is to some extent "hidden" in the average accuracy metric, i.e., the chosen alpha value is likely "worse" than that chosen by a search on many of the datasets, but also "better" than that chosen by search on many of the datasets (due to tiny training set sizes, distribution shift between training and test sets, etc), so the result on average doesn't look that different (esp. where the chosen alpha value is not radically different from the "true"/search-based alpha, i.e., within the same order of magnitude), which would appear to be consistent with the results presented in Figure 8 (Appendix E).

The two major issues I see with this approach are: (i) shifting the cost of finding the alpha value from a search to a kind of isolated design choice is arguably more of an accounting exercise, it's still a step taken in the method, but it's no longer accounted for in the cost; and (ii) I think there's a significant risk that fitting the ridge parameter to the datasets in this way will not generalise effectively to new data, which would make this work amount to something more like a "speed-run" of the given datasets, rather than a true improvement in efficiency, as impressive as the overall speedups in training and inference time might be.

  • My only other substantial criticism is that the related work section appears somewhat perfunctory. I realise that some related work is covered in the introduction but, nevertheless, I think most readers, particularly those not deeply versed in time series or time series classification, really should be given/would benefit from a broader and more thorough treatment of existing work.
Questions for authors
  1. At what quantity of data (in terms of the number of training series and/or time series length), if any, does this approach no longer work? That is, what characteristics of the input time series in terms of number of series, channels, time points, would be "too much" in terms of peak CPU and/or GPU memory usage? This might be answered in terms of both the L40S, and a smaller GPU memory limit, say 16 GB. If we were using a GPU with less memory (e.g., 16 GB), which of the datasets (if any) used in the study would no longer be compatible with the approach?

  2. If the conclusion really is that a fixed regularisation parameter works for all problems, can they authors please reconcile this with standard results that badly selecting lambda can have substantial negative impact on predictive performance of regressions?

5 comments

We thank the reviewer for their very helpful and thoughtful ideas.

Broader significance

Our broader takeaway is that it is possible to do time series classification at archive-scale in seconds whilst maintaining accuracy. Mantis (2026) describes itself as a “new state-of-the-art” on a subset of our 188 datasets and has 27,520 monthly downloads on HuggingFace [1]. FlashRocket is 298× faster and more accurate, suggesting it could be broadly useful.

Single alpha (ridge parameter)

(i) Our rationale is that alpha wouldn't need to be re-discovered by new users on these 188 datasets, saving about 10 seconds every time. This could apply to thousands of users and repeats. The four-candidate global-alpha search took 16.214 seconds of validation compute on one L40S, which we will add to the appendix.

(ii) The extent to which a fixed alpha generalizes to new datasets is a very interesting question. We agree with the reviewer's two hypotheses and add this analysis:

\text{Dataset} & \text{Training series} & \text{Fixed alpha accuracy (\\%)} & \text{Tuned alpha accuracy (\\%)} & \text{Difference (pp)} \\\\ \hline \text{InsectWingbeat} & \text{25,000} & \text{68.460} & \text{68.472} & \text{-0.012} \\\\ \text{AustraliaRainfall} & \text{112,186} & \text{76.581} & \text{76.656} & \text{-0.075} \\\\ \text{BeijingPM10Quality} & \text{11,918} & \text{82.884} & \text{82.845} & \text{+0.040} \\\\ \text{BeijingPM25Quality} & \text{11,918} & \text{88.174} & \text{88.193} & \text{-0.020} \\\\ \text{WISDM} & \text{11,989} & \text{88.893} & \text{87.483} & \text{+1.410} \\\\ \end{array}$$ For the 5 datasets where the number of training series is greater than the number of features, the fixed alpha was essentially tied with per-task alpha accuracy. This is interesting because our fixed alpha was tuned on equal weight across all 187 datasets (182 which are small), suggesting that a fixed alpha tuned from majority small datasets doesn’t significantly harm larger datasets. Other notes we want to emphasize: 1. The alternative of per-task alpha search can be suboptimal. Since most of the time series datasets are very small, choosing an alpha per hundred series can be noisy. 2. Mean validation accuracy is relatively insensitive to fixed alpha over the tested range 0.1–2.15, varying by only 0.21 percentage points (Table 4, Appendix D). We also tested fixed alpha = 0.464158883 against per-task search on 24 new datasets (3 Redux, 21 Multiverse-Core): $$\begin{array}{llll} \text{Setup} & \text{Time (s)} & \text{Mean accuracy (\\%)} & \text{Our setup speedup} \\\\ \hline \text{Fixed alpha + CG8 (our setup)} & \text{3.199} & \text{76.2961} & \text{--} \\\\ \text{Tuned alpha + exact solver} & \text{12.483} & \text{73.8983} & \text{3.90}\times \\\\ \end{array}$$ Fixed alpha wins on 7, ties on 6 and loses on 11 datasets. This shows how fixed alpha can be a reasonable design choice for new datasets. We do not guarantee that fixed regularisation works for all problems. Practically, fixed alpha is a cheap optimization worth trying first on new datasets (~4× speedup here). If it performs poorly, users can use FlashRocket with per-task search, which finished in 13.55 s on our original datasets. **Related work** We will expand the related work to give a broader explanation of existing time series methods. **Memory scalability** Storing extracted features and associated temporary arrays are major contributors to GPU memory usage. We propose two ideas for memory scalability: 1. Process features in chunks to reduce temporary allocations. 2. Store training features in FP16 instead of FP32, keeping normalization and solver arithmetic in FP32. We tested these in one L40S + 16 CPUs job on all 188 datasets: $$\begin{array}{lllllll} \text{Variant} & \text{Runtime (s)} & \text{Peak GPU allocated (GiB)} & \text{Peak sampled GPU total (GiB)} & \text{GPU total peak reduction (\\%)} & \text{Peak sampled CPU RAM (GiB)} & \text{Accuracy (\\%)} \\\\ \hline \text{FlashRocket original} & \text{3.157} & \text{12.69} & \text{27.10} & \text{--} & \text{13.54} & \text{83.0661} \\\\ \text{FP16 storage} & \text{3.132} & \text{14.73} & \text{34.32} & \text{-26.6\\%} & \text{13.60} & \text{83.0618} \\\\ \text{Chunking} & \text{3.084} & \text{7.51} & \text{15.40} & \text{43.2\\%} & \text{13.71} & \text{83.0588} \\\\ \text{FP16 + chunking} & \text{3.096} & \text{4.62} & \text{12.62} & \text{53.5\\%} & \text{13.74} & \text{83.0954} \\\\ \end{array}$$ Together, these reduce sampled GPU total by 53.5%, with similar observed time and accuracy. The 12.62 GiB sampled GPU total suggests potential for a 16 GB GPU. Future work can further improve memory scalability and test its limits as the number of series, channels and time points increases. [1] [https://huggingface.co/paris-noah/MantisV2](https://huggingface.co/paris-noah/MantisV2)
AuthorsOpenReview ↗

Per-dataset results for the 24 additional datasets

\text{Dataset} & \text{Training series} & \text{Fixed alpha + CG8 (our setup) accuracy (\\%)} & \text{Tuned alpha + exact solver accuracy (\\%)} & \text{Difference (pp)} \\\\ \hline \text{ElectricDeviceDetection} & \text{624} & \text{86.412} & \text{30.945} & \text{+55.467} \\\\ \text{KeplerLightCurves} & \text{920} & \text{91.479} & \text{92.231} & \text{-0.752} \\\\ \text{PhoneHeartbeatSound} & \text{424} & \text{66.484} & \text{65.385} & \text{+1.099} \\\\ \text{Alzheimers} & \text{45} & \text{48.837} & \text{48.837} & \text{+0.000} \\\\ \text{BIDMC32HR_disc} & \text{5,550} & \text{87.870} & \text{68.404} & \text{+19.466} \\\\ \text{BIDMC32SpO2_disc} & \text{5,550} & \text{59.900} & \text{61.442} & \text{-1.542} \\\\ \text{CounterMovementJump} & \text{419} & \text{89.385} & \text{89.385} & \text{+0.000} \\\\ \text{CrowdSourced} & \text{9,456} & \text{73.809} & \text{75.256} & \text{-1.447} \\\\ \text{FordChallenge} & \text{29,003} & \text{86.587} & \text{87.207} & \text{-0.620} \\\\ \text{HouseholdPowerConsumption1_disc} & \text{745} & \text{89.504} & \text{89.942} & \text{-0.437} \\\\ \text{HouseholdPowerConsumption2_disc} & \text{745} & \text{77.697} & \text{79.300} & \text{-1.603} \\\\ \text{IEEEPPG_disc} & \text{1,768} & \text{40.060} & \text{39.157} & \text{+0.904} \\\\ \text{KERAAL-RTK} & \text{256} & \text{71.429} & \text{71.429} & \text{+0.000} \\\\ \text{Locust2022} & \text{6,597} & \text{91.634} & \text{91.634} & \text{+0.000} \\\\ \text{LowCost} & \text{600} & \text{62.667} & \text{60.167} & \text{+2.500} \\\\ \text{MindReading} & \text{727} & \text{58.806} & \text{58.499} & \text{+0.306} \\\\ \text{MotionSenseHAR} & \text{966} & \text{100.000} & \text{100.000} & \text{+0.000} \\\\ \text{PhotoStimulation} & \text{37} & \text{38.889} & \text{41.667} & \text{-2.778} \\\\ \text{STEW} & \text{21,384} & \text{74.818} & \text{73.401} & \text{+1.417} \\\\ \text{Skoda} & \text{11,290} & \text{85.603} & \text{95.189} & \text{-9.586} \\\\ \text{TactileTextureRecognition} & \text{1,586} & \text{100.000} & \text{100.000} & \text{+0.000} \\\\ \text{Tiselac} & \text{79,907} & \text{80.950} & \text{84.247} & \text{-3.296} \\\\ \text{UCIActivity} & \text{7,898} & \text{99.334} & \text{99.500} & \text{-0.167} \\\\ \text{USCActivity} & \text{43,060} & \text{68.955} & \text{70.337} & \text{-1.382} \\\\ \end{array}$$

As today is the last day of the discussion period, we would like to ask whether our response has addressed your concerns. Thank you for your time and helpful feedback.

Reviewer_6tCyOpenReview ↗
Rating
4(+1)
Confidence
2
Informativeness
2
Presentation
3
Soundness
3
Read review
Paper summary

The authors indicate that keeping GPUs efficiently utilized across different tasks is challenging. To bridge this gap, FlashRocket is presented as a GPU system for training and evaluating MiniRocket-based classifiers across heterogeneous time-series datasets. It combines fused feature extraction, shared computation, long-sequence tiling, cross-task scheduling, and simplified ridge heads. Evaluated on 188 datasets, it reports a total runtime of 3.07 seconds, substantially lower than the evaluated implementation while achieving average accuracy comparable to MiniRocket.

Critical strengths
  1. The paper addresses a practical problem of efficiently processing many classification tasks with widely varying dataset shapes.
  2. The proposed optimizations are well motivated, and the evaluation covers 188 datasets across 4 archives.
  3. The paper provides component ablations, per-dataset accuracy results, and detailed implementation information.
  4. The limitations and several benchmarking qualifications are explicitly acknowledged.
Critical weaknesses
  1. The discussion of Related Work omits CUROCKET[1], which implements convolution and feature aggregation through custom CUDA kernels, publised in January 2026. It also omits Hydra[2], which integrates GPU Hydra feature extraction with iterative ridge fitting, published in 2024.
  2. Appendix F reports substantial MiniRocket runtime variation and acknowledges that run order and competing node activity were uncontrolled, while only two FlashRocket timing repeats are reported.
  3. FlashRocket changes both feature extraction and head fitting, making it difficult to separate kernel-level improvements from classifier and execution choices. A tsai extractor paired with the FlashRocket head would provide an informative control. Comparisons with an optimized CPU MiniRocket implementation and the GPU Hydra/ridge pipeline would also strengthen the assessment of practical speed–accuracy trade-offs.

[1] Stüven, Ole, Keno Moenck, and Thorsten Schüppstuhl. "CUROCKET: Optimizing ROCKET for GPU." arXiv preprint arXiv:2601.17091 (2026).

[2] Dempster, Angus, et al. "Highly scalable time series classification for very large datasets." International Workshop on Advanced Analytics and Learning on Temporal Data. Cham: Springer Nature Switzerland, 2024.

Questions for authors
  1. How does FlashRocket differ from CUROCKET and the scalable GPU Hydra/ridge pipeline, particularly in fused extraction, head fitting, and execution scheduling?
  2. Does the headline speedup persist under controlled, repeated timing runs? Please report timing distributions and clarify warm-up and synchronization procedures.
  3. How much acceleration remains when the tsai extractor uses the FlashRocket head? How does the complete system compare with optimized CPU MiniRocket and GPU Hydra/ridge implementations?
5 comments

We thank the reviewer for their helpful suggestions and questions.

Questions

FlashRocket vs CUROCKET and Hydra/ridge

We will add CUROCKET and Hydra to our related work discussion. Here is a comparison table.

& \text{CUROCKET} & \text{Hydra/ridge (Dempster et al., 2024)} & \text{FlashRocket} \\\\ \hline \text{Extraction} & \text{ROCKET, custom CUDA kernel} & \text{Hydra, PyTorch on GPU} & \text{MiniRocket, fused kernel with shared sum and tiling} \\\\ \text{Head} & \text{none} & \text{exact ridge from accumulated Gram matrices, λ searched per dataset} & \text{ridge with one fixed α, Cholesky or conjugate gradients} \\\\ \text{Scheduling} & \text{one dataset} & \text{one dataset, streamed in batches} & \text{188 tasks overlapped as one workload} \\\\ \end{array}$$ **Headline speedup under repeated timing runs** We do 10 runs per method in one L40S + 16 CPUs job: $$\begin{array}{lllll} \text{Method} & \text{Runs} & \text{Time (s), mean }\pm\text{ SD} & \text{FlashRocket speedup} & \text{Accuracy (\\%)} \\\\ \hline \text{FlashRocket} & \text{10} & \text{2.994 }\pm\text{ 0.036} & \text{--} & \text{83.0661} \\\\ \text{tsai MiniRocket} & \text{10} & \text{601.392 }\pm\text{ 5.451} & \text{200.84}\times & \text{83.1047} \\\\ \end{array}$$ Data/module loading and explicit compile-only setup are before timing. Training and prediction are timed with GPU synchronization; accuracy scoring is excluded. Each repeat uses a fresh process, with no synthetic warm-up or extra fit beforehand. The GPU and CPUs were allocated to our job. **tsai extractor paired with the FlashRocket head** We will clarify in the revision that most of the absolute runtime reduction comes from our ridge head and execution setup. We test the tsai extractor with our setup and head, alongside our extractor in the same L40S job: $$\begin{array}{llll} \text{Method} & \text{Time (s)} & \text{FlashRocket speedup} & \text{Accuracy (\\%)} \\\\ \hline \text{FlashRocket} & \text{3.087} & \text{--} & \text{83.0661} \\\\ \text{tsai MiniRocket extractor + FlashRocket head} & \text{58.005} & \text{18.79}\times & \text{83.0321} \\\\ \end{array}$$ An 18.79× full-pipeline speedup remains. **Complete FlashRocket system vs CPU MiniRocket** $$\begin{array}{lllll} \text{Method} & \text{Hardware} & \text{Time (s)} & \text{FlashRocket speedup} & \text{Accuracy (\\%)} \\\\ \hline \text{FlashRocket} & \text{L40S + 16 CPUs} & \text{2.994 }\pm\text{ 0.036} & \text{--} & \text{83.0661} \\\\ \text{Author CPU MiniRocket + ridge} & \text{16 CPUs} & \text{5872.071} & \text{1961.07}\times & \text{83.1025} \\\\ \end{array}$$ We used the MiniRocket authors' optimized CPU implementation from GitHub, with ridge heads for all datasets. **Complete FlashRocket system vs GPU Hydra/ridge (L40S + 16 CPUs)** $$\begin{array}{llll} \text{Method} & \text{Time (s)} & \text{FlashRocket speedup} & \text{Accuracy (\\%)} \\\\ \hline \text{FlashRocket} & \text{2.994 }\pm\text{ 0.036} & \text{--} & \text{83.0661} \\\\ \text{Author GPU Hydra/ridge} & \text{40.892} & \text{13.66}\times & \text{82.2723} \\\\ \end{array}$$ **Response to Critical Weaknesses** **MiniRocket runtime variation** The original interleaved MiniRocket timing difference came mainly from AustraliaRainfall's CPU head fit: $$\begin{array}{llll} \text{Measured interval} & \text{First run (s)} & \text{Last run (s)} & \text{First - last (s)} \\\\ \hline \text{Full interleaved run} & \text{954.878} & \text{634.244} & \text{320.634} \\\\ \text{AustraliaRainfall CPU head fit} & \text{555.767} & \text{248.093} & \text{307.674} \\\\ \text{Remaining elapsed time} & \text{399.111} & \text{386.151} & \text{12.960} \\\\ \end{array}$$ The cause of the slower AustraliaRainfall fit remains unresolved. This run variability emphasizes the need for more stable ridge fitting, which we provide with FlashRocket. We included the 10 repeated tsai MiniRocket runs above, which provide a more robust estimate of the overall FlashRocket speedups.

As today is the last day of the discussion period, we would like to ask whether our response has addressed your concerns. Thank you for your time and helpful feedback.

We wanted to follow up before the discussion period closes. Thank you again for your time and helpful feedback.

Reviewer_qKj6OpenReview ↗
Rating
3(+1)
Confidence
2
Informativeness
2
Presentation
3
Soundness
2(+1)
Read review
Paper summary

The paper introduces FlashRocket, a system that:

  • trains and tests classifiers on MiniRocket features within a single GPU workload,
  • extracts features in a single fused on-chip pass,
  • fits a cheaper ridge classification head.

The results show a substantial speedup over minirocket with maintained accuracy.

Critical strengths
  • The substantial improvements in the training time and inference time while preserving average predictive accuracy.
  • Addressing heterogeneous workloads in an effective way, utilizing tiling long series.
  • Broad evaluation on multiple time-series.
Critical weaknesses
  • While there is an ablation study, there is not enough data to identify which components provide the most significant speedup. It would be helpful to understand which of the included aspects yields the most impact (feature extraction vs ridge head)
  • The measurements are limited to one GPU model, very limited number of repeats, and substantially varying execution time for MiniRocket.
  • Comparison with MOMENT is based on "accounting estimate", and, therefore, limited.
Questions for authors
  • How much speedup can be attributed to the feature extractor and how much to ridge head? Could you compare the tsai and FlashRocket extractors using the same set-up and head?
  • How stable are the speedup values across multiple runs, runs with fewer tasks, different task orders, removal of the largest datasets, etc?
  • How controlled is the environment? Is the machine idle? Is there any chance that caching affects the results? What is the reason for time varying from 954 s vs 634 s for interleaved MiniRocket run?
5 comments

We thank the reviewer for their thoughtful suggestions and questions.

Questions

Feature extractor vs ridge head speedup

We will clarify in the revision that most of the absolute runtime reduction comes from our ridge head and execution setup. We test the tsai extractor with our setup and head, alongside our extractor in the same L40S job:

\text{Method} & \text{Time (s)} & \text{FlashRocket speedup} & \text{Accuracy (\\%)} \\\\ \hline \text{FlashRocket} & \text{3.087} & \text{--} & \text{83.0661} \\\\ \text{tsai MiniRocket extractor + FlashRocket head} & \text{58.005} & \text{18.79}\times & \text{83.0321} \\\\ \end{array}$$ An 18.79× full-pipeline speedup remains. **Speedup stability across settings** We do additional experiments for multiple runs, runs with fewer tasks, different task orders, and removal of largest datasets. The broad takeaway is that FlashRocket speedups persist across all tested settings. **10 runs on L40S + 16 CPUs** $$\begin{array}{lllll} \text{Method} & \text{Runs} & \text{Time (s), mean }\pm\text{ SD} & \text{FlashRocket speedup} & \text{Accuracy (\\%)} \\\\ \hline \text{FlashRocket} & \text{10} & \text{2.994 }\pm\text{ 0.036} & \text{--} & \text{83.0661} \\\\ \text{tsai MiniRocket} & \text{10} & \text{601.392 }\pm\text{ 5.451} & \text{200.84}\times & \text{83.1047} \\\\ \end{array}$$ **Runs with fewer tasks** $$\begin{array}{lllll} \text{Method} & \text{47 datasets: time (s)} & \text{94 datasets: time (s)} & \text{47 datasets: accuracy (\\%)} & \text{94 datasets: accuracy (\\%)} \\\\ \hline \text{FlashRocket} & \text{1.062} & \text{1.579} & \text{85.5114} & \text{84.2158} \\\\ \text{tsai MiniRocket} & \text{550.952} & \text{624.741} & \text{85.3269} & \text{84.1814} \\\\ \text{FlashRocket speedup} & \text{518.57}\times & \text{395.67}\times & \text{--} & \text{--} \\\\ \end{array}$$ **Different task orders** $$\begin{array}{lllll} \text{Method} & \text{Order 1: time (s)} & \text{Order 2: time (s)} & \text{Order 1: accuracy (\\%)} & \text{Order 2: accuracy (\\%)} \\\\ \hline \text{FlashRocket} & \text{3.062} & \text{3.008} & \text{83.0661} & \text{83.0661} \\\\ \text{tsai MiniRocket} & \text{637.268} & \text{2153.460} & \text{83.1047} & \text{83.1047} \\\\ \text{FlashRocket speedup} & \text{208.15}\times & \text{715.81}\times & \text{--} & \text{--} \\\\ \end{array}$$ **Removal of the five datasets with the most training series** $$\begin{array}{llll} \text{Method} & \text{Time (s)} & \text{FlashRocket speedup} & \text{Accuracy (\\%)} \\\\ \hline \text{FlashRocket} & \text{2.544} & \text{--} & \text{83.1394} \\\\ \text{tsai MiniRocket} & \text{129.887} & \text{51.06}\times & \text{83.1885} \\\\ \end{array}$$ **Control of environment** Our environment is quite controlled. Each L40S job had one L40S GPU and 16 allocated CPUs, with nothing else running on our allocated resources. Each run uses a fresh process. The original interleaved MiniRocket timing difference came mainly from AustraliaRainfall's CPU head fit: $$\begin{array}{llll} \text{Measured interval} & \text{First run (s)} & \text{Last run (s)} & \text{First - last (s)} \\\\ \hline \text{Full interleaved run} & \text{954.878} & \text{634.244} & \text{320.634} \\\\ \text{AustraliaRainfall CPU head fit} & \text{555.767} & \text{248.093} & \text{307.674} \\\\ \text{Remaining elapsed time} & \text{399.111} & \text{386.151} & \text{12.960} \\\\ \end{array}$$ The cause of the slower AustraliaRainfall fit remains unresolved. This run variability emphasizes the need for more stable ridge fitting, which we provide with FlashRocket. We included the 10 repeated tsai MiniRocket runs above, which provide a more robust estimate of the overall FlashRocket speedups. **Critical Weaknesses** **One GPU model** We also did 3 runs per method on one A100 with 16 CPUs: $$\begin{array}{lllll} \text{Method} & \text{Runs} & \text{Time (s), mean }\pm\text{ SD} & \text{FlashRocket speedup} & \text{Accuracy (\\%)} \\\\ \hline \text{FlashRocket} & \text{3} & \text{5.355 }\pm\text{ 0.107} & \text{--} & \text{83.0622} \\\\ \text{tsai MiniRocket} & \text{3} & \text{2584.557 }\pm\text{ 410.458} & \text{482.65}\times & \text{83.1047} \\\\ \end{array}$$ **MOMENT “accounting estimate” clarification** We will clarify the wording in the revision. MOMENT exceeded our cluster’s six-hour job limit, so we had to split the run of 188 datasets across jobs. Together, these took ~29,000 seconds. Subtracting the estimated extra overhead gives ~27,000 seconds (Appendix G). We believe the estimated ~8,800× speedup of FlashRocket over MOMENT is a fair comparison.

Thank you for this additional analysis. I would like to ask whether you updated the paper to include these results/are you planning to do this?

Thank you for your helpful feedback. We plan to include these results in the revised paper. Are there any remaining concerns you’d like us to address?

Comments on the paper

1 comment
Area_Chair_Af8MOpenReview ↗

Discussion Reminder

Dear Reviewers,

Thank you for your efforts so far. This is a friendly reminder to review the authors' rebuttal and respond to their comments as soon as possible, before the discussion deadline (November 18 AoE). Please also indicate whether your concerns have been addressed. Thank you for your time and cooperation!

Best regards,
AC

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.