betaFeedback

WorksComputer Science

TSB-SEG: A Systematic Time-Series Segmentation Benchmark

Abstract

Time-series segmentation, studied as either Change Point Detection (CPD) or State Detection (SD), underpins a broad range of monitoring and diagnostic applications. However, the field suffers from a persistent divide between the statistical community (focusing on CPD) and the machine learning and data mining communities (focusing on SD). Consequently, the literature remains fragmented: evaluations typically cover narrow methodological families, datasets are often small or homogeneous, and CPD and SD are rarely evaluated together. We address these gaps with TSB-SEG, a unified benchmark comprising 592 univariate and multivariate time series from 8 heterogeneous datasets and surveying 26 algorithms that span five decades of progress. To ensure a fair comparison, we introduce a two-pool design: a scalable main pool of tractable detectors used for the aggregate ranking, and an extended-scope pool for computationally intensive methods. All methods are unified under tsseg, an open-source library to ensure full reproducibility. Our systematic evaluation yields three insights: (a) no single detector dominates across domains, and per-dataset hyperparameter tuning remains decisive for performance, (b) CPD accuracy is a useful, though imperfect, proxy for SD accuracy, and (c) data characteristics should guide method selection. We provide actionable guidance based on data properties, error tolerances, and tuning budgets, identify impactful hyperparameters, and characterize algorithm robustness to these choices.

Introduction

The widespread availability of sensing and data acquisition technologies has enabled the large-scale collection of real-valued observations over time, commonly referred to as time series [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24]. Among the many tasks they enable (classification, clustering, anomaly detection, similarity search, pattern mining and forecasting [25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81]), identifying changes in the underlying data-generating process is fundamental to a broad range of monitoring and diagnostic applications, spanning human activity recognition [82, 83, 84], industrial condition monitoring [85], and health assessment [86].

In these settings, the signal can be viewed as a sequence of segments, each reflecting the characteristic behaviour of an underlying process state [87], separated by change points. The literature studies this through two complementary formulations: change point detection (CPD) [88, 89, 4], which localizes boundaries, and state detection (SD) [90, 91], which additionally labels recurring states. The two diverge as soon as states recur: in a wearable recording of walking, running, then walking again, CPD only needs the two boundaries, whereas SD must also recognize the first and last segments as the same activity; an industrial test cycle revisits the same operating modes dozens of times, and a monitored patient alternates between a few physiological regimes. Despite decades of progress, existing benchmarks (Table 1) still suffer from three major limitations: (L1) datasets are homogeneous or small-scale, while methodological coverage rarely extends beyond a single algorithmic family [92]; (L2) SD lacks a comprehensive empirical comparison [90, 93]; (L3) CPD and SD are studied in isolation, leaving the relationship between boundary localization and state identification largely unexplored. Therefore, the following question remains unanswered:

BenchmarkDatasetTaskEval.
# TSUni.Multi.CPDSD# Alg.
UTSA [94]32✓×✓×3
TCPD [92]42✓✓✓×14
SKAB [95]34×✓✓×10
TSSB [4]75✓×✓×7
HAS [84]250×✓✓×13
TSB-SEG592✓✓✓✓26

Table 1. Comparison with existing TSS benchmarks.

What have five decades of advances in segmentation achieved, when evaluated in a unified benchmark?

In this paper, we address this question by introducing TSB-SEG1, the most comprehensive benchmark for time-series segmentation to date. TSB-SEG curates 592 univariate and multivariate series from 8 datasets spanning heterogeneous domains, complemented by a long-series scalability case study. The benchmark surveys 26 algorithms representing five decades of progress, organised by how they search the segmentation and what they compare, and integrated within the open-source library, tsseg [96], which provides a unified fit/predict API. A scalable main pool forms the basis of the aggregate ranking, while an extended-scope pool gathers methods that cannot run on every series (§ 4.1).

Key findings. Our evaluation reveals three transferable insights: (i) no single detector consistently dominates across datasets, making per-dataset tuning essential; (ii) CPD and SD scores are strongly correlated, making CPD accuracy a useful proxy for SD accuracy; (iii) data characteristics should guide method selection.

Contributions. (i) A taxonomy of CPD and SD methods by search procedure and homogeneity criterion (§ 4.1); (ii) TSB-SEG, the first unified benchmark to jointly evaluate CPD and SD across the two-pool design above (§ 4); (iii) 8 complementary CPD and SD metrics, including soft and symmetric variants of the standard CPD measures and the recent WARI and SMS [97] for SD (§ 4.4); (iv) a large-scale evaluation with rigorous statistical testing and clear practical recommendations (§ 5); (v) tsseg, an open-source library packaging all algorithms and metrics, with the TSB-SEG pipelines and dataset loaders for full reproducibility.

Foundation and Related Work

In this section, we review the most relevant related work, formalize time-series segmentation, and discuss the limitations of existing benchmarks. Key notations are summarised in Appendix § 9.

Notation: An abstract process [98] is defined as P=(S,R)P=(S,R), where S={s1,…,snS}S=\{s_1,\ldots,s_{n_S}\} denotes a finite set of discrete and distinct states, and R⊆S×SR \subseteq S \times S denotes admissible transitions between states, with (si,sj)∈R(s_i,s_j) \in R only if si≠sjs_i \ne s_j. Each state is assumed to generate a stationary and distinguishable signature in the observed data. For clarity, we exclude homonym states, whose signals are indistinguishable, as well as states whose semantics drift over time. A time series T=(t1,…,tn)∈Rn×dT=(t_1,\ldots,t_n) \in\mathbb{R}^{n \times d} is a sequence of dd-dimensional observations generated by PP and recorded by dd sensors (univariate when d=1d=1, multivariate otherwise). A subsequence (or window) Ts,eT_{s,e} denotes the contiguous slice (ts,…,te)(t_s,\ldots,t_e) of length e−s+1e-s+1. The state sequence Q=(st1,…,stn)∈SnQ=(s_{t_1},\ldots,s_{t_n}) \in S^n assigns a state to each timestamp. A change point (CP) is an index ii such that sti≠sti+1s_{t_i} \ne s_{t_{i+1}}, and the contiguous interval between two CPs is a segment of the time series, generated by a single state.

Time Series Segmentation (TSS): A Multifaceted Problem

TSS partitions a time series into homogeneous segments and is studied through two complementary formulations, as illustrated in Figure 1.

Figure 1. Time Series Segmentation: Change Point Detection (CPD) and State Detection (SD).

Change Point Detection (CPD). CPD [99, 88, 89] aims to identify the temporal indices at which the underlying data-generating process changes, thereby partitioning TT into segments that are internally homogeneous while remaining distinct from adjacent ones. It is also a special case of Change Interval Detection [100], where the change is localized to an instantaneous boundary.

State Detection (SD). SD (a.k.a. semantic segmentation or regime shift detection) reconstructs the latent state sequence [98] by assigning an unsupervised label to every observation, such that temporally disjoint but structurally similar regions receive the same label. In this sense, SD extends CPD with a clustering objective: equal-state segments share a label, different-state segments do not. Since the labels are inferred without supervision, the optimal outcome is a prediction Q^\hat{Q} isomorphic to the ground-truth QQ. By construction, Q^\hat{Q} induces a segmentation (a change point wherever the label changes), so every SD method is also a CPD method, which lets us score SD methods on both tasks.

In most settings, the number of segments or states is assumed to be unknown a priori, reflecting a challenge analogous to determining the number of clusters in unsupervised clustering [101].

Gaps in Existing Benchmarks

Existing TSS benchmarks listed in Table 1 suffer from three structural limitations:

(L1) Limited dataset diversity. Most existing benchmarks for TSS remain limited in either scale or scope. Many focus on a single application domain [84], contain a small number of time series [94, 95, 92], or restrict evaluation to either univariate [94, 4] or multivariate settings [95, 84]. As a result, no current benchmark simultaneously captures diversity in domains, dimensionality, and segmentation complexity at scale, which limits the external validity of empirical findings.

(L2) SD remains underexplored. In contrast to CPD, which has been extensively studied [94, 95, 92, 4, 84], SD has received comparatively little attention from an empirical evaluation perspective. To the best of our knowledge, SD methods have only been compared within individual method papers [90, 93], each with its own datasets and protocol, and no dedicated SD benchmark exists.

(L3) CPD and SD are studied in isolation. Despite their conceptual proximity, CPD and SD have been evaluated separately, with no benchmark jointly evaluating both tasks on shared datasets or analyzing the relationship between boundary location accuracy and state identification quality. It thus remains unclear how far advances in CPD transfer to SD.

Objectives and Research Questions

The primary objective of this work is to establish a systematic and reproducible evaluation framework for TSS methods that addresses the limitations of existing benchmarks discussed in § 2.2. Guided by this objective, we investigate the following research questions:

RQ1: Do we have a “one size fits all” method? This question examines whether any existing CPD or SD method achieves consistently strong performance across varying domains.

RQ2: Can CPD performance serve as a reliable proxy for SD accuracy? Since CPD labels are easier to obtain, establishing CPD accuracy as a proxy for SD would be impactful.

RQ3: Which actionable guidelines exist in real applications? We analyse runtime-accuracy trade-offs, scalability, and sensitivity to input properties, to provide practical guidelines.

TSB-SEG: Our Proposed Benchmark

We present TSB-SEG, a benchmark specifically designed to address the gaps outlined in § 2.2. For (L1), we curate 8 heterogeneous datasets (592 labeled series, univariate and multivariate, from diverse domains) and PAMAP2 as a long-series scalability case study; for (L2), we treat SD as a first-class task with 7 dedicated methods and state-level annotations on every dataset, enabling the first reproducible large-scale SD comparison; for (L3), we also score the SD methods on CPD, through the change points their labels induce, enabling direct cross-task analysis. All algorithms and metrics are released through tsseg, and the evaluation pipelines through the TSB-SEG repository; 13 of the 26 algorithms were absent from existing toolkits (aeon [102], sktime [103], ruptures [88], and the R package changepoint [104]) and were re-implemented or adapted (univariate/multivariate extensions); see Appendix § 12.

Taxonomy: Search Procedure and Homogeneity Criterion

We organise the 26 algorithms with two questions (Figure 2), which extend to SD the decomposition of a CPD method into a search method and a cost function [88]: how is the segmentation searched? (columns) and what must stay the same within a segment? (rows). The search sets the runtime of a method and how it chooses the number of changes (a threshold, a penalty, a prior, or a given KK); the criterion sets which changes it can detect at all (details in Appendix § 11).

Figure 2. Time-series segmentation taxonomy: search procedure (columns; DP: dynamic programming) and homogeneity criterion (rows). Tinted: evaluated in TSB-SEG; white: representative methods not evaluated (Appendix § 11). K: needs (filled) or accepts (outlined) nCPn_{CP} or nSn_{S} (§ 4.3).

How CPD methods search. The simplest search is local: a profile method scores every time point, usually by contrasting the windows on its two sides, and reports the peaks of this score (Window [88], ChangeFinder [105], iCID [100], FLUSS [94], ESPRESSO [106], TIRE [107], TS-CP² [108], tGLAD [109]). The other searches compare whole segments. Bottom-up search starts from a fine partition and repeatedly merges the two most similar neighbours (BottomUp [110], EAgglo [111]); top-down search (binary segmentation) does the reverse, placing the best single split and recursing on each part (BinSeg [112], GGS [113], IGTS [114], ClaSP [4]). Both are greedy: apart from the local readjustments of GGS, they never revisit an earlier split or merge. Convex relaxation fits a piecewise model with an ℓ1\ell_1 penalty on its jumps, most of which become exactly zero (Prophet [115]). Optimal search minimises a sum of segment costs exactly by dynamic programming, under a penalty per change or a fixed number of them (AMOC [116], PELT [117], DynP [88]), and Bayesian search weighs every segmentation by its posterior probability (BOCD [118]).

How SD methods search. SD must also decide which segments share a state. State-sequence methods do both at once: as in a hidden Markov model, they give a state to every step or window and pay for each switch (AutoPlait [119], HDP-HSMM [120], TICC [121]). Segment-then-group methods cluster the segments of a CPD method (CLaP [93], on those of ClaSP). Window clustering labels each window independently: time order is ignored (Hidalgo [122]) or only enters the representation, learned contrastively from adjacent windows (Time2State [90], E2USD [91]). The optimal, Bayesian, and state-sequence searches share one dynamic programme over the position of the last change, which keeps the cheapest segmentation (optimal), sums over all of them (Bayesian), or also tracks the state of each segment (state sequence).

What must stay the same. Most methods compare the fit or likelihood of a model of the observations (a mean, a covariance, an autoregression); others compare distributions without a model (kernels, energy or Wasserstein distances, density ratios), the shapes of subsequences (nearest neighbours, classifiers, symbolic patterns), or a representation learned by a neural network. A cost on the mean, for instance, misses a change of variance that a kernel comparison detects. The penalised detectors (Window, BinSeg, BottomUp, PELT, DynP) take their cost as a parameter and span the first two rows.

Main pool vs. extended scope. Real-world series routinely reach n=104n = 10^4-10610^6 samples, where an O(n2)O(n^2) method may become intractable before it becomes uninteresting. The main pool (§ 5) gathers 21 algorithms: 15 CPD and 6 SD methods. The extended-scope pool (Appendix § 16) gathers 5 algorithms that cannot run on every series: BOCD and EAgglo are at least quadratic, the neural training of TS-CP² and tGLAD exceeds our compute budget on parts of the benchmark, and Hidalgo is multivariate-only. We verify that it never beats the main pool on shared cells, so this scoping does not hide a state-of-the-art outlier.

Heterogeneous Time Series Collection

TSB-SEG bundles 8 datasets (592 labelled series) used for the systematic evaluation, and a 9th dataset, PAMAP2 [123] (9 series), kept aside as a long-series scalability case study (§ 5). The 8 main datasets contain univariate (TSSB [4], UTSA [94]) and multivariate (d∈[4,10]d \in[4,10]) series (ActRecTut [124], HAS [84], MoCap [125], USC-HAD [126], SKAB [95], PUMP [127]), drawn from heterogeneous domains such as human activity recognition, industrial monitoring, healthcare, robotics, simulations, biology. Series lengths range from 240 to 56,251, the number of CPs from 0 to 78, and the number of distinct states from 1 to 43. Per-dataset statistics are reported in Table 2, with more details in Appendix § 10. All labels are inherited from the original dataset authors, without re-annotation; Appendix § 10 discusses their provenance and uncertainty.

Dataset#TSnnddnCPn_{CP}nSn_{S}
MoCap [125]95–11k45–103–9
HAS [84]2500.3–41k6–90–141–12
ActRecTut [124]231–33k10426
PUMP [127]12020–41k950–7841–43
SKAB [95]340.7–1.3k81–22
USC-HAD [126]7025–56k61112
UTSA [94]322–40k11–22–3
TSSB [4]750.2–21k10–81–7
PAMAP2 [123]98–447k92–272–13

Table 2. Datasets and their characteristics.

Evaluation Modes

Every algorithm is evaluated under two complementary modes. In Default mode, each algorithm runs one configuration θ0\theta_0, recommended by its authors or the original implementation (Appendix § 14). In Parameter-search mode, we sweep a grid of 2-4 values for the 2-4 most influential parameters, calibrated on pilot series in the same way for every algorithm (Appendix § 14). For each (algorithm, dataset) pair, the configuration with the highest (lowest) dataset-level mean score, applied uniformly to every series of that dataset, gives the tuned (worst-case) score. Their gap Δ=Ptuned−Pworst\Delta= P_{\mathrm{tuned}} - P_{\mathrm{worst}}, the tuning gap, exposes the algorithm’s sensitivity to its hyperparameters. Selected on the evaluation labels, the tuned score is optimistic, as in the oracle experiment of TCPDBench [92], though less so since one configuration serves a whole dataset. A few methods (e.g. AutoPlait) are essentially parameter-free and use a single configuration. Orthogonally, the expected number of events K∈{nCP,nS}K \in\{n_{CP}, n_{S}\} is treated as a separate guidance dimension since it is hard to estimate from data alone: every algorithm runs in Non-Guided (must infer KK) and Guided (ground-truth KK provided) modes. Guided mode is an oracle analysis: knowing KK removes the hardest model-selection step, so it bounds what a method can reach; it is also directly relevant when KK is fixed by the protocol (scripted sessions, test cycles) or given by an expert, and the gap between the two modes measures the error due to estimating KK. Methods that cannot ingest KK (e.g. PELT) have Guided ≡\equiv Non-Guided.

Evaluation Metrics

We assess segmentation quality with task-specific metrics (Table 3; formal definitions in Appendix § 13). For CPD, we report the standard F1F_1-score (CP localisation within a 1% margin) and Covering score (segment alignment via maximum IoU). Both have known limitations [97]: F1F_1 is discontinuous in the margin (a single-sample shift can flip a sparse-CP score from 1 to 0) and standard Covering is asymmetric and insensitive to over-segmentation. Event detection faces the same issue, which SoftED [128] addresses with metrics that give partial credit to detections close to an event; in the same spirit, we complement F1F_1 and Covering with their natural soft and symmetric counterparts: Gaussian F1F_1 (replacing the hit-or-miss indicator with a Gaussian reward kernel centred on each true CP, with a greedy bipartite matching to predictions) and Bidirectional Covering (BiC) (harmonic mean of the prediction-to-truth and truth-to-prediction Covering directions). For SD, the standard ARI and AMI disregard temporal ordering; following [97] we additionally report WARI (a temporally-weighted ARI) and the interpretable State Matching Score (SMS), which decomposes its penalty into four error types used in RQ2-RQ3: Delay (a boundary placed slightly early or late), Transition (a spurious state between two true segments), Isolation (a spurious fragment inside a true segment, i.e. over-fragmentation) and Missing (a true segment left undetected). BiC, Gaussian F1F_1 and the Delay class of SMS tolerate small boundary shifts, which limits the influence of annotation uncertainty. The main text reports BiC (CPD) and SMS (SD); the other metrics are reported in Appendix § 27.

TaskMetricKey Characteristic
CPDF1F_1-scoreLocalisation (1% margin)
CoveringSegment alignment (max IoU)
Gaussian F1F_1Smooth proximity reward
BiCSymmetric bidirectional overlap
SDARIClustering agreement
AMIAdjusted mutual information
WARI [97]Temporally-weighted ARI
SMS [97]Interpretable state matching

Table 3. Metrics (primary ones shaded).

Experimental Evaluation

All experiments are reproducible with our open-source repository; compute environment and per-trial budgets are given in Appendix § 15.

RQ1: Overall Accuracy Evaluation

We evaluate the 21 main-pool algorithms across the 8 main TSB-SEG datasets (592 series). The SD methods are also scored on CPD, through the change points their labels induce, except ClaP, which labels the segments of ClaSP and is not scored separately. Three methods (DynP, ESPRESSO, TICC) require the number of change points or states as input and are reported only in the Guided mode. For each (algorithm, dataset) pair, we report the tuned, median, and worst-case configurations (Section 4.3) and the default one. Figure 3 and Figure 4 report CPD and SD results in both supervision modes; per-dataset and per-domain views are in Appendices § 18-§ 19.

Figure 3. CPD performance - Non-Guided and Guided modes. Strip plots: mean over the 592 series of the tuned configuration (dot), the median and worst-case ones (thick body, thin stem) and the default one (♢); colour: CPD or SD method; dotted line: AMOC. CD diagrams: mean ranks; bars join rank-consecutive methods that a two-sided Wilcoxon signed-rank test with Holm correction does not separate (α=0.1\alpha= 0.1).

Figure 4. SD performance - Non-Guided and Guided modes. (a, b) SMS strip plots and (c) CD diagrams, as in Figure 3; in (c, top), HDP-HSMM is also tied with AutoPlait and E2USD.

CPD. The critical-difference diagram (Figure 3b) places the penalised detectors PELT, BottomUp and BinSeg in a statistically tied top clique (mean ranks 5.77–5.94), followed by two tied pairs, Window and ClaSP, then ChangeFinder and TIRE, TIRE being tied with iCID, IGTS and GGS; the last two cliques (HDP-HSMM, FLUSS, AutoPlait; Prophet, E2USD, Time2State) precede the single-CP reference AMOC. The SD methods, scored on their induced change points, are thus the weakest Non-Guided CPD detectors: lowest mean tuned BiC after AMOC (0.51-0.53), and significantly behind every CPD method but FLUSS and Prophet. In mean tuned BiC, ClaSP (0.70) and the three penalised detectors (0.68-0.69) are level: among CPD methods, ClaSP leads on TSSB, HAS and UTSA, GGS on MoCap and TIRE on ActRecTut, the penalised detectors (Window included) on PUMP, SKAB and USC-HAD. The mean score and the mean rank disagree because ClaSP is a highly feature-dependent method: it is the strict best on 18% of the series, more than any other, but ranks in the bottom half of the methods on 39% of them (against 19-20% for the top clique), so its large wins lift its mean while its frequent losses lower its rank. The strip plot (Figure 3a) reveals a sharply heterogeneous tuning gap: TIRE, ChangeFinder, BottomUp, Window, PELT and BinSeg span wide tuned-to-worst ranges (Δ≈0.35\Delta\approx0.35-0.50), so a poor configuration can drive them below AMOC; FLUSS, Prophet, iCID, IGTS and GGS sit in between (Δ≈0.25\Delta\approx0.25-0.32), while ClaSP stays well above AMOC even in its worst configuration (Δ≈0.17\Delta\approx0.17). Providing nCPn_{CP} (Guided, Figure 3c-Figure 3d) helps unevenly: Time2State, E2USD and GGS gain +0.14 to +0.17 in mean tuned BiC, IGTS, FLUSS, BinSeg, BottomUp, Prophet, Window, TIRE and ClaSP +0.05 to +0.10, HDP-HSMM, ChangeFinder and iCID at most +0.03, while PELT, AMOC and AutoPlait, which cannot use nCPn_{CP}, are unchanged. DynP, which requires nCPn_{CP}, takes the lead (tuned BiC 0.78, mean rank 6.71), statistically tied with BottomUp, itself tied with BinSeg and GGS. Among the methods that require nCPn_{CP}, TICC (0.64) comes closest to the leaders, while ESPRESSO (0.57) stays in the lower half.

SD. The picture is sharper: CLaP attains the lowest mean rank (2.32), significantly ahead of the four other methods (mean ranks 3.12-3.23), of which the test separates only Time2State from the rest (Figure 4c, top). The strip plot (Figure 4a) confirms CLaP’s lead: it achieves the highest mean tuned SMS (0.63) with a narrow tuning gap, while Time2State and E2USD trail it (0.50-0.51) with wider gaps, and HDP-HSMM and AutoPlait have the lowest means (0.48). Adding the ground-truth number of states (Figure 4b and Figure 4c, bottom) brings TICC into the comparison; it remains below the leaders, and CLaP now leads alone (mean rank 2.63, tuned SMS 0.71), significantly ahead of Time2State (2.92). Notably, CLaP, the strongest SD method, labels the segments found by ClaSP, a CPD method: in such segment-then-group pipelines, progress in CPD carries over to SD, up to the labeling stage, which remains the bottleneck where states recur (RQ2).

Beyond the means. Two views in Appendix L complete this picture. Picking the best method of each series would raise the mean score by 0.11 to 0.16 over the single best method in every task and mode, so even the leaders leave much to gain on many series. Without any tuning, the Default configurations keep largely the same leaders.

Answer to RQ1: No method dominates uniformly across tasks and modes. Per-dataset hyperparameter tuning is critical for many CPD methods. When available, providing the number of change points or states substantially improves performance for most methods.

RQ2: Change Point Detection vs. State Detection

To probe the link between CPD and SD, we restrict attention to SD algorithms and depict in Figure 5a every run both as CPD (BiC) and as SD (SMS), pooling the Non-Guided and Guided modes; analysed separately, each mode leads to the same conclusions (Appendix M). We report the residual r=SMS−BiCr = \mathrm{SMS} - \mathrm{BiC} in Figure 5b.

Figure 5. CPD vs. SD on every run of the SD methods, both modes. (a) SMS against BiC; the dashed envelope holds 95% of the runs, the tails outside it in black. (b) Distribution of r=SMS−BiCr = \mathrm{SMS} - \mathrm{BiC}. (c) Mean share of each SMS error type per zone (default configurations).

CPD is a useful but imperfect proxy for SD. The residual rr is sharply concentrated around 0: ∼34%\sim34\% of runs satisfy ∣r∣≤0.05\lvert r\rvert\le0.05 and an empirical ≈95%\approx95\% envelope holds r∈[−0.27,+0.36]r \in[-0.27, +0.36]. The agreement is statistical rather than deterministic: the scatter (Figure 5a) shows negligible vertical spread for any given BiC. In practice, a strong CPD score reliably indicates a strong SD score (e.g. BiC ≥0.8\ge0.8 rarely yields SMS <0.6< 0.6), but exceptions exist in both directions. Since change-point labels are far cheaper than dense state annotations, BiC remains a useful and inexpensive proxy for SD performance on average. The proxy is tightest when states do not recur (∣r∣≤0.05\lvert r\rvert\le0.05 for 41% of runs, against 23% when they do) and weakest on series with many recurring states such as PUMP (median r=−0.18r = -0.18), where correct boundaries do not guarantee correct labels. Conversely, the SD methods are the weakest CPD detectors (RQ1; CLaP takes its boundaries from ClaSP, a CPD method): their boundaries are a by-product of labelling windows (blocks of samples for HDP-HSMM), placed at that resolution, and lost whenever two adjacent segments are assigned the same state.

The asymmetric tails reflect two distinct error regimes. The SMS error breakdown (Figure 5c) clarifies what drives each tail. In the lower tail (r<−0.27r < -0.27), the SMS penalty is split between Missing (≈40%\approx40\%) and Delay (≈36%\approx36\%) errors: the segmentation is acceptable but the clustering stage mis-labels segments, so SMS collapses while BiC stays high. In the upper tail (r>+0.36r > +0.36), the penalty is dominated by Isolation (≈88%\approx88\%): heavy over-segmentation crashes BiC, but SMS only mildly penalises spurious fragments near a true boundary. Practical headroom therefore lies in clustering improvements (lower tail) and anti-fragmentation regularisation (upper tail).

Answer to RQ2: BiC and SMS are strongly correlated: CPD accuracy is a useful (though imperfect) proxy for SD accuracy. The asymmetric tails decompose into two regimes: a clustering bottleneck (r<−0.27r < -0.27) and over-segmentation (r>+0.36r > +0.36).

RQ3: Actionable Guidelines

We now turn from accuracy to the choices a practitioner faces: runtime, tuning effort and the properties of the series at hand.

Runtime-accuracy trade-off. Apart from AMOC, which places a single change point, the penalised detectors and IGTS are the fastest (median runtime of the tuned configuration at most 4.2 s); all methods but TICC have a median below 60 s, but the 90th percentile exceeds 500 s for ClaSP, CLaP, iCID, ESPRESSO and TICC. For CPD, the fastest methods are also among the most accurate (Figure 6): PELT reaches BiC 0.69 in 0.65 s, BinSeg and BottomUp are within 0.01 at 2-4 s, and only ClaSP scores higher (0.70, at ≈18\approx18 s); with nCPn_{CP} given, DynP, BinSeg and BottomUp lead in 1.6-3 s. For SD, all methods sit in the mid-range of runtimes (Appendix § 21), where CLaP, the most accurate, takes a median of 25-29 s per series.

Figure 6. Runtime-accuracy trade-off and SD error breakdown. (a, b) Mean tuned BiC against median runtime of the tuned configuration (circles: CPD methods; squares: SD methods). (c) Share of each SMS error type in the penalty of each SD method (default configuration; NG: Non-Guided, G: Guided).

Hyperparameter sensitivity. A per-algorithm marginal-score view (Appendix § 22) shows that Time2State, E2USD and iCID are dominated by a single, monotone window-size knob (TIRE and Prophet without KK by their threshold) and are otherwise robust; penalty-based methods (Window, BinSeg, BottomUp, PELT) respond mainly to the penalty, peaking near 8× the BIC penalty (1× for Window), the cost function mattering mostly at low penalties; only TICC exhibits genuine multi-axis sensitivity, so for the other methods a coarse sweep of a single parameter recovers most of the tuning gain. Providing KK flattens the response surface for most methods, partially absorbing the per-series tuning effort. Neither multivariate adaptation (ensembling or L2 reduction) dominates the other.

Sensitivity to input features. Spider plots (Appendix § 18) and Spearman correlations between tuned score and structural features (nn, dd, nCPn_{CP}, nSn_S; Figure 21) show that the penalised detectors are nearly insensitive to these features in Non-Guided mode (∣ρ∣≤0.17|\rho| \le0.17), whereas ClaSP excels on univariate series with few events (TSSB) but degrades on series with many events (ρ≈−0.5\rho\approx-0.5) and on multivariate inputs (ρ≈−0.5\rho\approx-0.5). Time2State and E2USD show the opposite pattern on CPD (ρ≈0.5\rho\approx0.5 with event counts) and their SMS barely depends on dd or nCPn_{CP} (∣ρ∣≤0.15|\rho| \le0.15, against ≈−0.55\approx-0.55 for CLaP), making them the most robust SD picks for complex multivariate series in Non-Guided mode.

Figure 21. Sensitivity of the tuned score to input series features (Spearman ρ\rho). Top: CPD score (BiC); bottom: SD score (SMS). One row per algorithm, the four features in each supervision mode as columns. Red: the score decreases as the feature grows (ρ<0\rho< 0); blue: it increases; grey: no monotonic dependence.

Performance on long series. On PAMAP2 (up to 447k samples per series; Appendix § 24), only 17 of the 26 algorithms process all 9 series within the time budget; ClaSP, CLaP and TGLAD finish 1-5 of them and six methods none, so main-pool accuracy does not always carry over to long series. For CPD, the penalised detectors scale and perform well: BinSeg, PELT and BottomUp reach tuned BiC 0.68-0.72 Non-Guided (0.71-0.73 Guided, with DynP), on par with IGTS (0.70) and above GGS (0.61 Non-Guided). For SD, Time2State and E2USD scale and remain competitive (tuned SMS 0.53-0.56).

SMS error-type breakdown. Decomposing the SMS penalty into its four error types (Figure 6c) reveals two distinct error profiles: the strongest methods (CLaP, Time2State G, TICC G) are dominated by Delay (50-70%): they recover the right states but misplace boundaries by a small margin, a benign error in many applications; Hidalgo is dominated by Isolation (> 90%): its intrinsic-dimension labels over-fragment our series with few channels, whereas the state-sequence HDP-HSMM and AutoPlait split their penalty between Delay (≈ 42-51%) and Missing (≈ 35-41%): they under-segment rather than fragment. Without KK, the window-clustering E2USD and Time2State are dominated by Isolation (46-48%), i.e. over-fragmentation, which supplying KK halves, mostly in favour of Delay. Practically, residual SD headroom lies in boundary refinement for the leaders and anti-fragmentation regularisation for the rest.

Answer to RQ3: For CPD, the fast penalised detectors (PELT, BinSeg, BottomUp; DynP when KK is known) are the safest choice and scale to long series; ClaSP is preferable on univariate series with few events. For SD, CLaP leads on simple series, Time2State and E2USD on complex multivariate and long ones. Tuning one window, penalty or threshold parameter captures most of the gain.

Conclusion and Limitations

We introduced TSB-SEG, the first large-scale benchmark jointly evaluating Change Point Detection (CPD) and State Detection (SD), covering 26 algorithms and 592 time series through the open-source tsseg library. Our results show that (i) no method consistently dominates, highlighting the need for dataset-specific tuning; (ii) BiC and SMS are strongly correlated, making CPD a useful proxy for SD; and (iii) data characteristics should guide method selection.

TSB-SEG also has limitations. It covers univariate and moderately multivariate series, leaving highly multivariate settings largely unexplored, and its parameter grids, however broad, cannot cover every plausible configuration. It treats change points and states as discrete events, whereas real transitions are often gradual and states can be mixed or hierarchical, which our soft metrics only partly account for. Finally, it focuses on offline segmentation and does not yet address online or streaming settings.

These limitations point to several directions for future work: extending the benchmark to highly multivariate and streaming data, adapting time-series foundation models to segmentation, and automating method selection from data characteristics, for instance by meta-learning.

Acknowledgments and Disclosure of Funding

The authors are grateful to the CLEPS infrastructure from Inria of Paris for providing resources and support. John Paparrizos was partially supported by the National Science Foundation under Award No. 2543459.

Reader’s Guide

The appendix is organised in four parts: Part I documents the design and protocol of the benchmark, Part II gives the additional results behind each research question, Part III explains how to extend TSB-SEG, and Part IV gathers the per-(algorithm, dataset) result tables. Table 4 maps each appendix to the part of the main text it supports.

App.ContentSupports
Part I - Benchmark design and protocol
BNotationsSection 2
CDatasets, provenance and uncertainty of the labels, licencesSection 4.2
DPer-method descriptionsSection 4.1
ERe-implementations and univariate/multivariate adaptationsSection 4
FFormal definitions of the metricsSection 4.4
GParameter grids and penaltiesSection 4.3
HCompute environment, budgets, missing seriesSection 5
IExtended-scope poolSection 4.1
Part II - Additional results
JCorrelation between metricsSection 4.4
KPer-domain and per-dataset spider plotsRQ1, RQ3
LPer-dataset score distributions, per-series oracle, ranking without tuningRQ1
MCPD vs. SD in each supervision modeRQ2
NRuntime distributionsRQ3
OHyperparameter influenceRQ3
PSensitivity to series featuresRQ3
QLong series (PAMAP2)RQ3
Part III - Extending the benchmark
RAdding algorithms and datasets-
Part IV - Result tables
SPer-(algorithm, dataset) scores of the main poolRQ1
TThe same tables under secondary metricsRQ1

Table 4. Reader’s guide to the appendix.

Notations

We summarise the main symbols and notations used in this paper in Table 5.

SymbolDefinition
TTTime series T∈Rn×dT \in\mathbb{R}^{n \times d}
nnTime series length
ddTime series number of dimensions
Ts,eT_{s,e}Subsequence (ts,…,te)(t_s,\ldots,t_e) of TT
ℓ\ellSubsequence / window length
CCSet of change points {CPi}\{CP_i\}
nCPn_{CP}Number of change points ∣C∣\lvert C\rvert
SSSegment sequence {[CPi,CPi+1)}0≤i≤nCP\{[CP_i,CP_{i+1})\}_{0\leq i\leq n_{CP}} (CP0,CPnCP+1(CP_0,CP_{n_{CP}+1}: ends of TT)
S\mathcal{S}Set of discrete states {s1,…,snS}\{s_1,\ldots,s_{n_S}\}
nSn_SNumber of unique states ∣S∣\lvert\mathcal{S}\rvert
QQState sequence (st1,…,stn)∈Sn(s_{t_1},\ldots,s_{t_n}) \in\mathcal{S}^n
KKNumber of events provided in Guided mode (nCP(n_{CP} or nS)n_S)

Table 5. List of symbols and notations used in this paper.

Datasets

TSB-SEG bundles 8 datasets used for the systematic evaluation, plus PAMAP2 [123] kept aside as a long-series scalability case study (see RQ3 and Appendix § 24). The 8 main datasets cover three domain families: Human Activity Recognition (ActRecTut [124], HAS [84], MoCap [125], USC-HAD [126]), industrial monitoring (SKAB [95], anomaly-style transitions on industrial machine signals; PUMP [127], 120 hydraulic-pump End-of-Line cycles measured by 9 sensors with up to 43 operational states per cycle), and general-purpose collections drawn from heterogeneous fields (TSSB [4], derived from the UEA/UCR classification archives [129]; UTSA [94], spanning sports, medicine and environmental monitoring). All datasets are annotated at the state level, enabling consistent CPD and SD evaluation.

Provenance and uncertainty of the labels. We use the state labels released by the original authors, without re-annotation: activity labels recorded with the protocol or annotated by hand for ActRecTut, HAS, MoCap and PAMAP2, operating states of the test program for PUMP, normal and anomalous phases for SKAB, the class of each concatenated segment for TSSB and USC-HAD (one recording per activity), and the regime labels of the original sources for UTSA. Boundaries of concatenated series are exact; hand-placed boundaries are uncertain by a few samples to seconds, and transitions between activities are gradual, so the state of the samples around a boundary is partly a matter of convention. Three choices limit the influence of this uncertainty on our conclusions: the margin of the F1F_1-score (1% of the series length), the Gaussian kernel of the Gaussian F1F_1, and the Delay class of SMS, which charges small boundary shifts less than structural errors; and every ranking is reported under several metrics (Appendix § 27). Dataset licence terms are reported in Table 6.

DatasetLicence / Usage Terms
PAMAP2 [123]CC BY 4.0
USC-HAD [126]Licence not explicit; presented as freely available in the original paper
TSSB [4]BSD 3-Clause License
UTSA [94]No explicit licence at the source; redistributed under BSD 3-Clause in the CLaP repository
ActRecTut [124]GPL-3.0-or-later
MoCap [125]Free for research; commercial use allowed in products, but resale (even converted) is prohibited
HAS [84]CC BY-NC-SA 4.0
SKAB [95]GPL-3.0
PUMP [127]CC BY 4.0

Table 6. Licences of datasets used in our experiments.

Per-method Descriptions

We describe here every method of Figure 2, column by column, that is, by search procedure. In each column we first describe the algorithms evaluated in TSB-SEG, then cite the representative methods we do not evaluate. The two axes extend the decomposition of CPD methods into a cost function and a search method [88]; we leave out its third element, the constraint on the number of changes, which our Guided and Non-Guided modes cover (§ 4.3). Our implementation choices are gathered in Appendix § 12.

Homogeneity criterion (rows). The cost of [88] is a measure of the homogeneity of a segment; the rows classify the methods by what must stay the same within a segment or a state. A model of the observations is compared through its fit or likelihood, or through fixed statistics (mean, median, covariance, regression or autoregressive coefficients, trend, subspace, Gaussian process, local dimension). A model-free distribution comparison contrasts empirical distributions without a model (characteristic kernel, energy distance, Wasserstein distance, density ratio, classifier, graph). Subsequence shapes are compared to their nearest neighbours (matrix-profile arcs, kk-nearest-neighbour classifiers), by a convolutional-kernel classifier (ROCKET [130] in the paper) or through symbolic patterns. Learned representations embed windows (time steps in SNLDS) with a trained network. The penalised detectors (Window, BinSeg, BottomUp, PELT, DynP) take their segment cost as a parameter: the ℓ1\ell_1, ℓ2\ell_2 and cosine costs (the cosine cost is the ℓ2\ell_2 cost on normalised vectors, i.e. the linear kernel) compare a model, whereas the RBF kernel, which is characteristic, maps the signal to a Hilbert space where any change of distribution becomes a mean shift; these detectors therefore span the first two rows.

CPD - Profile and peaks. These methods score every time point, usually by comparing two adjacent windows or arcs over the whole series, and report the peaks of the score. The score is computed once over the whole series, whereas binary segmentation recomputes its gain in each part: ClaSP, whose classification score profile is such a gain, therefore belongs to binary segmentation. Window [88] (popularised in the 1990s) slides two adjacent windows along the series and detects the peaks of their discrepancy. ChangeFinder [105] reduces CPD to outlier detection through two stacked sequentially discounting autoregressive (SDAR) models. iCID [100] represents each window by its kernel mean embedding under the Isolation Distributional Kernel and scores one minus the normalised kernel similarity between adjacent windows, choosing the isolation parameter that minimises the approximate entropy of the scores; it detects change intervals, which generalises CPD to changes spread over time. FLUSS [94] uses motif-arc proximity to build the arc curve, whose local minima reveal CPs of homogeneous regions; ESPRESSO [106] extends FLUSS’s arc curve with time-series chains [131] and an entropy-based segmentation. With the deep-learning shift, self-supervised representations became prominent: TS-CP2 [108] learns embeddings via Contrastive Predictive Coding to distinguish time-adjacent from time-distant pairs, and TIRE [107] learns an autoencoder Time-Invariant Representation to detect changes in time and frequency domains. tGLAD [109] recovers temporal conditional independence graphs across sliding windows via a multi-task uGLAD solver, and segments the sequence by tracking the first- and second-order trajectories of these graphs (precision matrices, hence the model row). Not evaluated: MOSUM [132], a moving-sum statistic; subspace ID [133], a change score obtained by subspace identification of a state-space model; RuLSIF [134, 135], which estimates a relative density ratio between adjacent windows; and KL-CPD [136], a kernel two-sample test with a learned deep kernel. Previous studies found aHSIC [137], RuLSIF and KL-CPD to be dominated by methods included in our benchmark [108, 100].

CPD - Bottom-up. These methods start from a fine partition and merge the most similar adjacent segments. BottomUp [110] starts with a fine grid and iteratively merges segments. EAgglo [111] merges adjacent segments agglomeratively, preserving time order, and keeps the segmentation that maximises a goodness-of-fit statistic built on the energy distance between segments. Not evaluated: TGUH [138], which merges several pairs of neighbouring regions per pass through an unbalanced Haar decomposition, and MDL greedy [139], a greedy minimum-description-length method that fits autoregressive models on windows, groups similar windows into subsequences and greedily removes the subsequences whose removal shortens the description.

CPD - Top-down (binary segmentation). These methods search one change point per interval, split where the gain is largest and recurse on the two parts; the intervals are whole segments or random or deterministic sub-intervals. BinSeg [112] extends AMOC to multiple CPs by applying the single-CP search recursively to the resulting sub-signals. GGS [113] models each segment as a multivariate Gaussian with a regularised covariance and maximises the total log-likelihood greedily, adding one breakpoint at a time and readjusting the previous ones after each addition. IGTS [114] segments multivariate series top-down, splitting at the points that maximise the Information Gain (entropy reduction between segments). ClaSP [4] casts CPD as a collection of self-supervised subsequence-classification problems, reports the split maximising cross-validation accuracy, and recurses on the two parts. Not evaluated: wild binary segmentation (WBS) [140], seeded binary segmentation (Seeded BS) [141], narrowest-over-threshold (NOT) [142] and Inspect [143], with its sparse projections, which search sub-intervals for changes in mean or slope; changeforest [144], whose gain is a classifier log-likelihood ratio; gSeg [145], a graph-based scan applied recursively for multiple changes; and E-Divisive [111], the divisive counterpart of EAgglo: with a fixed number of changes, it is binary segmentation with an energy-distance cost, i.e. a kernel cost [146], a family we evaluate with the RBF kernel; without it, its permutation test costs O(dn2+RnCPn2)O(d n^{2} + R n_{\mathrm{CP}} n^{2}), beyond our budget on the long series.

CPD - Convex relaxation. These methods fit a piecewise model with an ℓ1\ell_{1} penalty on its jumps, so that most jumps are exactly zero. Prophet [115] models trend changes with a sparse prior on rate changes at potential grid locations. Not evaluated: TV Lasso [147], the Lasso on the jumps of a piecewise-constant signal, i.e. a total-variation penalty; fast group LARS [148], its multivariate extension for change points shared by many signals; and ℓ1\ell_{1} trend filtering [149], whose changes of slope are change points.

CPD - Optimal (dynamic programming). These methods compute the exact minimum of a sum of segment costs, penalised or with a fixed number of changes. The foundation lies in AMOC [116] (At Most One Change point), which searches for a single breakpoint by minimising the sum of squared errors. PELT [117] prunes the exact dynamic-programming search down to a linear expected cost; DynP [88] solves the optimal segmentation when the number of CPs is known. Both minimise a sum of segment costs; kernel change-point detection (KCPD), often listed as a method of its own, runs these same two solvers with a kernel cost. Not evaluated: FPOP and SNIP [150], which speed up the penalised and fixed-KK recursions with functional and inequality pruning, and SMUCE [151], which minimises the number of changes subject to a multiscale test, also by dynamic programming.

CPD - Bayesian. These methods compute or sample the posterior over segmentations. BOCD [118] introduces a Bayesian recursive message-passing scheme to infer the most recent CP, later extended for gradual changes [152]; its exact offline counterpart [153] returns the posterior probability of a change at every time step. Not evaluated: BEAST [154], which averages piecewise trend and seasonal models by Markov chain Monte Carlo, performed very poorly in early experiments and was therefore discarded; BOCPDMS [155], BOCD with model selection among vector autoregressions, and GP-BOCPD [156], BOCD with Gaussian-process regimes; the product partition model (PPM) [157], sampled by Markov chain Monte Carlo as in the bcp package; and the change-point HMM [158] and DPHMM [159], left-to-right hidden Markov models whose state either stays or moves to the next regime, so that each state is one segment.

One dynamic programme. Because the score of a segmentation is a sum of segment costs, or the log of a product of segment likelihoods, the optimal, Bayesian and state-sequence searches run the same recursion over the position of the last change point: taking its minimum gives the best segmentation (PELT, DynP), taking its sum gives the posterior (BOCD); a left-to-right hidden Markov model is a product partition model, and allowing a return to a previous state turns it into the state-sequence search, with Viterbi for the minimum and forward–backward for the sum. The headers of Figure 2 draw this recursion: the nodes are candidate change points and the arcs segments, so that a segmentation is a path; the optimal search keeps the cheapest path, the Bayesian one weighs every path (arc width: posterior probability of the segment; dot size: posterior probability of a change), and the state-sequence search follows a path through the states over time. With a geometric prior on segment lengths (a change at each step with probability pp), a segmentation with mm changes has prior probability pm(1−p)n−1−m∝e−βmp^m(1-p)^{n-1-m} \propto e^{-\beta m}, with β=log⁡((1−p)/p)\beta= \log((1-p)/p); the negative logarithm of the maximum a posteriori recursion of [160] is then the optimal-partitioning recursion that PELT accelerates, with the negative log marginal likelihood of a segment as cost and β\beta as penalty.

SD - State sequence (dynamic programming). These methods give a state to each step, window or block, tied to the next by a transition probability or a switching cost, and infer the whole sequence jointly. AutoPlait [119] groups HMM states into a Multi-Level Chain Model and uses Minimum Description Length (MDL) to choose both the segmentation and the number of regimes. HDP-HSMM [161, 120] extends Hidden Semi-Markov Models with a Hierarchical Dirichlet Process prior, allowing nonparametric estimation of the number of states, with Gaussian emissions and explicit (shifted Poisson) state durations. TICC [121] clusters sliding-window subsequences, each cluster being a Gaussian Markov random field with a Toeplitz-structured sparse inverse covariance, alternating the estimation of these covariances with a temporally consistent assignment of the windows (switching penalty β\beta), computed by a Viterbi-type dynamic programme. Not evaluated: the Gaussian HMM [162]; the sticky HDP-HMM [163]; BP-AR-HMM [164], a beta-process autoregressive HMM that shares behaviours across several series; rSLDS [165], recurrent switching linear dynamical systems; and SNLDDS [166], switching nonlinear dynamical systems with neural transition and emission functions, the latter in the learned-representation row.

SD - Segment, then group. These methods first segment the series with a CPD method, then group the segments into states. CLaP [93] starts from the segments found by ClaSP and shifts focus from feature space to label space: it exploits the self-supervised classification gain [167] to merge confusable segment classes, thereby clustering segments directly in label space. Not evaluated: ClaSP2Feat, the baseline of [93], which clusters the ClaSP segments with the features of Time2Feat [168]; CLaP dominates it in [93], which is why we did not keep it. Also not evaluated: optimal transport [169] (unnamed by its authors), which places change points at the peaks of a Wasserstein two-sample statistic between adjacent windows, averaged over channels, then groups the segments by spectral clustering of their pairwise Wasserstein distances, the number of states being given; a recent preprint [170] follows the same pipeline and infers the number of states.

SD - Window clustering. These methods label each window or point by a clustering, independently of its neighbours in time; time order is ignored or only enters the features, e.g. through contrastive pairs of adjacent windows, or a smoothing of the labels. Hidalgo [122] clusters multivariate points by their local intrinsic dimension; its prior links nearest neighbours in the observation space, not consecutive time steps. Time2State [90] trains a contrastive-learning encoder on sliding windows, with sub-windows of the same window as positive pairs, and clusters the embeddings with a Dirichlet-process Gaussian mixture (DPGMM), which infers the number of states; E2USD [91] optimises this pipeline with FFT-based compression, a Decomposed Dual-view Embedding Module, and False-Negative-Cancellation contrastive learning. Not evaluated: WK-means [171], a Wasserstein kk-means that clusters the empirical distributions of windows of a return series; ordinal patterns [172], which clusters windows by their distribution of ordinal patterns; and PaTSS [173], which embeds each time step with the frequent sequential patterns mined from multi-resolution symbolic windows and showed weak performance in previous work [97].

Empty cells. Some cells of Figure 2 are empty in the published literature that we reviewed. Nearest-neighbour shape comparisons involve pairs of subsequences from the whole series and do not decompose into a sum of segment costs, a likelihood or a penalised parameter, which the optimal, Bayesian and convex searches need; such methods could be built (e.g. with a self-similarity segment cost), but we found none. Likewise, convex and Bayesian searches need parameters or a likelihood, so model-free distributions only enter them through nonparametric priors. We found no published unsupervised method combining learned representations with bottom-up, binary, convex, optimal or Bayesian searches, nor one grouping CPD segments by learned representations. For a broader and continuously updated overview of segmentation methods and benchmarks, including recent ones not evaluated here, we refer the reader to the community reading list of [174].

Adaptation and Implementation Details

Integrating 26 heterogeneous methods under a unified API required several reimplementations and adaptations. As mentioned in § 4, 13 of the 26 methods are absent from public toolkits (aeon [102], sktime [103], ruptures [88], and the R package changepoint [104]) and were implemented or adapted in this work, including ports of methods originally available only in MATLAB (ESPRESSO, iCID), a wrapper around the original C code of AutoPlait, extensions of univariate methods to multivariate inputs (FLUSS, Prophet, ChangeFinder, BOCD) and of IGTS to univariate inputs. For these methods, the results we obtain are consistent with the relative performance reported in the original papers and in the literature, although their datasets and protocols differ from those of our benchmark. Hidalgo is inherently incompatible with univariate inputs and is restricted to its intended multivariate setting. ESPRESSO, although described as essentially parameter-free, and TICC require the number of segments or states in the available implementations; like DynP, they are therefore evaluated in Guided mode only. AutoPlait chooses the number of regimes by MDL and takes no such input: like PELT and AMOC, it scores the same in both modes.

Implementation choices. The penalised detectors (Window, BinSeg, BottomUp, PELT, DynP) take their segment cost as a parameter; we run them with the ℓ1\ell_1, ℓ2\ell_2, cosine and RBF costs (Appendix § 14), and report kernel change-point detection (KCPD) under PELT and DynP, which it runs with a kernel cost. For BOCD, we use the exact offline inference of the product-partition model [153], which returns the posterior probability of a change at every time step. iCID detects change intervals; we evaluate the change points it returns. Without KK, the detectors that rank candidate change points stop at a threshold, one of their grid axes: ChangeFinder keeps the peaks of its score above its mean plus kk standard deviations, at least 1% of nn apart; FLUSS keeps the minima of its corrected arc curve below a threshold, as its online variant FLOSS does [94]; TIRE keeps the peaks of its dissimilarity above a prominence threshold; Prophet fits a rate change δ\delta at 200 evenly spaced candidates and keeps those whose ∣δ∣|\delta| exceeds a multiple of the median ∣δ∣|\delta|. With KK, each keeps its KK strongest candidates (ChangeFinder among the peaks above k=2k = 2). For HDP-HSMM, we use the weak-limit Gibbs sampler of [120], with the prior mean duration set to a third of the series length. HDP-HSMM and Prophet are fitted, on series longer than 2,000 samples, on the means of blocks of ⌈n/2000⌉\lceil n/2000 \rceil consecutive samples, and their labels or candidate change points are expanded back, so that boundaries fall on block edges: on a set of compared series the loss was negligible, whereas sampling HDP-HSMM at full length is intractable (without truncation of the durations, one sweep costs O(n2)O(n^2) per state).

Univariate and Multivariate Adaptations

FLUSS, Prophet, ChangeFinder and BOCD. These univariate methods rely on two adaptations illustrated in Figure 7: (i) L2 Norm Reduction transforms the multivariate signal into a univariate L2-norm series, preserving joint-magnitude changes; (ii) Ensemble Aggregation runs the detector independently per channel, pools all detected change points, clusters them by temporal proximity using a tolerance window, and returns the median timestamp of each cluster: with KK, of the KK clusters supported by the most channels; without KK, of every cluster, since a majority vote loses the changes that show on few channels. Prophet instead averages its candidate scores over the channels. Both adaptations are part of the grid for FLUSS, Prophet and ChangeFinder; BOCD uses the L2 reduction.

Figure 7. Multivariate adaptations for univariate methods (FLUSS, Prophet, ChangeFinder, BOCD): L2 Norm Reduction collapses the multivariate signal into a univariate L2 norm series; Ensemble Aggregation runs the detector independently per channel and merges the nearby change points of the channels (the KK best-supported ones when KK is given; shown with K=3K = 3).

IGTS. The original IGTS paper [114] prescribes a normalise-and-complement preprocessing step (§ 4.4, Eq. 12-13) for all inputs: each channel cic_i is normalised to sum to one and its complement max⁡(ci)−ci\max(c_i)-c_i is appended, doubling the channel count from dd to 2d2d. This transformation ensures that Shannon entropy varies across segments even on univariate signals and on multivariate signals with positively-correlated channels, where it would otherwise be constant and mask change points. The aeon [102] implementation only applies the augmentation to univariate inputs; we apply it unconditionally, which restores the behaviour described in the paper on multivariate data and makes IGTS applicable to univariate series. We additionally implement the cumulative-sum optimisation (Eq. 5-6), which precomputes Fi(t)=∑j≤tcijF_i(t)=\sum_{j\leq t}c_{ij} once and replaces each segment-sum recomputation by a single subtraction. This reduces each information-gain evaluation from O(d⋅n)O(d\cdot n) to O(k⋅d)O(k\cdot d), kk being the number of segments.

Hidalgo. Hidalgo [122] segments multivariate data into regions of differing local intrinsic dimension (ID) and does not natively support univariate inputs (the intrinsic dimension of a scalar series is 1 everywhere). We attempted a univariate adaptation via Takens time-delay embedding,

Xt=(xt,xt+τ,…,xt+(m−1)τ),X_t=(x_t,x_{t+\tau},\ldots,x_{t+(m-1)\tau}),

so that different dynamical regimes (periodic, chaotic, noise) could occupy manifolds of different dimension in Rm\mathbb{R}^m. We swept m∈{3,5,10}m\in\{3,5,10\}, τ∈{1,2}\tau\in\{1,2\} and the number of Gibbs iterations niter∈{300,500,1000}n_{\mathrm{iter}}\in\{300,500,1000\} on TSSB and UTSA, with q=3q=3 and ζ=0.8\zeta=0.8 as recommended by the original paper. The mean ARI over TSSB was ≈0.01\approx0.01 (essentially random), and the only configuration that recovered a non-trivial ARI (≈0.57\approx0.57) was a synthetic sine-vs-white-noise signal with a genuine change in intrinsic dimension. Per-segment ID estimates obtained with the TWO-NN estimator confirm the diagnosis: on TSSB the median ID gap between consecutive ground-truth segments is 1.19 (only 23% of series with a gap >2>2), and on UTSA it drops to 0.72. Hidalgo’s Gibbs sampler does not discriminate ID gaps of this magnitude, and the Potts smoothing term cannot create a discriminative signal where none exists. We therefore restrict Hidalgo to its intended multivariate use case.

Evaluation Metrics: Formal Definitions

Change Point Detection (CPD) Metrics

F1F_1-score. The standard margin-based evaluation metric for change point detection. A predicted change point is considered a true positive if it falls within a fixed tolerance window of a ground-truth change point. While widely used, its binary nature means it provides no partial credit for predictions that are just outside the margin, making it highly discontinuous.

Gaussian F1F_1. To address the discontinuity of the standard F1F_1-score and its sensitivity to the arbitrary tolerance hyperparameter, we introduce a soft alternative. Let C={CPi}1≤i≤nCP\mathcal{C}=\{CP_i\}_{1\leq i\leq n_{CP}} be the set of true CPs and C^={CP^j}\hat{C} = \{\widehat{CP}_{j}\} the set of predicted CPs. We define a Gaussian reward for each CPiCP_i:

Gi(CP^)=exp⁡(−(CP^−CPi)22σ2)G_i(\widehat{CP}) = \exp\left(-\frac{(\widehat{CP}-CP_i)^2}{2\sigma^2}\right)

with σ\sigma a fraction of the time-series length nn (default σ=0.01 n\sigma= 0.01\,n). A greedy bipartite matching M\mathcal{M} between CC and C^\hat{C} maximises the total reward:

W=∑(CPi,CP^j)∈MGi(CP^j)W = \sum_{(CP_i,\widehat{CP}_j)\in\mathcal{M}} G_i(\widehat{CP}_j)

The soft precision and recall are W/∣C^∣W/|\hat{C}| and W/∣C∣W/|C|; the Gaussian F1F_1 is their harmonic mean. This provides smooth partial credit instead of binary accept/reject decisions.

Covering Score. A classical (unidirectional) segment-based metric. Given source and target segment sets SsrcS_{src} and StgtS_{tgt}, the directional Covering score measures how well each source segment is covered by the target:

Covering⁡(Ssrc→Stgt)=∑s∈Ssrc∣s∣max⁡t∈StgtIoU⁡(s,t)∑s∈Ssrc∣s∣\operatorname{Covering}(S_{src} \to S_{tgt}) = \frac{\sum_{s\in S_{src}} |s| \max_{t\in S_{tgt}} \operatorname{IoU}(s,t)}{\sum_{s\in S_{src}} |s|}

By default, Covering is computed only as Covering⁡(SGT→Spred)\operatorname{Covering}(S_{GT} \to S_{pred}). This uni-directional formulation is problematic because it is largely insensitive to over-segmentation: a prediction set containing many spuriously fragmented segments can still correctly cover the ground-truth segments.

Bidirectional Covering (BiC). To penalise methods that over-segment the true regions, we extend the classical Covering metric symmetrically. While classical Covering only assesses Covering⁡(SGT→Spred)\operatorname{Covering}(S_{GT} \to S_{pred}), we additionally compute the prediction coverage Covering⁡(Spred→SGT)\operatorname{Covering}(S_{pred} \to S_{GT}) to measure how well predicted regions map back to the truth.

BiC is the harmonic mean of both directions. It matches the classical metric when predictions are perfectly aligned, but penalises over-segmentation: each fragment has a low IoU with the larger ground-truth segment it lies in, which drags the Covering⁡(Spred→SGT)\operatorname{Covering}(S_{pred} \to S_{GT}) component down.

State Detection (SD) Metrics

Adjusted Rand Index (ARI). A standard point-based clustering metric evaluating the similarity between ground-truth and predicted state assignments. It relies on the Rand Index (RI), which computes the fraction of agreeing pairs via a contingency matrix C=[nij]C = [n_{ij}], where nijn_{ij} counts the timestamps assigned to true state ii and predicted state jj. ARI adjusts this for chance:

ARI⁡=RI⁡−E[RI⁡]1−E[RI⁡]\operatorname{ARI} = \frac{\operatorname{RI} - \mathbb{E}[\operatorname{RI}]}{1 - \mathbb{E}[\operatorname{RI}]}

While widely used, standard ARI (and similar metrics like AMI) treats each time step as an independent data point, systematically ignoring the inherent temporal ordering and structure of time series segmentation errors.

Weighted Adjusted Rand Index (WARI) [97]. Introduced to address the structural blindness of point-based metrics, WARI is a temporal-aware extension of the ARI. It assigns a distance-to-boundary weight wi=1+αdiw_i = 1 + \alpha d_i to each timestamp ii, where did_i is the distance to the nearest true change point and α\alpha controls the penalty slope (default α=0.1\alpha= 0.1). The contingency counts nijn_{ij} are replaced by weighted sums n~ij=∑kwk\tilde{n}_{ij} = \sum_k w_k. This gives more importance to errors that structurally disrupt a segment (e.g., splitting a state into two) and naturally downweights slight boundary misplacements.

State Matching Score (SMS) [97]. SMS is an interpretable measure dedicated to SD. SMS first uses Hungarian matching to optimally align predicted and true discrete states. It then identifies error blocks and assigns a specific penalty to each based on its context (length, distance to boundaries, type of error). It decomposes errors into four structurally distinct types: Delay (slight boundary misalignment), Transition (brief transitional states between true regions), Isolation (over-fragmentation of segments), and Missing (completely undetected regions). The final SMS is calculated on a weighted sum of these penalties. We use the default weights of [97]: wdelay=0.1w_{\mathrm{delay}} = 0.1, wtransition=0.3w_{\mathrm{transition}} = 0.3, wisolation=0.8w_{\mathrm{isolation}} = 0.8 and wmissing=0.5w_{\mathrm{missing}} = 0.5.

A synthetic illustration of the evaluation metrics used in TSB-SEG is provided in Figure 8.

Figure 8. Evaluation measures in TSB-SEG.

Parameter Grids

Parameter Grids Setup. For each algorithm we identified the 2-4 hyperparameters that drive its behaviour, defined a small grid of 2-4 plausible values per parameter, drawn from the recommendations of the original papers and from values commonly used in the literature, and took the Cartesian product as the search space. Every grid was then calibrated on pilot series, in the same way for all algorithms, so that no method benefits from a more careful calibration than another. AutoPlait is essentially parameter-free and is evaluated in a single configuration, and the costliest extended-scope methods (BOCD, EAgglo, TS-CP2) in their default configuration only. The penalised detectors (PELT, BinSeg, BottomUp, Window) take their penalty as a multiple XX of the BIC penalty ulog⁡nu\log n, uu being the cost of one sample of the whole series (dd for the ℓ2\ell_2 cost on standardised channels), so that one value transfers across lengths, dimensions and costs: X∈{1,2,8,32}X \in\{1, 2, 8, 32\} ({1/16,1/4,1,4}\{1/16, 1/4, 1, 4\} for Window), with the ℓ1\ell_1, ℓ2\ell_2, RBF and cosine costs, a minimum segment length of 2 and a candidate step of 5; in Guided mode nCPn_{CP} replaces the penalty. As their penalty has no scale-free default in the original papers, their Default mode uses the ℓ2\ell_2 cost with X=8X = 8 (X=1/4X = 1/4 for Window), chosen on a pilot of 27 benchmark series. The Default configuration θ0\theta_0 need not be a grid configuration: when it is one (e.g. for the penalised detectors, Prophet, IGTS and HDP-HSMM), the Default score is that of its grid cell; otherwise θ0\theta_0 is run on its own, and its score can then exceed the tuned one (in 5 of the 384 (algorithm, dataset, mode) cells of Appendix S, by at most 0.02). Table 7 gives, for every method, the swept parameters, their value in Default mode and the values evaluated in each mode, as read from the logged runs; in Guided mode, the parameter that sets the number of change points, segments or states receives the ground-truth KK of each series and replaces the Non-Guided stopping rule (a penalty, a threshold or a maximum number of events). ChangeFinder, FLUSS, TIRE and Prophet have no scale-free rule to stop without KK in their original implementations (a hard-coded threshold, a fixed number of regimes, or none): their threshold (Appendix E) was calibrated in the same way, on pilots of 23-24 benchmark series, and its grid of 3-4 values brackets the calibrated default. As the pilot series are drawn from the benchmark, the calibrated Default configurations and the grids are slightly optimistic, for every method alike, as are the tuned scores. Descriptions of every parameter are released with the configuration files of the TSB-SEG repository2; we made a best effort to keep the grids fair and representative of standard usage, while acknowledging that exhaustive coverage of every plausible combination is out of reach.

Method#cfgParameterDefaultNon-Guided valuesGuided values
CPD, distribution-based
AMOC3/3min_size5{5, 15, 30}same
BinSeg16/4modelℓ2\ell_2{ℓ1\ell_1, ℓ2\ell_2, RBF, cosine}same
BinSegpenalty8{1, 2, 8, 32}-
BinSegn_cps--nCPn_{CP}
BottomUp16/4modelℓ2\ell_2{ℓ1\ell_1, ℓ2\ell_2, RBF, cosine}same
BottomUppenalty8{1, 2, 8, 32}-
BottomUpn_cps--nCPn_{CP}
Window48/12modelℓ2\ell_2{ℓ1\ell_1, ℓ2\ell_2, RBF, cosine}same
Windowpen0.25{0.0625, 0.25, 1, 4}-
Windowwidth100{50, 100, 200}same
Windown_cps--nCPn_{CP}

Table 7.

Table 7: Hyperparameter grids, as evaluated. For each method, the parameters swept in Parameter-search mode, their value in Default mode and the values tried in each mode; #cfg is the number of configurations per dataset (Non-Guided/Guided). In Guided mode the parameter marked with nCPn_{CP}, nCP+1n_{CP}+1 (number of segments) or nSn_S receives the ground-truth number of events of each series, and “-” marks a Non-Guided stopping rule that it replaces; “same”: the Non-Guided values. The penalties of PELT, BinSeg, BottomUp and Window are multiples XX of the BIC penalty ulog⁡nu\log n (Appendix G). Time2State and E2USD skip the window 64/step 100 combinations (step larger than the window). PELT, AMOC, ICID, EAgglo and tGLAD all take no KK: their Guided grid is their Non-Guided one (PELT and AMOC are not rerun). ClaSP distances: euclidean, z-normalised euclidean and complexity-invariant (CID) euclidean; window-size selection: SuSS, FFT or ACF; L2 norm and ensembling: the multivariate adaptations of Appendix E. tGLAD’s default runs used 100 epochs, 2000 on ActRectTut, MoCap and SKAB. #cfg “-”: default configuration only (BOCD, EAgglo, TS-CP2: main parameters shown); n/a: mode not evaluated.

(continued from previous page)

Method#cfgParameterDefaultNon-Guided valuesGuided values
ChangeFinder54/54discount0.005{0.005, 0.01, 0.05}same
multivariate_strategyL2 norm{L2 norm, ensembling}same
order55{3, 5, 10}
smooth_window7{5, 7, 15}same
threshold_factor4{3, 4, 5}2
n_cps--nCPn_{CP}
PELT16/16modelℓ2\ell_2{ℓ1\ell_1, ℓ2\ell_2, RBF, cosine}same
penalty8{1, 2, 8, 32}same
DynP-/4modelℓ2\ell_2n/an/a{ℓ1\ell_1, ℓ2\ell_2, RBF, cosine}
n_cps-n/an/anCPn_{CP}
Prophet16/4changepoint_prior_scale500{50, 500}same
delta_threshold3{1.5, 2.5, 3, 4}-
multivariate_strategyL2 norm{L2 norm, ensembling}same
n_changepoints--nCPn_{CP}
iCID27/27alpha0.5{0.1, 0.5, 0.9}same
t200{100, 200, 300}same
window_size50{30, 50, 100}same
GGS9/3k_max10{5, 10, 20}nCPn_{CP}
lamb1{0.1, 1, 10}same
CPD, subsequence-based
IGTS9/3k_max10{5, 10, 25}nCPn_{CP}
step5{1, 5, 10}same
FLUSS54/18exclusion_factor5{3, 5, 10}same
multivariate_strategyensembling{L2 norm, ensembling}same
threshold0.65{0.5, 0.65, 0.8}-
window_size10{10, 25, 50}same
n_segments--nCP+1n_{CP}+1
ESPRESSO-/9chain_len3n/an/a{1, 3, 5}
window_size64n/an/a{32, 64, 128}
n_segments-n/an/anCP+1n_{CP}+1
TIRE108/27domainboth{FD, TD, both}same
max_epochs20{20, 50, 100}same
prominence_threshold0.5{0.05, 0.2, 0.5, 0.7}-
window_size20{10, 20, 50}same
n_segments--nCP+1n_{CP}+1
ClaSP6/6distancez-norm.{euclidean, z-norm., CID}same
window_sizeSuSS{SuSS, FFT}same
n_segmentslearnlearnnCP+1n_{CP}+1
SD
AutoPlait1/1n_cps--nCPn_{CP}
HDP-HSMM27/9alpha6{1, 3, 6}same
dur_alpha10{2, 10, 20}same
n_max_states20{10, 20, 40}nSn_S
TICC-/27beta3000n/an/a{100, 1000, 5000}
lambda_parameter0.001n/an/a{0.0001, 0.001, 0.01}
window_size3n/an/a{3, 5, 10}
n_states-n/an/anSn_S
Time2State24/24depth10{1, 5, 10}same
step50{20, 50, 100}same
window_size256{64, 128, 256}same
n_states2020nSn_S
E2USD24/24depth1{1, 5, 10}same
step50{20, 50, 100}same
window_size256{64, 128, 256}same
n_states2020nSn_S

Table 20.

(continued on next page)

Method#cfgParameterDefaultNon-Guided valuesGuided values
CLaP6/6classifierROCKET{ROCKET, MR-Hydra}same
window_sizeSuSS{SuSS, FFT, ACF}same
n_change_points--nCPn_{CP}
Extended-scope pool
BOCD-/-hazard_lambda300300same
cp_prob_threshold0.050.05same
min_distance2525same
max_cps--nCPn_{CP}
EAgglo-/-alpha11same
penaltynonenonesame
TS-CP²-/-window_size128128same
code_size3232same
epochs100100same
temperature0.10.1same
n_cps--nCPn_{CP}
tGLAD18/18epochs100/2000{100, 500}same
threshold0.5{0.1, 0.3, 0.5}same
window_size32{32, 64, 128}same
Hidalgo-/6q3n/a{2, 3, 5}
zeta0.8n/a{0.5, 0.8}
K_states-n/anSn_S

Table 21.

Experimental Details and Compute Environment

The evaluation behind the three research questions relies on the two modes of Section 4.3: the Default configuration and a grid search over a fixed, predefined set of parameter values per method. We selected parameters as carefully as possible, but acknowledge that some may have been missed or under-tuned; we prioritised fairness and consistency while keeping the search space manageable. Each method from the main pool is evaluated across all series from the 9 datasets (8 main + PAMAP2) in these two modes, with the results from PAMAP2 used for scalability analysis only. Across the 8 main datasets, methods that complete most of a dataset but miss a few series (e.g. timeouts) are kept in the main figures and in every mean or rank over the 592 series, with their missing (dataset, trial) entries imputed as a score of 0 on every reported metric (tuned, median, worst-case and default); the per-(algorithm, dataset) tables of Appendices S and T instead average the completed series only. This is consistent with how a practitioner would summarise such a run: a method that fails to return on a series within the allotted budget effectively scores zero on that series. Padding is applied uniformly across modes (Non-Guided / Guided, CPD / SD) so that every algorithm is averaged over the same 592 series. Two methods are padded, both in Guided mode: ESPRESSO (20.8% of the series, on PUMP and USC-HAD) and TICC (13.5%, on PUMP only). All experiments were executed on a high-performance computing cluster comprising Cascade Lake nodes with dual Intel Xeon 5218 CPUs (2×16 cores at 2.4 GHz, hyper-threading enabled) and 192 GB RAM. Each run of one configuration on one dataset was allocated 8 CPU cores, 32 GB RAM and at most 24 hours. Each configuration runs once per series, with a fixed seed for the methods whose configuration sets one (e.g. TIRE, Time2State, E2USD); we do not estimate the variance over seeds, which the averaging over the series of a dataset partly absorbs. All means and ranks weight every series equally, so HAS (250 of the 592 series) weighs most; per-dataset results are in Appendices K and S.

Extended-Scope Pool

The extended-scope pool gathers 5 methods that legitimately cannot be evaluated under the same budget as the main pool: BOCD and EAgglo have at least quadratic runtime and quadratic memory (both build n×nn \times n matrices that exceed memory beyond n≈20,000n \approx20{,}000, and our exact BOCD inference is cubic in time); TS-CP² and tGLAD are linear-time at inference but their training exceeds the 24 h budget on parts of HAS, PUMP, USC-HAD and, for TS-CP², TSSB and UTSA; Hidalgo is multivariate-only by design.

Tables 8-9 summarise their per-dataset behaviour on the (algorithm, dataset, mode) cells they actually populate: completion, Default and Tuned scores and runtime (columns defined in the captions).

Because Hidalgo is multivariate-only by design but produces both a CPD and an SD output, it appears in both Table 8 (with BiC) and Table 9 (with SMS).

Table 8. Per-dataset coverage and score of the five extended-scope algorithms with a CPD output. Compl. = completed series / dataset cardinality. Default columns report the mean Bidirectional Covering (BiC) under the author-recommended configuration; Tuned columns report the mean BiC of the configuration maximising the dataset-level mean over the parameter sweep. t~\tilde{t} is the median wall-clock per finished trial (in seconds). NG = Non-Guided, G = Guided. “-” = (mode, dataset) pair not evaluated.

AlgorithmDatasetSeriesDefault, NG Compl.Default, NG BiCDefault, NG t~\tilde{t} [s]Default, G Compl.Default, G BiCDefault, G t~\tilde{t} [s]Tuned, NG Compl.Tuned, NG BiCTuned, NG t~\tilde{t} [s]Tuned, G Compl.Tuned, G BiCTuned, G t~\tilde{t} [s]
tGLADactrectut22/20.04367062/20.04339862/20.4998852/20.469736
tGLADhas250206/2500.46288171/2500.4534340/2500.53146243/2500.531377
tGLADmocap99/90.0573049/90.0652569/90.4618419/90.491795
tGLADpump12057/1200.07136755/1200.06157513/1200.52682012/1200.516800
tGLADskab3434/340.10132634/340.10130134/340.5730934/340.60329
tGLADtssb7575/750.2719175/750.2824075/750.3318.775/750.3416.5
tGLADusc-had7044/700.13179642/700.1318919/700.48102417/700.5012580
tGLADutsa3232/320.1658532/320.1654832/320.1264.632/320.1371.0
TS-CP²actrectut22/20.47109242/20.4510931------
TS-CP²has25032/2500.46172733/2500.561630------
TS-CP²mocap99/90.4731519/90.322516------
TS-CP²pump12010/1200.30813310/1200.178144------
TS-CP²skab3434/340.4123734/340.55245------
TS-CP²tssb7550/750.46122248/750.611166------
TS-CP²usc-had706/700.69141996/700.2913447------
TS-CP²utsa3220/320.26372820/320.683636------
EAggloactrectut20/2--0/2--------
EAgglohas2508/2500.3333.88/2500.3333.4------
EAgglomocap99/90.271089/90.27105------
EAgglopump1209/1200.429959/1200.421036------
EAggloskab3434/340.006.934/340.003.7------
EAgglotssb7575/750.0222.375/750.0226.7------
EAgglousc-had700/70--0/70--------
EAggloutsa3228/320.0232028/320.02278------
BOCDactrectut20/2--0/2--------
BOCDhas2508/2500.457188/2500.50738------
BOCDmocap99/90.1632139/90.163310------
BOCDpump1201/1200.04569121/1200.0465789------
BOCDskab3434/340.0463.534/340.0467.0------
BOCDtssb7528/750.4339128/750.43397------
BOCDusc-had700/70--0/70--------
BOCDutsa325/320.5114435/320.511494------
Hidalgoactrectut2---2/20.0110846---2/20.3116506
Hidalgohas250---8/2500.14757---8/2500.14731
Hidalgomocap9---9/90.051855---9/90.142746
Hidalgopump120---2/1200.0641896---2/1200.1132144
Hidalgoskab34---34/340.08151---34/340.22134
Hidalgousc-had70---3/700.0024346---4/700.3718350

Table 9. Per-dataset coverage and score of the SD-side extended-scope algorithm (Hidalgo). Same column convention as Table 8, with the SD primary metric (State Matching Score, SMS) replacing BiC. Hidalgo is multivariate-only by design, hence the absent (TSSB, UTSA) cells, and intrinsically Guided so the Non-Guided columns are uniformly empty.

AlgorithmDatasetSeriesDefault, NG Compl.Default, NG SMSDefault, NG t~\tilde{t} [s]Default, G Compl.Default, G SMSDefault, G t~\tilde{t} [s]Tuned, NG Compl.Tuned, NG SMSTuned, NG t~\tilde{t} [s]Tuned, G Compl.Tuned, G SMSTuned, G t~\tilde{t} [s]
Hidalgoactrectut2---2/20.2510846---2/20.3216506
Hidalgohas250---8/2500.39757---8/2500.39776
Hidalgomocap9---9/90.251855---9/90.322746
Hidalgopump120---2/1200.1741896---1/1200.1772877
Hidalgoskab34---34/340.59151---34/340.59159
Hidalgousc-had70---3/700.2224346---3/700.2223105

tGLAD - a budget-vs-quality tension. In its default configuration, tGLAD scores poorly (BiC 0.04-0.46) and takes from about 190 s (TSSB) to 37,000 s (ActRecTut) per series, leaving parts of HAS, PUMP and USC-HAD unfinished. These default runs use 100 training epochs, except on ActRecTut, MoCap and SKAB, where only runs with 2000 epochs are available (Table 7), and this longer training still leaves BiC at 0.04–0.10. Tuning the window size, the threshold and the number of epochs lifts BiC to 0.46–0.60 on the six multivariate datasets, still well below the main-pool leaders on each of them, and leaves it at 0.12–0.34 on the univariate TSSB and UTSA. The per-trial cost grows quasi-linearly with the number of epochs and roughly linearly with nn, so the tuned Non-Guided configuration completes only 40/250 series on HAS, 13/120 on PUMP and 9/70 on USC-HAD within our 24 h budget per configuration and dataset; its tuned scores on these three datasets are therefore means over these completed series only. tGLAD thus combines a moderate accuracy with a tunable regime that a fixed compute budget cannot accommodate on long series, hence its place in the extended-scope pool.

TS-CP2 - an unscalable method. TS-CP2 also requires a high number of epochs to converge. Its default configuration alone takes a median of 240 s (SKAB) to 14,200 s (USC-HAD) per series, so the grid sweep was not even dispatched: increasing the number of epochs would have exceeded the limits of our benchmark. Default scores remain limited (BiC 0.26–0.69 depending on dataset), suggesting that TS-CP2 is not competitive with the main-pool clique even on the cells it does complete, matching previous work conclusions [100].

EAgglo - O(n2)O(n^{2}) memory and structurally weak detector. Started, as in the reference implementation, from one cluster per observation, EAgglo’s hierarchical agglomeration builds an explicit n×nn \times n distance matrix and exhausts the cluster’s per-job RAM budget on series with n≳2⋅104n \gtrsim2 \cdot10^{4} samples, hence the systematic 0/2 coverage on ActRecTut and 0/70 on USC-HAD (the original paper applies it to a large sample only after grouping the observations into initial clusters). On the cells it does complete, EAgglo is also intrinsically weak because it massively over-segments: BiC collapses to 0.004 on SKAB, 0.022 on TSSB and 0.016 on UTSA, where its F1 precision stays below 0.01 at a recall above 0.9, i.e. it returns a hundred or more change points per true one. Its number of change points is the one that maximises a goodness-of-fit statistic, the sum of the energy divergences between adjacent segments, to which every boundary adds a non-negative term and which carries no penalty on the number of segments by default; the method moreover assumes independent observations. It scores reasonably only on PUMP (BiC 0.42) and HAS (0.33), and never approaches the main-pool leaders. We did not attempt grid tuning because no parameter setting can compensate for the algorithm’s O(n2)O(n^{2}) scaling on the longer series.

BOCD: at least quadratic exact Bayesian inference in our implementation. Our implementation runs the exact offline inference of the BOCD model [153], which evaluates every candidate segment, then the posterior of every change-point position, and therefore costs O(n2)O(n^{2}) memory and O(n3)O(n^{3}) time; this makes it fail on USC-HAD (n≈5⋅104n \approx5 \cdot10^{4}), ActRecTut (n≈3⋅104n \approx3 \cdot10^{4}) and all but one PUMP series. On the smaller cells it completes, BOCD is not particularly competitive (BiC 0.64 on SKAB, 0.43 on TSSB, 0.51 on UTSA, 0.45 on HAS for the 8 series it processes), and cannot reach the main pool’s coverage. We did not run a grid because the inference’s hyperpriors are conservative and the per-series cost on PUMP already exceeds 16 h/series at default.

Hidalgo (CPD). Hidalgo’s intrinsic-dimension prior is geometric and produces an SD-style label sequence; we evaluate the implied CPD by reading off the boundaries between consecutive runs of the same label. The default configuration is uniformly weak as a CPD detector (BiC between 0.003 on USC-HAD and 0.14 on HAS), reflecting that intrinsic dimension is a poor summary statistic for boundary localisation on series with few channels. The grid sweep recovers some performance on SKAB (0.22) and USC-HAD (0.37, on 4/70 series only) but Hidalgo never approaches main-pool CPD detectors.

Hidalgo (SD). As an SD method Hidalgo performs poorly on our series: its SMS reaches 0.59 on SKAB (with full coverage) and 0.39 on the 8 HAS series it completes, and stays in the 0.17–0.32 range elsewhere, well below the SD main pool. This verdict holds at least for series with few channels (d≤10d \le10 in TSB–SEG). Hidalgo was designed for high-dimensional data (e.g. molecular dynamics trajectories or brain imaging [122]), whose regions can differ widely in intrinsic dimension; its estimation of the local intrinsic dimension may well be more effective in high dimension, a setting our benchmark does not cover (§ 6).

Take-away. The extended-scope evaluation confirms the scoping logic of the main paper: none of these five methods Pareto-dominates the main-pool leaders on the cells they actually complete, and several (EAgglo, Hidalgo as a CPD detector) are outright weaker. The extended-scope pool therefore documents legitimate but specialised tools, not hidden state-of-the-art baselines.

Pairwise Correlation of Evaluation Metrics

Figure 9 reports the pairwise Pearson correlation between the CPD metrics (left) and the SD metrics (right), aggregated over all grid runs (both Non-Guided and Guided) of every algorithm on the 8 main datasets of TSB-SEG. The CPD metrics are the standard F1F_1-score, the Covering score, our proposed Gaussian F1F_1 and BiC (Appendix § 13); the SD metrics are the Adjusted Rand Index (ARI), the Adjusted Mutual Information (AMI), the Weighted Adjusted Rand Index (WARI) and the State Matching Score (SMS) [97]. All within-task correlations are positive: the lowest off-diagonal value is 0.57 for CPD (F1F_1 vs. Covering) and 0.54 for SD (AMI vs. SMS). Several metric pairs are essentially redundant: F1F_1 and Gaussian F1F_1 (r=0.98r = 0.98) as well as Covering and BiC (r=0.99r = 0.99) on the CPD side, and ARI/WARI (r=0.96r = 0.96) on the SD side. SMS is the most distinct SD metric, which motivates its use alongside the clustering metrics ARI, AMI and WARI. High correlations do not make the rankings metric-invariant, but the leaders are the same under every metric (Appendix § 27), which supports reporting BiC (CPD) and SMS (SD) in the main text.

Figure 9. Pairwise Pearson correlation between evaluation metrics over all grid runs (Non-Guided and Guided) of every algorithm on the 8 main datasets (438,176 runs with all CPD metrics, 105,316 with all SD metrics). Left: CPD metrics; right: SD metrics.

Per-Domain and Per-Dataset Spider Plots

For completeness, Figure 10 reports the per-domain spider plots of the six best algorithms (by mean tuned score) in each (task, supervision) combination (all the SD methods on the SD side), while Figure 11 details their performance at the individual dataset level. They confirm the conclusions drawn in RQ1: no single method dominates across all configurations.

Figure 10. Per-domain spider plots of the six best algorithms (tuned score) for CPD and SD, in both supervision modes. Within a task, a method keeps its colour and marker across the Non-Guided and Guided panels.

Figure 11. Per-dataset spider plots of the six best algorithms (tuned score) for CPD and SD, in both supervision modes. Same colours and markers as Figure 10.

Additional Views of the RQ1 Results

The figures of RQ1 report means and ranks over the 592 series. This appendix shows how the scores spread within each dataset, how much a per-series choice of method could gain over the single best method, and how the methods rank without any tuning.

Per-dataset score distributions. Figure 12 and Figure 13 give, for each dataset, the distribution of the per-series tuned score of the six best CPD methods of each mode (eight methods in all, as in the spider plots) and of every SD method. The interquartile range of a method is typically 0.2-0.35 on HAS, TSSB and UTSA, against 0.05-0.15 on PUMP and USC-HAD, whose series each follow one recording protocol. The feature-dependent behaviour of ClaSP (RQ1) is clearest on UTSA, where a quarter of its scores fall below 0.5 and 41% reach 0.9 or more. Missing series count as 0 (Appendix § 15): they pull TICC’s PUMP box down to 0 in Figure 13 (80 of the 120 series).

Figure 12. Per-dataset distribution of the per-series tuned BiC of the six best CPD methods of each mode, ordered by their best mean score over the two modes; number of series in parentheses. Light left half: Non-Guided; dark right half: Guided; a full-width box is drawn for a method run in one mode only (DynP) or that cannot use nCPn_{CP} (PELT). Boxes span the interquartile range, with the median as a line; whiskers extend to 1.5 times the interquartile range, and dots mark the series beyond.

Figure 13. Per-dataset distribution of the per-series tuned SMS of the SD methods, with the conventions of Figure 12; TICC runs in Guided mode only, and AutoPlait cannot use nSn_S.

Per-series oracle. Table 10 compares, in each task and mode, the single best method (highest mean tuned score) with an oracle that picks the best method of each series, among the three best methods or among all of them. Picking per series would raise the mean score by 0.11 to 0.16 in every task and mode, which quantifies the answer to RQ1: the single best method is strictly best on less than half of the series (4–40%), and the methods that win the others are not interchangeable with it. With nCPn_{CP}, the three best CPD methods (DynP, BinSeg and BottomUp) are nearly redundant (oracle 0.793 against 0.778), and the gain comes from the other methods. This oracle selects with the labels of each series and takes a maximum over noisy scores: it is an upper bound on what an automated method selection, e.g. meta-learned from the series features (Section 6), could reach.

TaskMode#MethodsSingle bestScoreStrict best onOracle, top 3Oracle, all
CPDNon-Guided17ClaSP0.69618%0.8050.858
CPDGuided20DynP0.7784%0.7930.884
SDNon-Guided5CLaP0.63340%0.7320.772
SDGuided6CLaP0.71437%0.7960.821

Table 10. Single best method against a per-series oracle (mean tuned BiC for CPD, SMS for SD, over the 592 series). Single best: highest mean tuned score; strict best on: share of the series on which it beats every other method (ties are frequent among the penalised detectors given nCPn_{CP}); oracle: mean over the series of the best score among the three best methods or among all methods of the mode.

Ranking without tuning. Figure 14 repeats the critical-difference diagrams of RQ1 on the Default configurations, the ranking a practitioner obtains without any tuning. The leaders largely persist. In CPD without nCPn_{CP}, BinSeg and PELT form a tied lead (mean ranks 5.59–5.70), followed by BottomUp and ClaSP (6.27–6.67), whereas Window, fourth once tuned (mean rank 6.91), falls to 10.12. With nCPn_{CP}, GGS, BottomUp, DynP and IGTS are statistically tied at the top (7.05–7.66). In SD, CLaP leads alone in both modes (mean rank 2.36 without nSn_S, 2.64 with it).

(a) CPD, Non-Guided.

(b) CPD, Guided.

(c) SD, Non-Guided.

(d) SD, Guided.

Figure 14. Critical-difference diagrams of the Default configurations over the 592 series, with the test of Figure 3 (two-sided Wilcoxon signed-rank test with Holm correction, α=0.1\alpha= 0.1).

CPD vs. SD in Each Supervision Mode

Figure 5 pools the runs of both supervision modes. Table 11 repeats its statistics for each mode separately. Envelopes are computed within each mode; the tail compositions use the pooled thresholds (r<−0.27r < -0.27, r>+0.36r > +0.36) on the runs for which the SMS error decomposition is available. Both modes lead to the same conclusions: a residual concentrated around zero, a BiC-SMS correlation of 0.76–0.79, rare large SMS drops at high BiC, a lower tail split between Delay and Missing errors and an upper tail dominated by Isolation. The Guided envelope is wider on the upper side (+0.40 against +0.31), partly because of the methods that run only in this mode (+0.36 without TICC and Hidalgo).

PooledNon-GuidedGuided
Runs97,07646,82550,797
Pearson correlation of BiC and SMS0.790.790.76
Runs with ∣r∣≤0.05\lvert r\rvert\le0.0533.8%33.2%34.6%
95% envelope of rr[−0.27, +0.36][−0.26, +0.31][−0.28, +0.40]
SMS < 0.6 among runs with BiC ≥0.8\ge0.83.7%2.7%4.0%
Lower tail (r<−0.27r < -0.27): Delay / Missing share36% / 40%39% / 37%36% / 40%
Upper tail (r>+0.36r > +0.36): Isolation share88%88%88%

Table 11. RQ2 statistics in each supervision mode (SD-capable methods, 8 main datasets, all default and grid runs). The Guided runs of AutoPlait are its Non-Guided ones (546 runs), counted once in the pooled column.

The quality of the proxy also depends on the series and on the method. It is tightest when no state recurs (∣r∣≤0.05\lvert r\rvert\le0.05 for 41% of the runs, against 23% when states recur) and weakest on PUMP, whose 41–43 states recur within every cycle (median r=−0.18r = -0.18): boundaries can be right while labels are wrong. Among methods, CLaP, whose labelling is the most accurate, keeps 60% of its runs within ∣r∣≤0.05\lvert r\rvert\le0.05, against 26–27% for E2USD and Time2State.

Runtime-Accuracy Distributions

Figure 15 reports the per-series runtime distributions for CPD methods, corresponding to the aggregated runtime-accuracy trade-off shown in RQ3 (Figure 6). Figure 16 reports the equivalent runtime-accuracy trade-off and per-series runtime distributions for the SD task.

Figure 15. Per-series runtime distribution on the CPD task (tuned configuration on BiC, 8 main datasets), for the CPD methods (blue) and the SD methods scored on CPD (orange), sorted by median runtime. The light left half of each box reports the Non-Guided runtimes, the dark right half the Guided ones; a method run in one mode only is drawn as a full-width box. Boxes span the interquartile range, whiskers 1.5 times it.

Figure 16. Runtime profile of SD methods on TSB-SEG. (a, b) Mean tuned SMS against the median runtime of the tuned configuration, as in Figure 6; (c) per-series runtime of the tuned configuration, with the conventions of Figure 15.

Unlike CPD, where the fastest methods are also among the most accurate, the SD methods all sit in the mid-range of runtimes: E2USD, AutoPlait, Time2State and HDP-HSMM take a median of 6–15 s per series, CLaP 25–29 s and TICC 69 s. Supplying the ground-truth number of states (Guided) tends to reduce runtimes for most of these methods. Combined with the SMS scores reported in § 5 (RQ1), CLaP is the most accurate SD method in both modes, at a moderate cost.

Hyperparameter Influence

To complement the aggregate tuning gap visible in the strip plots of RQ1 and the per-(algorithm, dataset) tuned/median/worst-case spreads of Appendix S, we report a per-algorithm, per-hyperparameter view of the score landscape. For every (algorithm, supervision mode) pair and each task (CPD scored under BiC, SD scored under SMS), Figures 17-20 plot the marginal score of each completed grid combination as a function of its hyperparameters. The most influential parameter, defined as the one whose marginal-mean score has the largest cross-value spread, is used as the primary x-axis; up to two additional parameters are encoded by colour and marker shape (legend below each panel). Combinations that did not complete on every (dataset, series) pair are nonetheless retained as long as their completion fraction exceeds 65%, with missing series imputed at score 0 so that incomplete configurations are visible but penalised. The five extended-scope algorithms (BOCD, EAgglo, TS-CP2, tGLAD, Hidalgo) are excluded from these figures because their grids are either unrealised or exercised on too narrow a subset of datasets to support a meaningful marginal analysis, as are AutoPlait (a single configuration) and AMOC (a single change point, whose only parameter is a minimum segment length); PELT, which cannot use nCPn_{CP}, appears in the Non-Guided figure only.

Reading the figures. Three readings are useful. (i) Vertical spread along the x-axis measures how strongly the primary parameter shapes the score; flat panels (e.g. HDP-HSMM, IGTS) indicate a method that is robust to its grid, whereas steep trends (e.g. the penalty of BinSeg, BottomUp, PELT and Window, or window_size for iCID, Time2State and E2USD) point to a knob that practitioners must tune. (ii) Colour scatter at fixed x captures the residual influence of the secondary parameter; tight colour clusters (e.g. ClaSP and CLaP, whose window-selection method barely matters) indicate robustness, while wide vertical bands (e.g. FLUSS, whose exclusion factor and window matter on top of its threshold) reveal a meaningful interaction. (iii) Comparison NG → G (Figure 17 vs. Figure 18) shows how knowing nCP/nSn_{CP}/n_S flattens or sharpens the response surface: most algorithms exhibit a clear upward shift accompanied by reduced grid sensitivity, suggesting that the supervision signal absorbs much of the per-series tuning headroom.

Take-aways. The figures confirm and refine the recommendations of RQ3. (a) For iCID, Time2State and E2USD, and for TIRE in Guided mode, the primary knob is the window size, with a monotone response; without KK, TIRE and Prophet respond first to their detection threshold, best at the highest value of the grid; ClaSP responds mostly to its distance and CLaP to its window-selection method, with a narrow range: a single coarse sweep is therefore sufficient. The exception is ClaSP’s complexity-invariant distance, which exceeds the time budget on PUMP and USC-HAD and drops in Guided mode, where its missing series are imputed at score 0. (b) Penalty-based methods (BinSeg, BottomUp, PELT, Window) respond mainly to the penalty, peaking near 8× the BiC penalty (1× for Window); the cost function matters at low penalties, where the RBF cost degrades least, and in Guided mode, where RBF is best for DynP, BinSeg and BottomUp. (c) Without KK, ChangeFinder is split by its multivariate strategy: the ensembling variant is markedly more sensitive to its smoothing window than the ℓ2\ell_2 variant. (d) One method stands out as inherently sensitive: TICC (jointly responsive to both β\beta and λ\lambda), confirming that it requires dataset-specific calibration to perform competitively. HDP-HSMM, and Prophet with KK, are by contrast nearly flat over their grids, the duration-prior strength being HDP-HSMM’s only visible knob.

Figure 18. Per-algorithm hyperparameter influence on CPD performance, Guided mode. Same conventions as Figure 17; PELT, which cannot use nCPn_{CP}, is shown there only. Compared to the Non-Guided figure, knowing nCPn_{CP} generally lifts the response surface and shrinks its vertical spread; TICC, run in this mode only, remains strongly responsive to its grid.

Figure 17. Per-algorithm hyperparameter influence on CPD performance, Non-Guided mode. Score: BiC (top left). For each algorithm, the most influential parameter (largest cross-value spread of marginal means) is used as the x-axis; colour and marker shape encode up to two additional parameters (legend below each panel). Parameter and value names are abbreviated for readability (e.g. win = window_size, cost = segment cost, pen = multiple X of the BIC penalty, thr = threshold, cinv = cinvariant_euclidean_distance); the full mapping is given in the source code released with the benchmark.

Figure 19. Per-algorithm hyperparameter influence on SD performance, Non-Guided mode. Score: SMS (top left). Same conventions as Figure 17.

Figure 20. Per-algorithm hyperparameter influence on SD performance, Guided mode. Same conventions as Figure 19.

Sensitivity to Input Features

We complement the runtime and accuracy analyses of RQ3 with a per-algorithm sensitivity study. For every (algorithm, supervision mode) pair we compute the Spearman rank correlation between the algorithm’s tuned score and four per-series structural features: length (nn), number of dimensions (dd), number of change points (nCPn_{CP}) and number of states (nSn_S). Tuned scores are computed as in § 4.3 (one configuration per dataset, applied uniformly to all series of that dataset).

Figure 21 reports the resulting heatmaps for CPD (top) and SD (bottom). Each algorithm is one row, with the four features in the Non-Guided and the Guided mode as columns (“-” marks a mode the algorithm does not run in); algorithms are ordered by mean tuned score over the modes they run in (descending). Two patterns stand out: in Non-Guided mode, the penalised detectors are nearly insensitive to the four features, ClaSP, CLaP, FLUSS, HDP-HSMM and AMOC degrade on series with many events (ρ\rho from −0.5-0.5 to −0.9-0.9), and Time2State and E2USD improve on them (ρ\rho up to 0.50.5); in Guided mode, almost every method degrades as the number of events grows, the series with many events remaining hard even when their number is known.

Performance on Long Series

This section provides additional details on the PAMAP2 case study discussed in RQ3. The PAMAP2 dataset contains 9 long multivariate series of 8k to 447k samples. Only 17 out of the 26 algorithms process all 9 series within the computational budget. Figure 22 presents the score distributions and runtime variations for the methods evaluated on this dataset, for both CPD and SD tasks under both supervision modes. Note, however, that long series can in practice be subsampled to recover the desired behaviour at scale, as noted in [90]. Runtimes follow the segment cost of the tuned configuration: ℓ2\ell_2 for BinSeg (about 1 s per series), RBF for PELT and BottomUp (about 10310^3 s), which beats their ℓ2\ell_2 configuration (90–100 s) by 0.01–0.02 BiC.

Figure 22. Analysis on the PAMAP2 dataset (up to 447k samples per series), for the 17 methods that process its 9 series. Top: tuned score of each series, (a) BiC for CPD, (b) SMS for SD; bottom: runtime of the tuned configuration on each series. Same conventions as Figure 15; methods sorted by median tuned score.

Window. On PAMAP2, Window scores higher in the Non-Guided mode (tuned BiC 0.54) than in the Guided one (0.47). In Guided mode, Window must stop at the true number of peaks of its discrepancy curve, and only a third of them fall within the F1F_1 margin of a true change point. Its best Non-Guided configuration places about three times as many change points as the ground truth, which recovers twice as many true change points and raises the covering in both directions.

Extending TSB-SEG

TSB-SEG is meant to grow. New methods and datasets enter through the two open-source components that produced every number of this paper: the tsseg library (detectors and metrics) and the benchmark pipeline (configurations, runs and analysis). The TSB-SEG repository is frozen on this paper and pins the version of tsseg that produced it; tsseg keeps evolving, and new methods enter tsseg first.

Adding an algorithm. Candidates include the recent methods collected in community reading lists [174]. A method is contributed as a pull request to tsseg that provides: (i) a detector class following the common API (fit/predict on an n×dn \times d array, returning either the sorted change-point indices or one state label per sample) and declaring its capabilities (task, univariate and/or multivariate input, whether it can take KK); (ii) a declarative schema of its parameters, with types and admissible ranges checked at fit time; (iii) its default parameters (those recommended by the original authors, or a documented choice when they give none) and a search grid of 2-4 values for its 2-4 most influential parameters, flagging the parameters that KK replaces in Guided mode; (iv) a provenance note (original paper, source code, licence). The generic test suite of tsseg checks the API contract of every registered detector. The benchmark then runs the default configuration and the grid on every dataset in both supervision modes, under the same budget as all other methods (Appendix § 15); the method joins the main pool if it completes (nearly) every series within this budget, and the extended-scope pool otherwise.

Adding a dataset. A dataset is contributed with a loader returning, for each series, the observations T∈Rn×dT \in\mathbb{R}^{n \times d} and a dense state sequence QQ (one label per sample, the change points being derived from label changes), together with its provenance, licence and annotation protocol (Appendix § 10). Datasets annotated with boundaries only can enter by giving each segment its own state, but they then inform CPD only.

Reporting. Every run is logged per series with all the metrics of § 4.4, so that a new method or dataset enters every table and figure of this paper by re-running the analysis scripts; rankings and statistical tests are then recomputed over the extended collection.

Per-(algorithm, dataset) Breakdown for the Main Pool

For completeness, Table 12-Table 13 report the per-(algorithm, dataset) decomposition of the main-pool 21 algorithms into the four configurations of interest (Default, Worst-case, Median, Tuned) in both Non-Guided and Guided modes. Each cell averages the series that the method completed, without imputation (e.g. TICC in Guided mode on PUMP, 40 of 120 series), whereas the means, ranks and figures over the 592 series count the missing ones as 0 (Appendix § 15). The worst-case/median/tuned triple quantifies the tuning gap per cell: a small spread indicates a stable algorithm whose grid is largely interchangeable, whereas a wide spread signals a method whose realistic deployment requires a dataset-specific selection.

AlgoDatasetNon-Guided Def.Non-Guided WorstNon-Guided Med.Non-Guided TunedNon-Guided t~\tilde{t} [s]Guided Def.Guided WorstGuided Med.Guided TunedGuided t~\tilde{t} [s]
AMOCActRecTut0.240.240.240.240.20.240.240.240.240.2
AMOCHAS0.610.610.610.610.20.610.610.610.610.2
AMOCMoCap0.300.300.300.300.20.300.300.300.300.2
AMOCPUMP0.070.070.070.070.20.070.070.070.070.2
AMOCSKAB0.710.710.720.720.30.710.710.720.720.3
AMOCTSSB0.420.420.420.420.30.420.420.420.420.3
AMOCUSC-HAD0.240.240.240.240.30.240.240.240.240.3
AMOCUTSA0.640.640.640.640.30.640.640.640.640.3
BinSegActRecTut0.320.310.410.7742.80.430.430.600.7330.3
BinSegHAS0.660.300.530.731.10.780.780.800.821.1
BinSegMoCap0.660.140.370.721.00.660.660.710.821.7
BinSegPUMP0.540.310.570.6222.60.620.600.620.6219.2
BinSegSKAB0.770.430.560.780.20.760.760.780.800.2
BinSegTSSB0.420.330.400.480.60.420.420.570.701.1
BinSegUSC-HAD0.810.550.780.8752.70.860.820.850.8753.2
BinSegUTSA0.550.340.490.631.80.660.660.750.802.7
BottomUpActRecTut0.460.310.650.7821.70.630.610.690.748.7
BottomUpHAS0.610.230.490.721.60.780.780.810.831.7
BottomUpMoCap0.620.130.330.751.70.580.580.660.801.5
BottomUpPUMP0.560.380.600.638.60.630.630.630.634.1
BottomUpSKAB0.770.400.550.790.20.780.780.800.820.2
BottomUpTSSB0.400.150.380.471.50.550.550.580.651.8
BottomUpUSC-HAD0.780.370.660.8333.40.800.780.820.8744.7
BottomUpUTSA0.440.060.350.6411.30.710.700.730.789.8
ChangeFinderActRecTut0.490.100.420.5884.50.420.300.450.5678.2
ChangeFinderHAS0.580.190.470.6810.50.680.620.670.7110.0
ChangeFinderMoCap0.360.160.330.637.30.660.330.480.661.9
ChangeFinderPUMP0.350.040.410.6266.20.560.500.560.587.0
ChangeFinderSKAB0.520.330.480.672.80.640.400.520.690.4
ChangeFinderTSSB0.490.410.450.501.80.620.600.630.661.5
ChangeFinderUSC-HAD0.590.180.500.6655.10.630.480.610.6464.1
ChangeFinderUTSA0.510.260.500.654.40.680.610.650.712.9
ClaSPActRecTut0.440.200.360.425100.310.300.350.417.8k
ClaSPHAS0.740.580.630.7410.60.800.700.750.806.8
ClaSPMoCap0.750.690.750.7913.80.810.760.800.8314.6
ClaSPPUMP0.200.190.290.426070.420.320.390.45603
ClaSPSKAB0.470.460.540.631.30.690.600.660.710.6
ClaSPTSSB0.850.830.850.872.50.900.880.900.911.0
ClaSPUSC-HAD0.740.610.720.814480.740.700.760.82469
ClaSPUTSA0.730.520.640.7313.80.950.890.930.957.1
AlgoDatasetNon-Guided Def.Non-Guided WorstNon-Guided Med.Non-Guided TunedNon-Guided t~\tilde{t} [s]Guided Def.Guided WorstGuided Med.Guided TunedGuided t~\tilde{t} [s]
DynPActRecTut-----0.560.560.670.7434.0
DynPHAS-----0.780.780.810.830.8
DynPMoCap-----0.680.680.740.841.1
DynPPUMP-----0.620.610.620.6321.4
DynPSKAB-----0.780.780.790.810.3
DynPTSSB-----0.490.490.590.720.5
DynPUSC-HAD-----0.850.830.850.8831.3
DynPUTSA-----0.680.680.760.811.9
ESPRESSOActRecTut-----0.490.480.490.515.1k
ESPRESSOHAS-----0.780.780.780.7851.8
ESPRESSOMoCap-----0.730.710.740.75103
ESPRESSOPUMP-----0.510.490.500.522.1k
ESPRESSOSKAB-----0.830.800.830.836.4
ESPRESSOTSSB-----0.480.480.490.524.8
ESPRESSOUSC-HAD-----0.800.790.790.803.0k
ESPRESSOUTSA-----0.700.670.690.7332.0
FLUSSActRecTut0.120.100.160.4638.70.380.230.320.4440.1
FLUSSHAS0.480.330.480.5712.40.650.600.660.7112.0
FLUSSMoCap0.160.160.160.541.90.420.300.400.631.6
FLUSSPUMP0.080.040.070.4624.50.220.100.190.414.0
FLUSSSKAB0.430.260.460.7110.80.620.550.600.6911.1
FLUSSTSSB0.510.390.510.691.70.710.690.750.801.9
FLUSSUSC-HAD0.240.100.240.4124.80.290.250.340.5221.4
FLUSSUTSA0.540.200.440.632.20.840.820.860.912.1
GGSActRecTut0.570.460.570.781650.600.600.600.67270
GGSHAS0.490.350.500.628.40.820.820.820.833.6
GGSMoCap0.850.620.750.8520.40.920.910.920.9312.7
GGSPUMP0.330.200.330.511640.650.560.640.65352
GGSSKAB0.390.300.420.571.90.760.760.760.761.1
GGSTSSB0.440.410.440.493.10.480.470.480.511.9
GGSUSC-HAD0.700.550.690.811370.720.670.720.7987.6
GGSUTSA0.540.460.540.6111.10.730.730.730.741.9
IGTSActRecTut0.380.320.380.4629.20.460.420.450.4675.3
IGTSHAS0.530.370.510.630.40.780.780.780.780.8
IGTSMoCap0.620.590.610.640.80.640.640.640.641.4
IGTSPUMP0.310.180.310.5426.20.630.630.630.63158
IGTSSKAB0.420.190.410.600.40.810.810.810.830.6
IGTSTSSB0.390.350.380.410.50.420.420.420.420.8
IGTSUSC-HAD0.830.580.810.8317.60.830.820.830.835.1
IGTSUTSA0.580.510.580.630.60.660.650.650.660.5
PELTActRecTut0.400.310.530.777.50.400.310.530.777.5
PELTHAS0.640.240.510.730.60.640.240.510.730.6
PELTMoCap0.610.130.340.770.60.610.130.340.770.6
PELTPUMP0.550.350.590.620.60.550.350.590.620.6
PELTSKAB0.770.410.550.790.20.770.410.550.790.2
PELTTSSB0.400.210.390.470.40.400.210.390.470.4
PELTUSC-HAD0.810.500.710.869.10.810.500.710.869.1
PELTUTSA0.500.140.390.631.70.500.140.390.631.7
ProphetActRecTut0.700.520.620.709.60.400.400.400.4171.1
ProphetHAS0.480.280.440.5848.00.650.650.660.6746.2
ProphetMoCap0.510.340.460.558.60.510.400.460.547.3
ProphetPUMP0.250.200.280.438.30.520.520.530.5374.6
ProphetSKAB0.470.100.320.6739.70.610.610.670.7639.3
ProphetTSSB0.460.190.300.495.50.590.580.580.594.5
ProphetUSC-HAD0.690.480.630.698.50.700.630.670.708.3
ProphetUTSA0.500.150.310.597.60.650.650.650.656.6

Table 12. Main-pool algorithms on CPD: per-(algorithm, dataset) default / worst-case / median / tuned BiC, in both Non-Guided (NG) and Guided (G) modes. The SD methods (last block) are scored on the change points induced by their labels, except CLaP, which labels the segments of ClaSP and is not scored separately. t~\tilde{t} is the median wall-clock of the tuned configuration in seconds. “-” = (mode, dataset) pair not evaluated for that algorithm (e.g. intrinsically Guided methods have no NG entries).

AlgoDatasetNon-Guided Def.Non-Guided WorstNon-Guided Med.Non-Guided TunedNon-Guided t~\tilde{t} [s]Guided Def.Guided WorstGuided Med.Guided TunedGuided t~\tilde{t} [s]
Time2StateActRecTut0.650.540.600.6650.40.650.570.630.674.7
HAS0.450.340.400.4614.70.690.620.660.706.8
MoCap0.810.280.660.8134.80.760.400.700.819.6
PUMP0.480.450.530.5917.60.490.450.540.618.6
SKAB0.460.380.430.4917.20.630.630.740.828.1
TSSB0.380.120.270.4012.30.590.320.500.649.4
USC-HAD0.660.410.610.6716.70.680.440.630.6915.2
UTSA0.260.100.180.3114.20.620.260.490.6326.6
AutoPlaitActRecTut0.310.310.310.3147.40.310.310.310.3147.4
HAS0.650.650.650.6510.40.650.650.650.6510.4
MoCap0.860.860.860.8625.00.860.860.860.8625.0
PUMP0.140.140.140.143160.140.140.140.14316
SKAB0.730.730.730.731.50.730.730.730.731.5
TSSB0.390.390.390.390.70.390.390.390.390.7
USC-HAD0.310.310.310.311550.310.310.310.31155
UTSA0.620.620.620.622.20.620.620.620.622.2
CLaPActRecTut0.400.530.570.596230.540.500.530.57647
HAS0.750.690.730.7515.10.810.750.780.8213.4
MoCap0.740.700.770.7841.00.740.710.760.8325.9
PUMP0.03-0.16-0.040.043850.19-0.020.060.26550
SKAB0.620.620.620.622.20.740.640.680.742.5
TSSB0.860.830.870.869.40.900.880.900.905.7
USC-HAD0.810.810.860.885000.760.760.780.78498
UTSA0.820.760.820.8227.40.970.910.960.9718.4
E2USDActRecTut0.680.600.710.7812.50.780.770.790.8415.2
HAS0.530.430.480.5312.70.750.720.740.7512.7
MoCap0.770.550.690.7714.30.740.650.710.7510.2
PUMP0.300.270.330.3718.10.320.280.350.4012.2
SKAB0.480.350.400.4815.60.720.710.740.7516.0
TSSB0.430.370.400.4318.10.570.560.590.6114.2
USC-HAD0.700.570.640.7016.40.640.530.590.6614.9
UTSA0.440.350.410.4613.30.690.630.680.7212.7
HDP-HSMMActRecTut0.410.340.480.636.20.540.410.470.5415.1
HAS0.650.640.660.6811.30.730.690.720.734.0
MoCap0.580.530.620.696.30.610.540.600.6810.6
PUMP-0.05-0.07-0.05-0.0412.7-0.04-0.05-0.04-0.0425.2
SKAB0.670.630.660.706.20.810.710.770.814.1
TSSB0.560.480.530.5916.70.570.500.550.574.8
USC-HAD0.310.260.310.3323.20.300.260.300.319.0
UTSA0.630.630.670.7211.40.660.590.650.725.5
TICCActRecTut-----0.820.700.800.861.0k
HAS-----0.790.700.770.8029.3
MoCap-----0.810.640.730.80218
PUMP-----0.560.540.540.541.8k
SKAB-----0.830.820.850.8522.1
TSSB-----0.440.440.460.5522.4
USC-HAD-----0.620.480.520.64716
UTSA-----0.610.560.610.6512.1
AlgoDatasetNon-Guided Def.Non-Guided WorstNon-Guided Med.Non-Guided TunedNon-Guided t~\tilde{t} [s]Guided Def.Guided WorstGuided Med.Guided TunedGuided t~\tilde{t} [s]
Time2StateActRecTut0.690.650.720.7834.70.720.710.750.8012.7
Time2StateHAS0.470.410.450.5114.30.730.730.740.756.8
Time2StateMoCap0.840.560.750.8415.70.790.590.780.859.6
Time2StatePUMP0.290.250.340.4117.60.320.260.370.478.6
Time2StateSKAB0.440.320.420.4912.50.670.670.800.868.1
Time2StateTSSB0.460.260.390.4714.40.610.500.600.6810.2
Time2StateUSC-HAD0.710.610.680.7217.20.690.600.660.7014.7
Time2StateUTSA0.420.290.390.4813.20.750.590.700.7626.6

Table 13. Main-pool SD algorithms: per-(algorithm, dataset) default / worst-case / median / tuned SMS, in both Non-Guided (NG) and Guided (G) modes. Conventions identical to Table 12.

(continued from previous page)

AlgoDatasetNon-Guided Def.Non-Guided WorstNon-Guided Med.Non-Guided TunedNon-Guided t~\tilde{t} [s]Guided Def.Guided WorstGuided Med.Guided TunedGuided t~\tilde{t} [s]
TIREActRecTut0.360.290.400.821820.750.530.650.7550.6
TIREHAS0.560.130.440.6544.30.630.550.610.6841.1
TIREMoCap0.500.150.430.5911.10.520.420.510.6251.8
TIREPUMP0.210.120.250.5755.00.670.530.610.6749.2
TIRESKAB0.640.170.580.734.90.700.630.710.799.2
TIRETSSB0.410.050.270.586.50.600.520.550.6516.7
TIREUSC-HAD0.460.280.370.6668.10.610.310.530.6771.4
TIREUTSA0.370.020.240.6293.20.680.680.730.7571.5
WindowActRecTut0.470.230.460.7224.20.730.660.700.7531.3
WindowHAS0.400.220.460.671.70.690.660.710.751.2
WindowMoCap0.410.240.400.542.40.420.400.450.491.2
WindowPUMP0.610.220.540.6425.20.630.580.630.650.7
WindowSKAB0.410.180.560.730.20.680.640.710.760.2
WindowTSSB0.420.410.430.530.20.630.570.630.701.8
WindowUSC-HAD0.420.260.560.7336.70.440.300.580.7169.3
WindowUTSA0.590.360.560.693.90.710.620.670.714.5
iCIDActRecTut0.650.320.570.717420.680.320.560.75697
iCIDHAS0.490.350.500.6323.30.480.350.500.6320.8
iCIDMoCap0.360.290.430.6344.90.360.280.430.6446.3
iCIDPUMP0.460.370.470.585810.460.370.470.58635
iCIDSKAB0.720.490.720.762.50.710.490.720.772.1
iCIDTSSB0.390.260.400.5713.40.390.260.400.5613.1
iCIDUSC-HAD0.550.410.560.681.1k0.550.410.560.681.0k
iCIDUTSA0.200.100.210.431030.210.100.200.4399.8
\multicolumn{12}{c}{SD methods, scored on the change points induced by their labels}
AutoPlaitActRecTut0.220.220.220.2247.40.220.220.220.2247.4
AutoPlaitHAS0.650.650.650.6510.40.650.650.650.6510.4
AutoPlaitMoCap0.880.880.880.8825.00.880.880.880.8825.0
AutoPlaitPUMP0.270.270.270.273160.270.270.270.27316
AutoPlaitSKAB0.710.710.710.711.50.710.710.710.711.5
AutoPlaitTSSB0.420.420.420.420.70.420.420.420.420.7
AutoPlaitUSC-HAD0.430.430.430.431550.430.430.430.43155
AutoPlaitUTSA0.610.610.610.612.20.610.610.610.612.2
E2USDActRecTut0.600.510.610.679.00.660.570.660.6915.2
E2USDHAS0.480.330.390.4812.70.720.610.670.7212.7
E2USDMoCap0.760.290.590.7614.30.710.500.650.7310.2
E2USDPUMP0.500.480.540.5918.10.500.480.540.6012.2
E2USDSKAB0.470.300.410.4715.60.640.640.670.7015.7
E2USDTSSB0.360.210.290.3716.50.540.410.500.5815.3
E2USDUSC-HAD0.690.450.590.6914.80.680.460.590.6815.1
E2USDUTSA0.280.120.210.2814.10.610.340.480.6412.7
HDP-HSMMActRecTut0.330.270.440.5912.10.430.270.330.5314.9
HDP-HSMMHAS0.640.600.650.677.40.730.670.730.744.0
HDP-HSMMMoCap0.560.510.590.716.30.630.510.600.687.9
HDP-HSMMPUMP0.120.110.110.1312.70.120.110.110.1325.9
HDP-HSMMSKAB0.700.630.690.756.20.780.670.730.784.1
HDP-HSMMTSSB0.570.470.550.6015.10.610.540.600.624.4
HDP-HSMMUSC-HAD0.370.350.360.4211.00.370.360.360.419.9
HDP-HSMMUTSA0.610.510.630.6911.90.640.520.640.685.2
TICCActRecTut-----0.720.400.690.7593.0
TICCHAS-----0.790.520.720.8030.3
TICCMoCap-----0.750.500.690.78218
TICCPUMP-----0.640.630.630.632.0k
TICCSKAB-----0.810.790.820.8322.1
TICCTSSB-----0.610.420.590.6277.3
TICCUSC-HAD-----0.660.320.350.70900
TICCUTSA-----0.670.260.610.7285.0

Table 22.

(continued on next page)

Cross-metric Consistency Check

The per-(algorithm, dataset) tables of Appendices I and S use the primary metric of each task (BiC for CPD, SMS for SD). For transparency, we re-emit the same tables under the alternative metrics that the segmentation literature most commonly reports: Gaussian F1F_1 for CPD (point-process matching with Gaussian tolerance), and ARI / WARI for SD (label-permutation invariant clustering metrics). Each table is self-contained: its Tuned column is the configuration maximising the table’s own metric, not a re-evaluation of the BiC/SMS-best configuration. The leaders do not depend on the metric. In CPD, the top five methods of each mode are the same under BiC, Covering, F1F_1 and Gaussian F1F_1: ClaSP and the penalised detectors without KK; DynP, BinSeg, BottomUp, GGS and ClaSP with KK, within 0.02 of each other under the F1F_1-type metrics, which favour ClaSP and GGS. In SD, CLaP leads in both modes under every metric, with Time2State second in Guided mode. Lower ranks can swap (e.g. HDP-HSMM and E2USD under WARI): the conclusions of the main paper are not artefacts of the primary metric, but fine-grained orderings are metric-dependent.

Main pool.

Table 14: Main-pool algorithms on CPD: per-(algorithm, dataset) default / worst-case / median / tuned Gaussian F1F_1, in both Non-Guided (NG) and Guided (G) modes. Same conventions as Table 12, with BiC replaced by Gaussian F1F_1. The tuned configuration in this table is selected on Gaussian F1F_1 itself (not on BiC), so each table is self-contained.

AlgoDatasetNon-Guided Def.Non-Guided WorstNon-Guided Med.Non-Guided TunedNon-Guided t~\tilde{t} [s]Guided Def.Guided WorstGuided Med.Guided TunedGuided t~\tilde{t} [s]
AMOCActRecTut0.050.050.050.050.20.050.050.050.050.2
AMOCHAS0.190.190.190.190.20.190.190.190.190.2
AMOCMoCap0.170.170.170.170.20.170.170.170.170.2
AMOCPUMP0.030.030.030.030.20.030.030.030.030.2
AMOCSKAB0.120.120.120.120.30.120.120.120.120.3
AMOCTSSB0.000.000.000.000.30.000.000.000.000.3
AMOCUSC-HAD0.170.170.170.170.30.170.170.170.170.3
AMOCUTSA0.090.090.090.090.30.090.090.090.090.3
BinSegActRecTut0.130.090.260.6532.00.390.390.540.6230.3
BinSegHAS0.330.120.250.421.10.460.460.500.541.1
BinSegMoCap0.470.100.220.612.00.510.510.570.691.7
BinSegPUMP0.470.240.580.6822.60.670.660.670.6819.2
BinSegSKAB0.180.000.110.200.20.180.170.170.200.3
BinSegTSSB0.070.020.060.140.60.080.080.200.351.1
BinSegUSC-HAD0.790.160.650.8243.70.800.790.820.8753.2
BinSegUTSA0.100.020.020.243.30.100.100.170.342.7

Table 14.

(continued from previous page)

AlgoDatasetNon-Guided Def.Non-Guided WorstNon-Guided Med.Non-Guided TunedNon-Guided t~\tilde{t} [s]Guided Def.Guided WorstGuided Med.Guided TunedGuided t~\tilde{t} [s]
BottomUpActRecTut0.320.090.430.637.00.540.540.580.658.7
BottomUpHAS0.300.090.220.441.60.450.450.500.551.7
BottomUpMoCap0.350.100.220.571.70.410.410.490.651.5
BottomUpPUMP0.500.280.610.693.50.690.680.690.698.2
BottomUpSKAB0.220.000.120.230.20.220.170.210.220.3
BottomUpTSSB0.060.030.060.121.50.130.130.150.231.8
BottomUpUSC-HAD0.650.030.520.8140.80.680.680.760.8544.7
BottomUpUTSA0.070.010.010.192.10.120.120.120.329.8
ChangeFinderActRecTut0.270.000.320.4780.50.440.050.430.4874.1
ChangeFinderHAS0.250.120.180.3810.50.360.280.350.4310.0
ChangeFinderMoCap0.200.000.150.477.30.360.130.240.371.9
ChangeFinderPUMP0.320.000.370.5965.00.600.530.600.657.5
ChangeFinderSKAB0.050.000.020.212.80.100.010.040.130.5
ChangeFinderTSSB0.150.080.080.191.40.240.140.230.261.3
ChangeFinderUSC-HAD0.510.090.450.5755.10.530.410.510.5411.1
ChangeFinderUTSA0.180.000.100.223.50.210.050.200.233.9
ClaSPActRecTut0.190.080.150.216530.380.280.300.38601
ClaSPHAS0.450.280.320.4510.60.500.370.420.506.8
ClaSPMoCap0.560.550.580.6214.50.580.550.580.6047.4
ClaSPPUMP0.180.130.260.576070.540.280.420.59603
ClaSPSKAB0.000.000.050.141.80.150.080.090.160.6
ClaSPTSSB0.630.610.630.682.50.690.670.720.731.0
ClaSPUSC-HAD0.680.490.610.804480.740.670.740.81469
ClaSPUTSA0.440.280.360.4713.80.690.570.640.697.1
DynPActRecTut-----0.480.480.550.6121.3
DynPHAS-----0.460.460.510.550.8
DynPMoCap-----0.520.520.580.731.1
DynPPUMP-----0.680.670.680.6928.8
DynPSKAB-----0.170.170.180.210.3
DynPTSSB-----0.100.100.190.330.5
DynPUSC-HAD-----0.770.770.810.8731.3
DynPUTSA-----0.130.120.160.371.9
ESPRESSOActRecTut-----0.500.500.520.535.1k
ESPRESSOHAS-----0.470.470.470.4750.9
ESPRESSOMoCap-----0.550.520.560.60106
ESPRESSOPUMP-----0.640.610.630.652.1k
ESPRESSOSKAB-----0.240.190.230.256.1
ESPRESSOTSSB-----0.120.110.110.135.7
ESPRESSOUSC-HAD-----0.740.720.730.743.0k
ESPRESSOUTSA-----0.130.080.110.1336.4
FLUSSActRecTut0.040.000.050.4043.20.220.070.160.4610.6
FLUSSHAS0.120.070.130.2413.00.290.240.280.3612.0
FLUSSMoCap0.000.000.000.316.20.230.150.220.3110.5
FLUSSPUMP0.020.000.020.5424.50.150.080.190.494.3
FLUSSSKAB0.100.000.000.1510.80.100.020.020.1711.1
FLUSSTSSB0.210.140.210.351.60.470.400.420.511.9
FLUSSUSC-HAD0.060.020.100.314.60.220.090.260.4921.4
FLUSSUTSA0.050.020.060.272.20.580.550.550.632.1
GGSActRecTut0.320.190.320.541650.500.490.500.59270
GGSHAS0.300.200.290.378.40.580.580.580.593.6
GGSMoCap0.700.460.600.7218.10.790.780.790.8112.7
GGSPUMP0.250.140.260.431640.730.610.720.75350
GGSSKAB0.160.110.170.221.90.270.240.270.271.0
GGSTSSB0.030.020.030.073.10.130.120.130.151.9
GGSUSC-HAD0.690.580.620.7866.30.700.650.700.7987.6
GGSUTSA0.090.060.090.1411.10.240.240.240.241.9

Table 23.

(continued on next page)

AlgoDatasetNon-Guided Def.Non-Guided WorstNon-Guided Med.Non-Guided TunedNon-Guided t~\tilde{t} [s]Guided Def.Guided WorstGuided Med.Guided TunedGuided t~\tilde{t} [s]
IGTSActRecTut0.170.140.170.351930.390.380.390.3975.3
IGTSHAS0.240.150.220.291.50.470.470.470.470.8
IGTSMoCap0.450.330.440.490.40.500.500.500.501.4
IGTSPUMP0.240.150.240.4826.20.690.690.690.6962.2
IGTSSKAB0.150.100.140.200.40.220.220.220.240.6
IGTSTSSB0.000.000.000.010.50.080.080.080.080.5
IGTSUSC-HAD0.780.480.590.793.90.760.750.760.775.1
IGTSUTSA0.080.040.070.111.30.100.100.100.101.0
PELTActRecTut0.240.090.330.671.10.240.090.330.671.1
PELTHAS0.320.100.240.430.60.320.100.240.430.6
PELTMoCap0.370.110.220.650.60.370.110.220.650.6
PELTPUMP0.490.260.600.690.60.490.260.600.690.6
PELTSKAB0.160.000.120.210.10.160.000.120.210.1
PELTTSSB0.050.030.060.140.40.050.030.060.140.4
PELTUSC-HAD0.770.030.590.8212.00.770.030.590.8212.0
PELTUTSA0.080.010.010.221.70.080.010.010.221.7
ProphetActRecTut0.390.270.390.4571.60.420.420.420.4371.1
ProphetHAS0.160.150.160.2042.10.280.280.290.3045.0
ProphetMoCap0.270.050.240.318.60.220.100.160.267.3
ProphetPUMP0.230.180.300.4375.00.540.540.540.5470.1
ProphetSKAB0.120.070.080.1439.70.120.120.140.2239.3
ProphetTSSB0.130.110.110.132.90.200.200.200.201.8
ProphetUSC-HAD0.630.420.540.638.50.650.500.590.658.8
ProphetUTSA0.070.060.060.096.50.090.090.090.096.6
TIREActRecTut0.150.090.200.681840.600.450.560.7048.6
TIREHAS0.240.050.160.3122.10.260.140.220.3441.1
TIREMoCap0.270.120.220.3511.10.250.130.250.3612.6
TIREPUMP0.210.070.250.5754.30.730.590.670.7349.2
TIRESKAB0.170.070.100.232.50.170.080.120.238.8
TIRETSSB0.170.040.090.2527.60.160.090.090.2638.6
TIREUSC-HAD0.390.040.260.591780.500.220.410.65156
TIREUTSA0.090.010.030.1446.70.080.050.080.1740.5
WindowActRecTut0.200.050.240.6660.50.630.560.620.7031.3
WindowHAS0.180.100.200.341.20.330.300.360.441.2
WindowMoCap0.150.080.180.300.20.120.120.160.230.3
WindowPUMP0.650.230.580.6852.60.660.630.660.690.5
WindowSKAB0.110.080.130.180.20.200.160.170.200.2
WindowTSSB0.050.020.070.210.90.210.150.160.321.8
WindowUSC-HAD0.280.130.440.6764.10.300.180.460.6769.3
WindowUTSA0.040.010.020.130.20.150.030.020.150.4
iCIDActRecTut0.470.150.480.677080.490.140.490.64704
iCIDHAS0.220.130.200.3020.70.210.130.200.3121.9
iCIDMoCap0.250.160.250.4744.90.240.160.240.4846.3
iCIDPUMP0.470.350.470.595740.470.350.470.59624
iCIDSKAB0.060.040.050.171.90.050.040.050.162.6
iCIDTSSB0.120.090.110.1713.60.110.090.110.1612.2
iCIDUSC-HAD0.350.130.360.611.1k0.350.120.360.611.0k
iCIDUTSA0.050.030.050.1296.60.050.030.050.1398.9
AutoPlaitActRecTut0.050.050.050.0547.40.050.050.050.0547.4
AutoPlaitHAS0.330.330.330.3310.40.330.330.330.3310.4
AutoPlaitMoCap0.750.750.750.7525.00.750.750.750.7525.0
AutoPlaitPUMP0.190.190.190.193160.190.190.190.19316
AutoPlaitSKAB0.180.180.180.181.50.180.180.180.181.5
AutoPlaitTSSB0.080.080.080.080.70.080.080.080.080.7
AutoPlaitUSC-HAD0.400.400.400.401550.400.400.400.40155
AutoPlaitUTSA0.170.170.170.172.20.170.170.170.172.2
AlgoDatasetDef.WorstMed.Tunedt~\tilde{t} [s]Def.WorstMed.Tunedt~\tilde{t} [s]
E2USDActRecTut0.530.490.540.5810.00.530.520.540.5910.0
E2USDHAS0.170.100.140.1812.10.330.310.320.3613.4
E2USDMoCap0.490.170.310.4914.30.470.290.380.4712.3
E2USDPUMP0.600.580.630.6617.80.610.590.630.6712.8
E2USDSKAB0.040.020.050.1415.10.030.010.030.1216.0
E2USDTSSB0.080.080.090.1317.60.180.170.180.2314.4
E2USDUSC-HAD0.440.100.270.4414.80.450.110.280.4515.1
E2USDUTSA0.060.020.050.0717.70.150.060.090.1612.7
HDP-HSMMActRecTut0.100.070.230.406.20.200.070.120.3314.9
HDP-HSMMHAS0.300.270.300.3218.70.430.370.420.443.9
HDP-HSMMMoCap0.450.430.470.566.30.530.390.490.5711.0
HDP-HSMMPUMP0.080.070.080.1012.70.080.080.080.0925.2
HDP-HSMMSKAB0.150.090.120.205.70.180.100.150.184.8
HDP-HSMMTSSB0.080.060.040.1615.10.170.150.130.194.8
HDP-HSMMUSC-HAD0.330.320.320.3811.00.330.320.320.379.9
HDP-HSMMUTSA0.190.130.170.2519.70.190.110.170.225.5
TICCActRecTut-----0.480.120.480.57134
TICCHAS-----0.540.280.450.5339.1
TICCMoCap-----0.580.270.490.60218
TICCPUMP-----0.680.690.690.691.8k
TICCSKAB-----0.270.250.280.3166.3
TICCTSSB-----0.150.140.140.2422.4
TICCUSC-HAD-----0.510.020.030.42900
TICCUTSA-----0.120.050.070.2812.4
Time2StateActRecTut0.630.440.540.6375.10.580.470.570.6426.8
Time2StateHAS0.160.110.130.1815.90.300.300.310.356.7
Time2StateMoCap0.530.180.360.5415.70.500.230.430.549.6
Time2StatePUMP0.550.530.610.6620.70.560.530.620.678.6
Time2StateSKAB0.040.010.050.1412.60.050.010.030.268.0
Time2StateTSSB0.110.060.090.1212.80.180.170.170.249.7
Time2StateUSC-HAD0.410.070.300.4315.40.460.080.340.4715.2
Time2StateUTSA0.060.020.040.0814.20.130.050.080.1411.9

Table 14 (PDF p. 53). SD methods, scored on the change points induced by their labels

Table 15: Main-pool SD algorithms: per-(algorithm, dataset) default / worst-case / median / tuned ARI, in both Non-Guided (NG) and Guided (G) modes. Same conventions as Table 13, with SMS replaced by ARI. The tuned configuration in this table is selected on ARI itself (not on SMS), so each table is self-contained.

AlgoDatasetDef.WorstMed.Tunedt~\tilde{t} [s]Def.WorstMed.Tunedt~\tilde{t} [s]
AutoPlaitActRecTut0.190.190.190.1947.40.190.190.190.1947.4
AutoPlaitHAS0.470.470.470.4710.40.470.470.470.4710.4
AutoPlaitMoCap0.800.800.800.8025.00.800.800.800.8025.0
AutoPlaitPUMP0.240.240.240.243160.240.240.240.24316
AutoPlaitSKAB0.380.380.380.381.50.380.380.380.381.5
AutoPlaitTSSB0.080.080.080.080.70.080.080.080.080.7
AutoPlaitUSC-HAD0.290.290.290.291550.290.290.290.29155
AutoPlaitUTSA0.220.220.220.222.20.220.220.220.222.2
CLAPActRecTut0.210.350.420.436230.380.320.340.44504
CLAPHAS0.590.470.540.6015.10.660.560.610.6913.4
CLAPMoCap0.590.560.670.6725.50.620.570.650.7125.9
CLAPPUMP0.120.020.100.133660.140.060.130.24550
CLAPSKAB0.010.000.000.012.20.380.060.170.384.7
CLAPTSSB0.730.710.770.759.40.810.800.830.825.7
CLAPUSC-HAD0.810.810.870.895000.710.710.750.76490
CLAPUTSA0.750.660.740.7527.50.910.820.900.9118.4
AlgoDatasetNon-Guided Def.Non-Guided WorstNon-Guided Med.Non-Guided TunedNon-Guided t~\tilde{t} [s]Guided Def.Guided WorstGuided Med.Guided TunedGuided t~\tilde{t} [s]
E2USDActRecTut0.620.580.670.7612.50.680.680.720.8015.2
E2USDHAS0.400.340.350.4012.70.570.540.560.5813.0
E2USDMoCap0.710.440.580.7212.30.610.480.570.6211.7
E2USDPUMP0.270.240.290.3517.80.280.240.310.3712.2
E2USDSKAB0.230.170.210.2715.10.280.250.310.3716.0
E2USDTSSB0.200.190.220.2617.40.270.260.280.3214.2
E2USDUSC-HAD0.660.500.590.6716.40.600.460.530.6214.9
E2USDUTSA0.300.220.270.3117.70.330.220.300.3912.7
HDP-HSMMActRecTut0.340.160.390.506.20.440.140.380.4415.1
HDP-HSMMHAS0.450.420.480.5019.90.550.480.530.554.0
HDP-HSMMMoCap0.470.410.510.616.30.520.370.470.5810.6
HDP-HSMMPUMP0.110.080.110.1113.20.110.100.110.1124.8
HDP-HSMMSKAB0.390.340.380.466.20.480.270.360.484.1
HDP-HSMMTSSB0.280.160.210.3216.70.280.200.230.294.8
HDP-HSMMUSC-HAD0.340.300.350.3723.20.330.300.340.359.0
HDP-HSMMUTSA0.400.380.430.5111.40.280.170.250.385.5
TICCActRecTut-----0.800.700.780.831.0k
TICCHAS-----0.640.520.600.6438.8
TICCMoCap-----0.740.530.610.73218
TICCPUMP-----0.500.490.500.502.0k
TICCSKAB-----0.520.490.560.5722.1
TICCTSSB-----0.080.080.100.2722.4
TICCUSC-HAD-----0.580.450.500.61716
TICCUTSA-----0.140.120.140.2512.4
Time2StateActRecTut0.660.570.680.7534.70.640.610.680.7812.7
Time2StateHAS0.370.330.350.3814.70.540.520.540.577.0
Time2StateMoCap0.790.470.700.8131.80.710.460.660.759.6
Time2StatePUMP0.310.270.340.4117.60.320.270.360.458.6
Time2StateSKAB0.220.210.250.3312.50.210.210.430.618.1
Time2StateTSSB0.270.120.230.3114.50.330.200.300.4310.2
Time2StateUSC-HAD0.700.570.650.7117.40.660.540.630.6816.2
Time2StateUTSA0.300.180.250.3313.20.410.200.330.4226.6

Table 15.

Table 16: Main-pool SD algorithms: per-(algorithm, dataset) default / worst-case / median / tuned WARI, in both Non-Guided (NG) and Guided (G) modes. Same conventions as Table 13, with SMS replaced by WARI. The tuned configuration in this table is selected on WARI itself (not on SMS), so each table is self-contained.

AlgoDatasetNon-Guided Def.Non-Guided WorstNon-Guided Med.Non-Guided TunedNon-Guided t~\tilde{t} [s]Guided Def.Guided WorstGuided Med.Guided TunedGuided t~\tilde{t} [s]
AutoPlaitActRecTut0.260.260.260.2647.40.260.260.260.2647.4
AutoPlaitHAS0.510.510.510.5110.40.510.510.510.5110.4
AutoPlaitMoCap0.890.890.890.8925.00.890.890.890.8925.0
AutoPlaitPUMP0.360.360.360.363160.360.360.360.36316
AutoPlaitSKAB0.570.570.570.571.50.570.570.570.571.5
AutoPlaitTSSB0.080.080.080.080.70.080.080.080.080.7
AutoPlaitUSC-HAD0.410.410.410.411550.410.410.410.41155
AutoPlaitUTSA0.210.210.210.212.20.210.210.210.212.2
CLaPActRecTut0.250.450.510.546230.460.350.420.60647
CLaPHAS0.640.520.600.6415.10.740.630.700.7613.4
CLaPMoCap0.700.660.790.7925.50.740.680.790.8225.9
CLaPPUMP0.180.030.140.203850.250.080.200.40550
CLaPSKAB0.020.000.000.022.20.540.100.280.544.7
CLaPTSSB0.770.740.810.798.30.860.850.870.865.7
CLaPUSC-HAD0.890.890.940.955000.820.820.850.85490
CLaPUTSA0.790.680.800.7927.40.950.850.940.9518.4
AlgoDatasetNon-Guided Def.Non-Guided WorstNon-Guided Med.Non-Guided TunedNon-Guided t~\tilde{t} [s]Guided Def.Guided WorstGuided Med.Guided TunedGuided t~\tilde{t} [s]
E2USDActRecTut0.710.680.730.7612.50.850.780.850.8715.2
E2USDHAS0.440.350.380.4412.70.640.570.610.6413.3
E2USDMoCap0.840.470.660.8512.30.700.510.640.7310.2
E2USDPUMP0.320.280.330.3718.10.330.280.340.4012.2
E2USDSKAB0.380.240.320.3815.60.450.440.490.5316.0
E2USDTSSB0.250.220.270.3217.40.310.300.330.3815.3
E2USDUSC-HAD0.760.600.690.7614.80.710.550.630.7214.9
E2USDUTSA0.320.230.290.3317.70.390.250.360.4512.7
HDP-HSMMActRecTut0.470.160.480.796.20.620.100.480.6215.1
HDP-HSMMHAS0.500.470.530.5519.90.620.530.590.624.0
HDP-HSMMMoCap0.550.480.600.686.30.630.440.550.6710.6
HDP-HSMMPUMP0.150.120.150.1613.20.150.140.150.1624.8
HDP-HSMMSKAB0.570.480.590.656.20.620.330.510.624.1
HDP-HSMMTSSB0.360.200.270.4016.70.330.220.270.354.8
HDP-HSMMUSC-HAD0.470.400.480.5023.20.450.400.460.479.2
HDP-HSMMUTSA0.450.430.470.5711.40.310.150.270.425.5
TICCActRecTut-----0.820.660.790.931.0k
TICCHAS-----0.680.530.630.6938.8
TICCMoCap-----0.830.590.710.84218
TICCPUMP-----0.530.480.490.502.0k
TICCSKAB-----0.700.680.740.7422.1
TICCTSSB-----0.080.080.100.2922.4
TICCUSC-HAD-----0.680.520.580.72716
TICCUTSA-----0.160.130.160.2712.4
Time2StateActRecTut0.730.640.720.7834.70.740.730.770.8919.0
Time2StateHAS0.410.350.370.4314.70.610.580.600.646.8
Time2StateMoCap0.910.500.790.9231.80.820.480.750.8710.4
Time2StatePUMP0.390.340.420.4817.60.410.350.440.519.1
Time2StateSKAB0.340.290.350.4312.50.340.340.660.778.1
Time2StateTSSB0.320.140.260.3814.50.400.220.350.519.4
Time2StateUSC-HAD0.810.650.750.8128.10.790.640.740.7916.2
Time2StateUTSA0.340.200.280.3613.20.490.240.400.5026.6

Table 16.

Extended-scope pool. Additional metrics for the extended-scope algorithms are reported in the same spirit as Table 8-Table 9: only for the (algorithm, dataset, mode) cells they actually completed, and with the tuned configuration defined as the one maximising the table’s own metric.

AlgorithmDatasetSeriesCompl.gF1t~\tilde{t} [s]Compl.gF1t~\tilde{t} [s]Compl.gF1t~\tilde{t} [s]Compl.gF1t~\tilde{t} [s]
tGLADactrectut22/20.05367062/20.05339862/20.3698852/20.398928
has250206/2500.11288171/2500.103436/2500.1735.2171/2500.14323
mocap99/90.0573049/90.0552569/90.1817529/90.191735
pump12057/1200.03136755/1200.02157510/1200.49774112/1200.506669
skab3434/340.06132634/340.06130134/340.0930934/340.11317
tssb7575/750.0619175/750.0624075/750.0814775/750.0819.8
usc-had7044/700.01179642/700.01189110/700.2481537/700.2512580
utsa3232/320.0258532/320.0254832/320.0352232/320.0271.0
TS-CP²actrectut22/20.07109242/20.2010931------
has25032/2500.02172733/2500.161630------
mocap99/90.0431519/90.112516------
pump12010/1200.14813310/1200.178144------
skab3434/340.0223734/340.04245------
tssb7550/750.11122248/750.231166------
usc-had706/700.04141996/700.1513447------
utsa3220/320.01372820/320.153636------
EAggloactrectut20/2--0/2--------
has2508/2500.2633.88/2500.2633.4------
mocap99/90.231089/90.23105------
pump1209/1200.329959/1200.321036------
skab3434/340.006.934/340.003.7------
tssb7575/750.0122.375/750.0126.7------
usc-had700/70--0/70--------
utsa3228/320.0132028/320.01278------
BOCDactrectut20/2--0/2--------
has2508/2500.137188/2500.13738------
mocap99/90.0032139/90.003310------
pump1201/1200.00569121/1200.0065789------
skab3434/340.1463.534/340.1367.0------
tssb7528/750.0739128/750.07397------
usc-had700/70--0/70--------
utsa325/320.0014435/320.001494------
Hidalgoactrectut2---2/20.0010846---2/20.2216506
has250---8/2500.13757---8/2500.13776
mocap9---9/90.021855---9/90.032746
pump120---2/1200.0241896---2/1200.0633118
skab34---34/340.01151---34/340.02134
usc-had70---3/700.0024346---4/700.0118350

Table 17. Per-dataset coverage and score (Gaussian F1F_1) of the five extended-scope CPD algorithms. Tuned configurations are selected on Gaussian F1F_1.

AlgorithmDatasetSeriesCompl.ARIt~\tilde{t} [s]Compl.ARIt~\tilde{t} [s]Compl.ARIt~\tilde{t} [s]Compl.ARIt~\tilde{t} [s]
Hidalgoactrectut2---2/20.0710846---2/20.0710487
has250---8/2500.15757---8/2500.15731
mocap9---9/90.051855---9/90.051716
pump120---2/1200.0641896---1/1200.0672877
skab34---34/340.13151---34/340.14221
usc-had70---3/700.0724346---3/700.0723105

Table 18. Per-dataset coverage and score (ARI) of the SD-side extended-scope algorithm (Hidalgo). Tuned configurations are selected on ARI.

AlgorithmDatasetSeriesCompl.WARIt~\tilde{t} [s]Compl.WARIt~\tilde{t} [s]Compl.WARIt~\tilde{t} [s]Compl.WARIt~\tilde{t} [s]
Hidalgoactrectut2---2/20.0610846---2/20.0610487
has250---8/2500.15757---8/2500.15731
mocap9---9/90.061855---9/90.061716
pump120---2/1200.0541896---2/1200.0542438
skab34---34/340.17151---34/340.21221
usc-had70---3/700.0924346---3/700.0923105

Table 19. Per-dataset coverage and score (WARI) of the SD-side extended-scope algorithm (Hidalgo). Tuned configurations are selected on WARI.

References

  1. [1]Oscar D. Lara and Miguel A. Labrador. A survey on human activity recognition using wearable sensors. IEEE Communications Surveys & Tutorials, 15:1192–1209, 2013.
  2. [2]Ameeth Kanawaday and Aditya Sane. Machine learning for predictive maintenance of industrial machines using IoT sensor data. 2017 8th IEEE International Conference on Software Engineering and Service Science (ICSESS), pages 87–90, 2017.
  3. [3]J. H. Woollam, Jannes Münchmeyer, Frederik Tilmann, Andreas Rietbrock, Dietrich Lange, Thomas Bornstein, Tobias Diehl, Carlo Giunchi, Florian Haslinger, Dario Jozinović, Alberto Michelini, Joachim Saul, and Hugo Soto. SeisBench—a toolbox for machine learning in seismology. Seismological Research Letters, 2022.arxiv.org/abs/2111.00786
  4. [4]Arik Ermshaus, Patrick Schäfer, and Ulf Leser. ClaSP: parameter-free time series segmentation. Data Mining and Knowledge Discovery, 37:1262 – 1300, 2023.DOI
  5. [5]John Paparrizos, Ryen W White, and Eric Horvitz. Screening for pancreatic adenocarcinoma using signals from web search logs: Feasibility study and results. Journal of oncology practice, 12(8):737–744, 2016.DOI
  6. [6]Ioannis Paparrizos. Fast, scalable, and accurate algorithms for time-series analysis. PhD thesis, Columbia University, 2018.DOI
  7. [7]John Paparrizos, Ryen W White, and Eric Horvitz. Detecting devastating diseases in search logs. In Proceedings of the 22nd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, pages 559–568, 2016.DOI
  8. [8]Shinan Liu, Tarun Mangla, Ted Shaowang, Jinjing Zhao, John Paparrizos, Sanjay Krishnan, and Nick Feamster. Amir: Active multimodal interaction recognition from video and network traffic in connected environments. Proceedings of the ACM on Interactive, Mobile, Wearable and Ubiquitous Technologies, 7(1):1–26, 2023.
  9. [9]Chunwei Liu, Hao Jiang, John Paparrizos, and Aaron J Elmore. Decomposed bounded floats for fast compression and queries. Proceedings of the VLDB Endowment, 14(11):2586–2598, 2021.DOI
  10. [10]Chunwei Liu, John Paparrizos, and Aaron J Elmore. Adaedge: A dynamic compression selection framework for resource constrained devices. In 2024 IEEE 40th International Conference on Data Engineering (ICDE), pages 1506–1519. IEEE, 2024.DOI
  11. [11]Kathy McKeown, Hal Daume III, Sngidha Chaturvedi, John Paparrizos, Kapil Thadani, Pablo Barrio, Or Brian, Suvarna Bothe, Michael Collins, Kenneth R Fleischmann, et al. Predicting the impact of scientific concepts using full-text features. Journal of the Association for Information Science and Technology, 67(11):2684–2696, 2016.DOI
  12. [12]John Paparrizos, Chunwei Liu, Bruno Barbarioli, Johnny Hwang, Ikraduya Edian, Aaron J Elmore, Michael J Franklin, and Sanjay Krishnan. Vergedb: A database for iot analytics on edge devices. In CIDR, 2021.
  13. [13]Rahul Goel, Sandeep Soni, Naman Goyal, John Paparrizos, Hanna Wallach, Fernando Diaz, and Jacob Eisenstein. The social dynamics of language change in online networks. In International conference on social informatics, pages 41–57. Springer, 2016.arxiv.org/abs/1609.02075
  14. [14]Sanjay Krishnan, Aaron J Elmore, Michael Franklin, John Paparrizos, Zechao Shang, Adam Dziedzic, and Rui Liu. Artificial intelligence in resource-constrained and shared environments. ACM SIGOPS Operating Systems Review, 53(1):1–6, 2019.DOI
  15. [15]Hao Jiang, Chunwei Liu, Qi Jin, John Paparrizos, and Aaron J Elmore. Pids: attribute decomposition for improved compression and query performance in columnar storage. Proceedings of the VLDB Endowment, 13(6):925–938, 2020.DOI
  16. [16]Hao Jiang, Chunwei Liu, John Paparrizos, Andrew A Chien, Jihong Ma, and Aaron J Elmore. Good to the last bit: Data-driven encoding with codecb. In Proceedings of the 2021 International Conference on Management of Data, pages 843–856, 2021.DOI
  17. [17]Adam Dziedzic, John Paparrizos, Sanjay Krishnan, Aaron Elmore, and Michael Franklin. Band-limited training and inference for convolutional neural networks. In International Conference on Machine Learning, pages 1745–1754. PMLR, 2019.arxiv.org/abs/1911.09287
  18. [18]John Paparrizos, Kaize Wu, Aaron Elmore, Christos Faloutsos, and Michael J Franklin. Accelerating similarity search for elastic measures: A study and new generalization of lower bounding distances. Proceedings of the VLDB Endowment, 16(8):2019–2032, 2023.DOI
  19. [19]John Paparrizos, Chunwei Liu, Aaron J Elmore, and Michael J Franklin. Querying time-series data: A comprehensive comparison of distance measures. Data Engineering, page 69, 2023.
  20. [20]John Paparrizos, Ikraduya Edian, Chunwei Liu, Aaron J Elmore, and Michael J Franklin. Fast adaptive similarity search through variance-aware quantization. In 2022 IEEE 38th International Conference on Data Engineering (ICDE), pages 2969–2983. IEEE, 2022.DOI
  21. [21]Hoyoung Jeung, Sofiane Sarni, Ioannis Paparrizos, Saket Sathe, Karl Aberer, Nicholas Dawes, Thanasis G Papaioannou, and Michael Lehning. Effective metadata management in federated sensor networks. In 2010 IEEE International Conference on Sensor Networks, Ubiquitous, and Trustworthy Computing, pages 107–114. IEEE, 2010.
  22. [22]Ioannis Paparrizos, Hoyoung Jeung, and Karl Aberer. Advanced search, visualization and tagging of sensor metadata. In 2011 IEEE 27th International Conference on Data Engineering, pages 1356–1359. IEEE, 2011.DOI
  23. [23]Kaisei Hishida, Chunwei Liu, John Paparrizos, and Aaron Elmore. Beyond compression: A comprehensive evaluation of lossless floating-point compression. Proceedings of the VLDB Endowment, 18(11):4396–4409, 2025.DOI
  24. [24]Jens E d’Hondt, Odysseas Papapetrou, and John Paparrizos. Beyond the dimensions: A structured evaluation of multivariate time series distance measures. In 2024 IEEE 40th International Conference on Data Engineering Workshops (ICDEW), pages 107–112. IEEE, 2024.DOI
  25. [25]Patrick Schäfer. The BOSS is concerned with time series classification in the presence of noise. Data Min. Knowl. Discov., 29(6):1505–1530, November 2015. ISSN 1384-5810. doi: 10.1007/s10618-014-0377-7. URL https://doi.org/10.1007/s10618-014-0377-7.
  26. [26]Patrick Schäfer and Ulf Leser. Fast and accurate time series classification with WEASEL. In Proceedings of the 2017 ACM on Conference on Information and Knowledge Management, CIKM ’17. ACM, November 2017. doi: 10.1145/3132847.3132980. URL http://dx.doi.org/10.1145/3132847.3132980.
  27. [27]Jason Lines, Sarah Taylor, and Anthony Bagnall. HIVE-COTE: The hierarchical vote collective of transformation-based ensembles for time series classification. In 2016 IEEE 16th International Conference on Data Mining (ICDM), pages 1041–1046, 2016. doi: 10.1109/ICDM.2016.0133.DOI
  28. [28]Matthew Middlehurst, Patrick Schäfer, and Anthony Bagnall. Bake off redux: a review and experimental evaluation of recent time series classification algorithms. Data Mining and Knowledge Discovery, 38(4):1958–2031, 2024.DOI
  29. [29]John Paparrizos and Luis Gravano. k-Shape: Efficient and accurate clustering of time series. In Proceedings of the 2015 ACM SIGMOD International Conference on Management of Data, pages 1855–1870. ACM, 2015.
  30. [30]John Paparrizos, Fan Yang, and Haojun Li. Bridging the gap: A decade review of time-series clustering methods. arXiv preprint arXiv:2412.20582, 2024.arxiv.org/abs/2412.20582
  31. [31]John Paparrizos and Michael J Franklin. GRAIL: efficient time-series representation learning. Proceedings of the VLDB Endowment, 12(11):1762–1777, 2019.DOI
  32. [32]Paul Boniol, Qinghua Liu, Mingyi Huang, Themis Palpanas, and John Paparrizos. Dive into time-series anomaly detection: A decade review, 2024. URL https://arxiv.org/abs/2412.20512.
  33. [33]John Paparrizos, Yuhao Kang, Paul Boniol, Ruey S Tay, Themis Palpanas, and Michael J Franklin. TSB-UAD: an end-to-end benchmark suite for univariate time-series anomaly detection. Proceedings of the VLDB Endowment, 15(8):1697–1711, 2022.DOI
  34. [34]Qinghua Liu and John Paparrizos. The elephant in the room: Towards a reliable time-series anomaly detection benchmark. Advances in Neural Information Processing Systems, 37: 108231–108261, 2024.DOI
  35. [35]Pavel Senin, Jessica Lin, Xing Wang, Tim Oates, Sunil Gandhi, Arnold P Boedihardjo, Crystal Chen, Susan Frankenstein, and Manfred Lerner. GrammarViz 2.0: a tool for grammar-based pattern discovery in time series. In Machine Learning and Knowledge Discovery in Databases: European Conference, ECML PKDD 2014, Nancy, France, September 15-19, 2014. Proceedings, Part III 14, pages 468–472. Springer, 2014.DOI
  36. [36]John Paparrizos, Paul Boniol, Themis Palpanas, Ruey S Tay, Aaron Elmore, and Michael J Franklin. Volume under the surface: a new accuracy evaluation measure for time-series anomaly detection. Proceedings of the VLDB Endowment, 15(11):2774–2787, 2022.DOI
  37. [37]Paul Boniol and Themis Palpanas. Series2Graph: graph-based subsequence anomaly detection for time series. Proc. VLDB Endow., 13(12):1821–1834, July 2020. ISSN 2150-8097. doi: 10.14778/3407790.3407792. URL https://doi.org/10.14778/3407790.3407792.
  38. [38]Jessica Lin, Eamonn Keogh, Stefano Lonardi, and Bill Chiu. A symbolic representation of time series, with implications for streaming algorithms. In Proceedings of the 8th ACM SIGMOD workshop on Research issues in data mining and knowledge discovery, pages 2–11, 2003.
  39. [39]Jin Shieh and Eamonn Keogh. iSAX: indexing and mining terabyte sized time series. In Proceedings of the 14th ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, KDD ’08, page 623–631, New York, NY, USA, 2008. Association for Computing Machinery. ISBN 9781605581934. doi: 10.1145/1401890.1401966. URL https://doi.org/10.1145/1401890.1401966.
  40. [40]Patrick Schäfer and Mikael Högqvist. SFA: a symbolic Fourier approximation and index for similarity search in high dimensional datasets. In Proceedings of the 15th International Conference on Extending Database Technology, EDBT ’12, page 516–527, New York, NY, USA, 2012. Association for Computing Machinery. ISBN 9781450307901. doi: 10.1145/2247596.2247656. URL https://doi.org/10.1145/2247596.2247656.
  41. [41]John Paparrizos, Haojun Li, Fan Yang, Kaize Wu, Jens E d’Hondt, and Odysseas Papapetrou. A survey on time-series distance measures. arXiv preprint arXiv:2412.20574, 2024.arxiv.org/abs/2412.20574
  42. [42]Jens E d’Hondt, Haojun Li, Fan Yang, Odysseas Papapetrou, and John Paparrizos. A structured study of multivariate time-series distance measures. In Proceedings of the 2025 ACM SIGMOD international conference on management of data, 2025.DOI
  43. [43]Yuan Li, Jessica Lin, and Tim Oates. Visualizing variable-length time series motifs. In Proceedings of the 2012 SIAM International Conference on Data Mining (SDM), pages 895–906. SIAM, 2012. doi: 10.1137/1.9781611972825.77.DOI
  44. [44]Len Feremans, Patrick Schäfer, and Wannes Meert. MotiPlus and MotiSet: Discovering the best set of motiflets in time series. In Joint European Conference on Machine Learning and Knowledge Discovery in Databases, pages 473–489. Springer, 2025.DOI
  45. [45]Fan Yang and John Paparrizos. SPARTAN: Data-adaptive symbolic time-series approximation. Proc. ACM Manag. Data, 3(3), June 2025. doi: 10.1145/3725357. URL https://doi.org/10.1145/3725357.
  46. [46]Fan Yang and John Paparrizos. SAIL: A voyage to symbolic approximation solutions for time-series analysis. Proceedings of the VLDB Endowment, 18(12):5419–5422, 2025.DOI
  47. [47]Yuqi Nie, Nam H. Nguyen, Phanweadee Sinthong, and Jayanth Kalagnanam. A time series is worth 64 words: Long-term forecasting with transformers. In International Conference on Learning Representations, 2023.arxiv.org/abs/2211.14730
  48. [48]Abdul Fatir Ansari, Lorenzo Stella, Caner Turkmen, Xiyuan Zhang, Pedro Mercado, Huibin Shen, Oleksandr Schhur, Syama Syndar Rangapuram, Sebastian Pineda Arango, Shubham Kapoor, Jasper Zschiegner, Danielle C. Maddix, Hao Wang, Michael W. Mahoney, Kari Torkkola, Andrew Gordon Wilson, Michael Bohlke-Schneider, and Yuyang Wang. Chronos: Learning the language of time series. arXiv preprint arXiv:2403.07815, 2024.arxiv.org/abs/2403.07815
  49. [49]Haoxin Liu, Shangqing Xu, Zhiyuan Zhao, Lingkai Kong, Harshavardhan Prabhakar Kamarthi, Aditya Sasnur, Megha Sharma, Jiaming Cui, Qingsong Wen, Chao Zhang, et al. Time-MMD: Multi-domain multimodal dataset for time series analysis. Advances in Neural Information Processing Systems, 37:77888–77933, 2024.arxiv.org/abs/2406.08627
  50. [50]Haoxin Liu, Zhiyuan Zhao, Jindong Wang, Harshavardhan Kamarthi, and B. Aditya Prakash. LSTPrompt: Large language models as zero-shot time series forecasters by long-short-term prompting. In Lun-Wei Ku, Andre Martins, and Vivek Srikumar, editors, Findings of the Association for Computational Linguistics: ACL 2024, pages 7832–7840, Bangkok, Thailand, August 2024. Association for Computational Linguistics. doi: 10.18653/v1/2024.findings-acl.466. URL https://aclanthology.org/2024.findings-acl.466/.DOI
  51. [51]Haoxin Liu, Harshavardhan Kamarthi, Lingkai Kong, Zhiyuan Zhao, Chao Zhang, and B. Aditya Prakash. Time-series forecasting for out-of-distribution generalization using invariant learning. In Ruslan Salakhutdinov, Zico Kolter, Katherine Heller, Adrian Weller, Nuria Oliver, Jonathan Scarlett, and Felix Berkenkamp, editors, Proceedings of the 41st International Conference on Machine Learning, volume 235 of Proceedings of Machine Learning Research, pages 31312–31325. PMLR, 21–27 Jul 2024. URL https://proceedings.mlr.press/v235/liu24ae.html.arxiv.org/abs/2406.09130
  52. [52]Haoxin Liu, Zhiyuan Zhao, Shiduo Li, and B Aditya Prakash. Evaluating system 1 vs. 2 reasoning approaches for zero-shot time-series forecasting: A benchmark and insights. arXiv preprint arXiv:2503.01895, 2025.arxiv.org/abs/2503.01895
  53. [53]Zhiyuan Zhao, Alexander Rodriguez, and B Aditya Prakash. Performative time-series forecasting. arXiv preprint arXiv:2310.06077, 2023.arxiv.org/abs/2310.06077
  54. [54]Zhiyuan Zhao, Haoxin Liu, and B Aditya Prakash. Tackling time-series forecasting generalization via mitigating concept drift. arXiv preprint arXiv:2510.14814, 2025.arxiv.org/abs/2510.14814
  55. [55]Zhiyuan Zhao, Juntong Ni, Shangqing Xu, Haoxin Liu, Wei Jin, and B Aditya Prakash. TimeRecipe: A time-series forecasting recipe via benchmarking module level effectiveness. arXiv preprint arXiv:2506.06482, 2025.arxiv.org/abs/2506.06482
  56. [56]Paul Boniol, John Paparrizos, Themis Palpanas, and Michael J Franklin. Sand: Streaming subsequence anomaly detection. Proc. VLDB Endow., 14(10):1717–1729, 2021.DOI
  57. [57]Paul Boniol, John Paparrizos, Themis Palpanas, and Michael J Franklin. Sand in action: Subsequence anomaly detection for streams. Proc. VLDB Endow., 14(12):2867–2870, 2021.DOI
  58. [58]John Paparrizos, Chunwei Liu, Aaron J Elmore, and Michael J Franklin. Debunking four long-standing misconceptions of time-series distance measures. In Proceedings of the 2020 ACM SIGMOD International Conference on Management of Data, pages 1887–1905, 2020.DOI
  59. [59]John Paparrizos and Luis Gravano. Fast and accurate time-series clustering. ACM Transactions on Database Systems (TODS), 42(2):1–49, 2017.DOI
  60. [60]Qinghua Liu, Paul Boniol, Themis Palpanas, and John Paparrizos. Time-series anomaly detection: Overview and new trends. Proceedings of the VLDB Endowment (PVLDB), 17(12): 4229–4232, 2024.DOI
  61. [61]Emmanouil Sylligardos, Paul Boniol, John Paparrizos, Panos E. Trahanias, and Themis Palpanas. Choose wisely: An extensive evaluation of model selection for anomaly detection in time series. Proc. VLDB Endow., 16(11):3418–3432, 2023.DOI
  62. [62]Emmanouil Sylligardos, John Paparrizos, Themis Palpanas, Pierre Senellart, and Paul Boniol. Msad: A deep dive into model selection for time series anomaly detection. The VLDB Journal, 34(6):1–25, 2025.DOI
  63. [63]Paul Boniol, Emmanouil Sylligardos, John Paparrizos, Panos Trahanias, and Themis Palpanas. Adecimo: Model selection for time series anomaly detection. In 2024 IEEE 40th International Conference on Data Engineering (ICDE), pages 5441–5444. IEEE, 2024.DOI
  64. [64]Paul Boniol, Ashwin K Krishna, Marine Bruel, Qinghua Liu, Mingyi Huang, Themis Palpanas, Ruey S Tsay, Aaron Elmore, Michael J Franklin, and John Paparrizos. Vus: effective and efficient accuracy measures for time-series anomaly detection. The VLDB Journal, 34(3):32, 2025.arxiv.org/abs/2502.13318
  65. [65]John Paparrizos, Paul Boniol, Qinghua Liu, and Themis Palpanas. Advances in time-series anomaly detection: Algorithms, benchmarks, and evaluation measures. In Proceedings of the 31st ACM SIGKDD Conference on Knowledge Discovery and Data Mining V. 2, pages 6151–6161, 2025.DOI
  66. [66]John Paparrizos and Sai Prasanna Teja Reddy Bogireddy. Time-series clustering: A comprehensive study of data mining, machine learning, and deep learning methods. Proceedings of the VLDB Endowment, 18(11):4380–4395, 2025.
  67. [67]John Paparrizos and Sai Prasanna Teja Reddy. Odyssey: An engine enabling the time-series clustering journey. Proceedings of the VLDB Endowment, 16(12):4066–4069, 2023.DOI
  68. [68]Paul Boniol, John Paparrizos, Yuhao Kang, Themis Palpanas, Ruey S Tsay, Aaron J Elmore, and Michael J Franklin. Theseus: Navigating the labyrinth of time-series anomaly detection. Proc. VLDB Endow., 15(12):3702–3705, 2022.DOI
  69. [69]Paul Boniol, John Paparrizos, and Themis Palpanas. New trends in time series anomaly detection. In EDBT, pages 847–850, 2023.DOI
  70. [70]Mohini Bariya, Alexandra von Meier, John Paparrizos, and Michael J Franklin. k-shapestream: Probabilistic streaming clustering for electric grid events. In 2021 IEEE Madrid PowerTech, pages 1–6. IEEE, 2021.DOI
  71. [71]Qinghua Liu, Seunghak Lee, and John Paparrizos. Easyad: A demonstration of automated solutions for time-series anomaly detection. Proceedings of the VLDB Endowment, 18(12): 5431–5434, 2025.DOI
  72. [72]Qinghua Liu, Sam Heshmati, Zheda Mai, Zubin Abraham, John Paparrizos, and Liu Ren. Mllm4ts: Leveraging vision and multimodal language models for general time-series analysis. arXiv preprint arXiv:2510.07513, 2025.arxiv.org/abs/2510.07513
  73. [73]Qinghua Liu, Seunghak Lee, and John Paparrizos. Tsb-autoad: Towards automated solutions for time-series anomaly detection. Proceedings of the VLDB Endowment, 18(11):4364–4379, 2025.DOI
  74. [74]Paul Boniol, John Paparrizos, and Themis Palpanas. An interactive dive into time-series anomaly detection. In 2024 IEEE 40th International Conference on Data Engineering (ICDE), pages 5382–5386. IEEE, 2024.DOI
  75. [75]Apostolos Giannoulidis, Anastasios Gounaris, and John Paparrizos. Burst: Rendering clustering techniques suitable for evolving streams. Proceedings of the VLDB Endowment, 18(11): 4054–4063, 2025.DOI
  76. [76]Anastasios Papadopoulos, Apostolos Giannoulidis, Anastasios Gounaris, and John Paparrizos. The power of anomaly detection in predictive maintenance: [experiments & analysis]. Proceedings of the ACM on Management of Data, 4(3 (SIGMOD):1–33, 2026.DOI
  77. [77]Mingyi Huang, Qinghua Liu, Paul Boniol, and John Paparrizos. Hydra: A multi-level hierarchy-driven approach for robust anomaly detection in time series. Proceedings of the ACM on Management of Data, 4(3 (SIGMOD):1–30, 2026.DOI
  78. [78]Mingyi Huang, Qinghua Liu, Paul Boniol, and John Paparrizos. Glassboxad: An interactive system for dissecting hierarchical time-series anomaly detection. In Companion of the International Conference on Management of Data, pages 46–49, 2026.DOI
  79. [79]John Paparrizos, Paul Boniol, Qinghua Liu, and Themis Palpanas. A comprehensive guide to time-series anomaly detection. In Proceedings of the Nineteenth ACM International Conference on Web Search and Data Mining, pages 1363–1366, 2026.DOI
  80. [80]Haojun Li and John Paparrizos. Mufasa: Fast and accurate multivariate time-series clustering. Proceedings of the ACM on Management of Data, 4(3 (SIGMOD):1–29, 2026.DOI
  81. [81]Gerardo Pastrana, Haojun Li, Dhruv Mehta, Anoushka Vyas, Sina Khoshfetrat Pakazad, Henrik Ohlsson, and John Paparrizos. Red-bench: Benchmarking historical instance retrieval for time-series diagnosis. arXiv preprint arXiv:2609.32123, 2026.arxiv.org/abs/2609.32123
  82. [82]Jie Yin, Qiang Yang, and Jeffrey Junfeng Pan. Sensor-based abnormal human-activity detection. IEEE Transactions on Knowledge and Data Engineering, 20:1082–1090, 2008.DOI
  83. [83]Faicel Chamroukhi, Samer Mohammed, Dorra Trabelsi, Latifa Oukhellou, and Yacine Amirat. Joint segmentation of multivariate time series with hidden process regression for human activity recognition. Neurocomputing, 120:633–644, 2013. ISSN 09252312. doi: 10.1016/j.neucom.2013.04.003. URL http://arxiv.org/abs/1312.6956.
  84. [84]Arik Ermshaus, Patrick Schäfer, Anthony Bagnall, Thomas Guyet, Georgiana Ifrim, Vincent Lemaire, Ulf Leser, Colin Leverger, and Simon Malinowski. Human activity segmentation challenge @ ECML/PKDD’23. In 8th Workshop on Advanced Analytics and Learning on Temporal Data, 2023.DOI
  85. [85]Minh-Quang Tran, Hoang-Phuong Doan, Viet Q. Vu, and Lien T. Vu. Machine learning and IoT-based approach for tool condition monitoring: A review and future prospects. Measurement, 2022.
  86. [86]Bob Kemp, Aeilko H. Zwinderman, Bert Tuk, Hilbert A. C. Kamphuisen, and Josefien J. L. Oberye. Analysis of a sleep-dependent neuronal feedback loop: the slow-wave microcontinuity of the EEG. IEEE Transactions on Biomedical Engineering, 47:1185–1194, 2000.pubmed.ncbi.nlm.nih.gov/11008419
  87. [87]Arik Ermshaus, Patrick Schäfer, and Ulf Leser. Raising the ClaSS of streaming time series segmentation. Proceedings of the VLDB Endowment, 17(8):1953–1966, 2024.DOI
  88. [88]Charles Truong, Laurent Oudre, and Nicolas Vayatis. Selective review of offline change point detection methods. Signal Processing, 167:107299, 2020.DOI
  89. [89]Samaneh Aminikhanghahi and Diane J Cook. A survey of methods for time series change point detection. KAIS, 51(2):339–367, 2017.DOI
  90. [90]Chengyu Wang, Kui Wu, Tongqing Zhou, and Zhiping Cai. Time2State: An unsupervised framework for inferring the latent states in time series data. Proceedings of the ACM on Management of Data, 1:1 – 18, 2023.DOI
  91. [91]Zhichen Lai, Huan Li, Dalin Zhang, Yan Zhao, Weizhu Qian, and Christian S. Jensen. E2USD: Efficient-yet-effective unsupervised state detection for multivariate time series. Proceedings of the ACM Web Conference 2024, 2024.arxiv.org/abs/2402.14041
  92. [92]Gerrit JJ van den Burg and Christopher KI Williams. An evaluation of change point detection algorithms. arXiv, 2020.arxiv.org/abs/2003.06222
  93. [93]Arik Ermshaus, Patrick Schäfer, and Ulf Leser. CLAp - state detection from time series. Proceedings of the VLDB Endowment, 19(1):70 – 83, 2025.arxiv.org/abs/2504.01783
  94. [94]Shaghayegh Gharghabi, Chin-Chia Michael Yeh, Yifei Ding, Wei Ding, Paul R. Hibbинг, Samuel R LaMunion, Andrew Kaplan, Scott E. Crouter, and Eamonn J. Keogh. Domain agnostic online semantic segmentation for multi-dimensional time series. Data Mining and Knowledge Discovery, 33:96 – 130, 2019.DOI
  95. [95]Iurii D. Katser and Vyacheslav O. Kozitsin. Skoltech anomaly benchmark (SKAB), 2020.
  96. [96]Félix Chavelli, Arik Ermshaus, Fan Yang, Patrick Schäfer, John Paparrizos, and Paul Boniol. tsseg: An interactive toolkit for time series segmentation. In Machine Learning and Knowledge Discovery in Databases. Applied Data Science Track, Demo Track and Industrial Track, Lecture Notes in Computer Science, pages 391–394. Springer Nature Switzerland, 2026. doi: 10.1007/978-3-032-37685-5_41.DOI
  97. [97]Félix Chavelli, Paul Boniol, and Michael Th омazo. Toward interpretable evaluation measures for time series segmentation. In The Thirty-ninth Annual Conference on Neural Information Processing Systems, 2025. URL https://openreview.net/forum?id=Gz6dujD5jO.arxiv.org/abs/2510.23261
  98. [98]Chengyu Wang, Xionglve Li, Tongqing Zhou, and Zhiping Cai. Unsupervised time series segmentation: A survey on recent advances. Computers, Materials & Continua, 2024.DOI
  99. [99]Michèle Basseville and Igor V Nikiforov. Detection of Abrupt Changes: Theory and Application. Prentice Hall, Englewood Cliffs, NJ, 1993.
  100. [100]Yang Cao, Ye Zhu, Kai Ming Ting, Flora D. Salim, Hong Xian Li, Luxing Yang, and Gang Li. Detecting change intervals with isolation distributional kernel. J. Artif. Intell. Res., 79:273–306, 2024. doi: 10.1613/jair.1.15762.DOI
  101. [101]Hai-Long Nguyen, Yew-Kwong Woon, and Wee-Keong Ng. A Survey on Data Stream Clustering and Classification. KAIS, 45(3):535–569, 2015.DOI
  102. [102]Matthew Middlehurst, Ali Ismail-Fawaz, Antoine Guillaume, Christopher Holder, David Guijo-Rubio, Guzal Bulatova, Leonidas Tsaprounis, Lukasz Mentel, Martin Walter, Patrick Schäfer, and Anthony Bagnall. aeon: a Python toolkit for learning from time series. Journal of Machine Learning Research, 25(289):1–10, 2024. URL http://jmlr.org/papers/v25/23-1444.html.arxiv.org/abs/2406.14231
  103. [103]Markus Löning, Anthony J. Bagnall, Sajaysurya Ganesh, Viktor Kazakov, Jason Lines, and Franz J. Király. sktime: A unified interface for machine learning with time series. CoRR, abs/1909.07872, 2019. URL http://arxiv.org/abs/1909.07872.
  104. [104]Rebecca Killick and Idris A. Eckley. changepoint: An R package for changepoint analysis. Journal of Statistical Software, 58(3):1–19, 2014. doi: 10.18637/jss.v058.i03. URL https://www.jstatsoft.org/index.php/jss/article/view/v058i03.DOI
  105. [105]J. Takeuchi and K. Yamanishi. A unifying framework for detecting outliers and change points from time series. IEEE Transactions on Knowledge and Data Engineering, 18(4):482–492, 2006. doi: 10.1109/TKDE.2006.1599387.DOI
  106. [106]Shohreh Deldari, Daniel V. Smith, Amin Sadri, and Flora D. Salim. ESPRESSO: Entropy and shape aware time-series segmentation for processing heterogeneous sensor data. Proc. ACM Interact. Mob. Wearable Ubiquitous Technol., 4:77:1–77:24, 2020.DOI
  107. [107]Tim De Ryck, Maarten de Vos, and Alexander Bertrand. Change point detection in time series data using autoencoders with a time-invariant representation. IEEE Transactions on Signal Processing, 69:3513–3524, 2021.
  108. [108]Shohreh Deldari, Daniel V. Smith, Hao Xue, and Flora Dilys Salim. Time series change point detection with self-supervised contrastive predictive coding. Proceedings of the Web Conference 2021, 2021.
  109. [109]Shima Imani and Harsh Shrivastava. tGLAD: A sparse graph recovery based approach for multivariate time series segmentation. In AALTĐ@ECML/PKDD, 2023.DOI
  110. [110]Eamonn Keogh, Selina Chu, David Hart, and Michael Pazzani. An online algorithm for segmenting time series. In Proceedings 2001 IEEE international conference on data mining, pages 289–296. IEEE, 2001.
  111. [111]David S. Matteson and Nicholas A. James. A nonparametric approach for multiple change point analysis of multivariate data. Journal of the American Statistical Association, 109:334 – 345, 2014.arxiv.org/abs/1306.4933
  112. [112]A. J. Scott and Martin Knott. A cluster analysis method for grouping means in the analysis of variance. Biometries, pages 507–512, 1974.
  113. [113]David Hallac, Peter Nystrup, and Stephen P. Boyd. Greedy Gaussian segmentation of multivariate time series. Advances in Data Analysis and Classification, 13:727 – 751, 2019.arxiv.org/abs/1610.07435
  114. [114]Amin Sadri, Yongli Ren, and Flora D. Salim. Information gain-based metric for recognizing transitions in human activities. Pervasive and Mobile Computing, 38:92–109, 2017. ISSN 1574-1192. doi: 10.1016/j.pmcj.2017.01.003. URL https://www.sciencedirect.com/science/article/pii/S1574119217300081.DOI
  115. [115]Sean J Taylor and Benjamin Letham. Forecasting at scale. The American Statistician, 72(1):37–45, 2018.DOI
  116. [116]David V. Hinkley. Inference about the change-point in a sequence of random variables. Biometrika, 57(1):1–17, 1970. ISSN 00063444, 14643510. URL http://www.jstor.org/stable/2334932.
  117. [117]Rebecca Killick, Paul Fearnhead, and Idris A. Eckley. Optimal detection of changepoints with a linear computational cost. Journal of the American Statistical Association, 107:1590 – 1598, 2012.DOI
  118. [118]Ryan Prescott Adams and David JC MacKay. Bayesian online changepoint detection. arXiv preprint arXiv:0710.3742, 2007.
  119. [119]Yasuko Matsubara, Yasushi Sakurai, and Christos Faloutsos. AutoPlait: automatic mining of co-evolving time sequences. Proceedings of the 2014 ACM SIGMOD International Conference on Management of Data, 2014.DOI
  120. [120]Matthew J. Johnson and Alan S. Willsky. Bayesian nonparametric hidden semi-Markov models. Journal of Machine Learning Research, 14:673–701, 2013.arxiv.org/abs/1203.1365
  121. [121]David Hallac, Sagar Vare, Stephen P. Boyd, and Jure Leskovec. Toeplitz inverse covariance-based clustering of multivariate time series data. Proceedings of the 23rd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, 2017.arxiv.org/abs/1706.03161
  122. [122]Michele Allegra, Elena Facco, Francesco Denti, Alessandro Laio, and Antonietta Mira. Data segmentation based on the local intrinsic dimension. Scientific Reports, 10:16449, 2020. doi: 10.1038/s41598-020-72222-0.DOI
  123. [123]Attila Reiss and Didier Stricker. Introducing a new benchmarked dataset for activity monitoring. 2012 16th International Symposium on Wearable Computers, pages 108–109, 2012.DOI
  124. [124]Andreas Bulling, Ulf Blanke, and Bernt Schiele. A tutorial on human activity recognition using body-worn inertial sensors. ACM Computing Surveys, 46(3):31:1–33:3, 2014. ISSN 0360-0300. URL https://github.com/andyknownasabu/ActRecTut.DOI
  125. [125]Carnegie Mellon University. The CMU Graphics Lab Motion Capture Database. In CMU Graphics Lab, 2003. http://mocap.cs.cmu.edu.
  126. [126]Mi Zhang and Alexander A. Sawchuk. USC-HAD: a daily activity dataset for ubiquitous activity recognition using wearable sensors. Proceedings of the 2012 ACM Conference on Ubiquitous Computing, 2012.
  127. [127]Stefan Gaugel and Manfred Reichert. PrecTime: A deep learning architecture for precise time series segmentation in industrial manufacturing operations. Engineering Applications of Artificial Intelligence, 122:106078, June 2023. ISSN 0952-1976. doi: 10.1016/j.engappai.2023.106078. URL http://dx.doi.org/10.1016/j.engappai.2023.106078.
  128. [128]Rebecca Salles, Janio Lima, Michel Reis, Rafaelli Coutinho, Esther Pacitti, Florent Masseglia, Reza Akbarinia, Chao Chen, Jonathan Garibaldi, Fabio Porto, and Eduardo Ogasawara. SoftED: Metrics for soft evaluation of time series event detection. Computers & Industrial Engineering, 198:110728, 2024. ISSN 03608352. doi: 10.1016/j.cie.2024.110728. URL https://linkinghub.elsevier.com/retrieve/pii/S0360835224008507.DOI
  129. [129]Hoang Anh Dau, Anthony Bagnall, Kaveh Kamgar, Chin-Chia Michael Yeh, Yan Zhu, Shaghayegh Gharghabi, Chotirat Ann Ratanamahatana, and Eamonn Keogh. The UCR Time Series Archive. IEEE/CAA Journal of Automatica Sinica, 6(6):1293–1305, 2019. ISSN 2329-9266. doi: 10.1109/JAS.2019.1911747. URL https://www.ieee-jas.net/en/article/doi/10.1109/JAS.2019.1911747.DOI
  130. [130]Angus Dempster, François Petitjean, and Geoffrey I. Webb. ROCKET: exceptionally fast and accurate time series classification using random convolutional kernels. Data Mining and Knowledge Discovery, 34(5):1454–1495, 2020. doi: 10.1007/s10618-020-00701-z.DOI
  131. [131]Yan Zhu, Makoto Imamura, Daniel Nikovski, and Eamonn Keogh. Matrix Profile VII: Time series chains: A new primitive for time series data mining (best student paper award). 2017 IEEE International Conference on Data Mining (ICDM), pages 695–704, 2017.DOI
  132. [132]Birte Eichinger and Claudia Kirch. A MOSUM procedure for the estimation of multiple random change points. Bernoulli, 24(1):526–564, 2018. doi: 10.3150/16-BEJ887.DOI
  133. [133]Yoshinobu Kawahara, Takehisa Yairi, and Kazuo Machida. Change-Point Detection in Time-Series Data Based on Subspace Identification. In Seventh IEEE International Conference on Data Mining (ICDM 2007), pages 559–564, October 2007. doi: 10.1109/ICDM.2007.78.DOI
  134. [134]Makoto Yamada, Taiji Suzuki, Takafumi Kanamori, Hirotaka Hachiya, and Masashi Sugiyama. Relative Density-Ratio Estimation for Robust Distribution Comparison, 2011. URL http://arxiv.org/abs/1106.4729.
  135. [135]Song Liu, Makoto Yamada, Nigel Collier, and Masashi Sugiyama. Change-point detection in time-series data by relative density-ratio estimation. Neural Networks, 43:72–83, 2013. doi: 10.1016/j.neunet.2013.01.012.DOI
  136. [136]Wei-Cheng Chang, Chun-Liang Li, Yiming Yang, and Barnabás Póczos. Kernel change-point detection with auxiliary deep generative models, 2019. URL https://arxiv.org/abs/1901.06077.
  137. [137]Makoto Yamada, Akisato Kimura, Futoshi Naya, and Hiroshi Sawada. Change-Point Detection with Feature Selection in High-Dimensional Time-Series Data. In IJCAI, 2013.
  138. [138]Piotr Fryzlewicz. Tail-greedy bottom-up data decompositions and fast multiple change-point detection. The Annals of Statistics, 46(6B), December 2018. ISSN 0090-5364. doi: 10.1214/17-AOS1662.DOI
  139. [139]Daoping Wu, Suhas Gundimeda, Shaoshuai Mou, and Christopher J Quinn. Unsupervised Change Point Detection in Multivariate Time Series. In International Conference on Artificial Intelligence and Statistics, 2024.
  140. [140]Piotr Fryzlewicz. Wild binary segmentation for multiple change-point detection. The Annals of Statistics, 42(6):2243, 2014.DOI
  141. [141]S Kovács, P Bühlmann, H Li, and A Munk. Seeded binary segmentation: A general methodology for fast and optimal changepoint detection. Biometrika, 110(1):249–256, March 2023. ISSN 1464-3510. doi: 10.1093/biomet/asac052.DOI
  142. [142]Baranowski, Yining Chen, and Piotr Fryzlewicz. Narrowest-Over-Threshold Detection of Multiple Change Points and Change-Point-Like Features. Journal of the Royal Statistical Society Series B: Statistical Methodology, 81(3):649–672, July 2019. ISSN 1369-7412. doi: 10.1111/rssb.12322.
  143. [143]Tengyao Wang and Richard J. Samworth. High dimensional change point estimation via sparse projection. Journal of the Royal Statistical Society Series B: Statistical Methodology, 80(1):57–83, 2018. doi: 10.1111/rssb.12243.DOI
  144. [144]Malte Londschien, Peter Bühlmann, and Solt Kovács. Random Forests for Change Point Detection. Journal of Machine Learning Research, 24(216):1–45, 2023.arxiv.org/abs/2205.04997
  145. [145]Hao Chen and Nancy Zhang. Graph-based change-point detection. The Annals of Statistics, 43(1), February 2015. ISSN 0090-5364. doi: 10.1214/14-AOS1269.
  146. [146]Dino Sejdinovic, Bharath Sriperumbudur, Arthur Gretton, and Kenji Fukumizu. Equivalence of distance-based and RKHS-based statistics in hypothesis testing. The Annals of Statistics, 41(5):2263–2291, 2013.DOI
  147. [147]Z. Harchaoui and C. Lévy-Leduc. Multiple Change-Point Estimation With a Total Variation Penalty. Journal of the American Statistical Association, 105(492):1480–1493, December 2010. ISSN 0162-1459, 1537-274X. doi: 10.1198/jasa.2010.tm09181.DOI
  148. [148]Jean-Philippe Vert and Kevin Bleakley. Fast detection of multiple change-points shared by many signals using group LARS. In Advances in Neural Information Processing Systems, 2010.
  149. [149]Seung-Jean Kim, Kwangmoo Koh, Stephen Boyd, and Dimitry Gorinevsky. ℓ1 Trend Filtering. SIAM Review, 51(2):339–360, May 2009. ISSN 0036-1445, 1095-7200. doi: 10.1137/070690274.
  150. [150]Robert Maidstone, Toby Hocking, Guillem Rigaill, and Paul Fearnhead. On optimal multiple changepoint algorithms for large data. Statistics and Computing, 27(2):519–533, March 2017. ISSN 1573-1375. doi: 10.1007/s11222-016-9636-3.DOI
  151. [151]Klaus Frick, Axel Munk, and Hannes Sieling. Multiscale Change Point Inference. Journal of the Royal Statistical Society Series B: Statistical Methodology, 76(3):495–580, June 2014. ISSN 1369-7412. doi: 10.1111/rssb.12047.DOI
  152. [152]Erick Draayer, Huiping Cao, and Yifan Hao. Reevaluating the change point detection problem with segment-based Bayesian online detection. Proceedings of the 30th ACM International Conference on Information & Knowledge Management, 2021.
  153. [153]Paul Fearnhead. Exact and efficient Bayesian inference for multiple changepoint problems. Statistics and Computing, 16(2):203–213, 2006. doi: 10.1007/s11222-006-8450-8.DOI
  154. [154]Kaiguang Zhao, Michael A. Wulder, Tongxi Hu, Ryan Bright, Qiusheng Wu, Haiming Qin, Yang Li, Elizabeth Toman, Bani Mallick, Xuesong Zhang, and Molly Brown. Detecting change-point, trend, and seasonality in satellite time series data to track abrupt changes and nonlinear dynamics: A Bayesian ensemble algorithm. Remote Sensing of Environment, 232:111181, 2019. ISSN 0034-4257. doi: 10.1016/j.rse.2019.04.034. URL https://www.sciencedirect.com/science/article/pii/S0034425719301853.DOI
  155. [155]Jeremias Knoblauch and Theodoros Damoulas. Spatio-temporal Bayesian On-line Changepoint Detection with Model Selection. In International Conference on Machine Learning, 2018.arxiv.org/abs/1805.05383
  156. [156]Yunus Saatçı, Ryan Turner, and Carl Edward Rasmussen. Gaussian Process Change Point Models. In International Conference on Machine Learning, 2010.
  157. [157]Daniel Barry and J A Hartigan. A Bayesian Analysis for Change Point Problems. Journal of the American Statistical Association, 1993.DOI
  158. [158]Siddhartha Chib. Estimation and comparison of multiple change-point models. Journal of Econometrics, 86(2):221–241, October 1998. ISSN 0304-4076. doi: 10.1016/S0304-4076(97)00115-2.DOI
  159. [159]Stanley I. M. Ko, Terence T. L. Chong, and Pulak Ghosh. Dirichlet Process Hidden Markov Multiple Change-point Model. Bayesian Analysis, 10(2), June 2015. ISSN 1936-0975. doi: 10.1214/14-BA910.DOI
  160. [160]Paul Fearnhead and Zhen Liu. On-line inference for multiple changepoint problems. Journal of the Royal Statistical Society Series B: Statistical Methodology, 69(4):589–605, 2007. doi: 10.1111/j.1467-9868.2007.00601.x.DOI
  161. [161]Matthew J. Johnson and Alan S. Willsky. The hierarchical Dirichlet process hidden semi-Markov model. In Conference on Uncertainty in Artificial Intelligence, 2010.
  162. [162]L.R. Rabiner. A tutorial on hidden Markov models and selected applications in speech recognition. Proceedings of the IEEE, 77(2):257–286, February 1989. ISSN 1558-2256. doi: 10.1109/5.18626.DOI
  163. [163]Emily B. Fox, Erik B. Sudderth, Michael I. Jordan, and Alan S. Willsky. A sticky HDP-HMM with application to speaker diarization. The Annals of Applied Statistics, 5(2A):1020–1056, June 2011. ISSN 1932-6157, 1941-7330. doi: 10.1214/10-AOAS395.DOI
  164. [164]Emily B. Fox, Michael C. Hughes, Erik B. Sudderth, and Michael I. Jordan. Joint modeling of multiple time series via the beta process with application to motion capture segmentation. The Annals of Applied Statistics, 8(3), September 2014. ISSN 1932-6157. doi: 10.1214/14-AOAS742.DOI
  165. [165]Scott Linderman, Matthew Johnson, Andrew Miller, Ryan Adams, David Blei, and Liam Paninski. Bayesian Learning and Inference in Recurrent Switching Linear Dynamical Systems. In Proceedings of the 20th International Conference on Artificial Intelligence and Statistics, pages 914–922. PMLR, April 2017.
  166. [166]Zhe Dong, Bryan Seybold, Kevin Murphy, and Hung Bui. Collapsed amortized variational inference for switching nonlinear dynamical systems. In Hal Daumé III and Aarti Singh, editors, Proceedings of the 37th International Conference on Machine Learning, volume 119 of Proceedings of Machine Learning Research, pages 2638–2647. PMLR, 13–18 Jul 2020. URL https://proceedings.mlr.press/v119/dong20e.html.arxiv.org/abs/1910.09588
  167. [167]Shohei Hido, Tsuyoshi Idé, Hisashi Kashima, Harunobu Kubo, and Hirofumi Matsuzawa. Unsupervised change analysis using supervised learning. In Pacific-Asia Conference on Knowledge Discovery and Data Mining, 2008.DOI
  168. [168]Angela Bonifati, Francesco Del Buono, Francesco Guerra, and Donato Tiano. Time2Feat: Learning interpretable representations for multivariate time series clustering. Proceedings of the VLDB Endowment, 16(2):193–201, October 2022. ISSN 2150-8097. doi: 10.14778/3565816.3565822.DOI
  169. [169]Kevin C. Cheng, Shuchin Aeron, Michael C. Hughes, Erika Hussey, and Eric L. Miller. Optimal transport based change point detection and time series segment clustering. In ICASSP 2020 - 2020 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pages 6034–6038. IEEE, May 2020. doi: 10.1109/ICASSP40776.2020.9053344.
  170. [170]David Gentile, Joshua Huang, and James M. Murphy. Wasserstein-based identification of metastable states in time series data via change point detection and segment clustering. arXiv preprint arXiv:2603.01989, March 2026.arxiv.org/abs/2603.01989
  171. [171]Blanka Horvath, Zacharia Issa, and Aitor Muguruza. Clustering Market Regimes using the Wasserstein Distance. Journal of Computational Finance, 28(1):1–39, 2024.
  172. [172]M. Sinn, K. Keller, and B. Chen. Segmentation and classification of time series using ordinal pattern distributions. The European Physical Journal Special Topics, 222(2):587–598, June 2013. ISSN 1951-6401. doi: 10.1140/epjst/e2013-01861-8.DOI
  173. [173]Louis Carpentier, Len Freamans, Wannes Meert, and Mathias Verbeke. Pattern-based time series semantic segmentation with gradual state transitions. In SDM, 2024.DOI
  174. [174]Lzz19980125/awesome-time-series-segmentation-papers. GitHub repository. URL https://github.com/lzz19980125/awesome-time-series-segmentation-papers.

Paper details

vlnc:W_3xwvrqv8
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 11

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

Not recorded for this paper

View statement
Looking for related papers…
Contents