Paper deep dive
TypiCore: A Hybrid Active Query Strategy for Class-Incremental Learning on Time Series
Gabor Szucs, Samuel Jacsev, Marcell Nemeth, Davide Dalle Pezze, Gian Antonio Susto
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 92%
Last extracted: 7/21/2026, 5:22:34 AM
Summary
The paper introduces TypiCore, a hybrid active query strategy for Active Class-Incremental Learning (ACIL) on multivariate time series. It addresses the limitation of high annotation costs in Continual Learning by alternating between typicality-based and diversity-based sample selection to construct representative and diverse memory buffers. Evaluated on the TSCIL benchmark, TypiCore outperforms existing baselines and matches fully supervised performance with significantly fewer labels.
Entities (9)
Relation Signals (10)
TypiCore → evaluatedon → TSCIL
confidence 95% · Evaluated on the TSCIL benchmark, TypiCore delivers statistically significant improvements
TypiCore → isa → Hybrid Active Query Strategy
confidence 95% · we propose TypiCore, a novel hybrid query strategy
TypiCore → usedfor → Active Class-Incremental Learning
confidence 95% · This paper investigates Active Class-Incremental Learning (ACIL)... we propose TypiCore
TypiCore → combines → Diversity-based Selection
confidence 92% · alternates between typicality-based and diversity-based sample selection
TypiCore → combines → Typicality-based Selection
confidence 92% · alternates between typicality-based and diversity-based sample selection
Experience Replay → isa → Rehearsal-based Method
confidence 90% · Experience Replay (ER) is the most famous replay-based method
Active Class-Incremental Learning → isa → Class-Incremental Learning
confidence 90% · Active Class-Incremental Learning (ACIL) for multivariate time series... Class-Incremental Learning (CIL)
TypiCore → outperforms → ASER
confidence 90% · TypiCore consistently outperforms all baseline methods
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Time series data play a pivotal role across numerous domains, including healthcare and manufacturing. In real-world environments, models must cope with distribution shifts over time, a challenge commonly addressed through Continual Learning (CL) techniques. However, existing CL methods face a critical limitation: real-world data streams are rarely fully labeled, making annotation cost a major practical constraint. This paper investigates Active Class-Incremental Learning (ACIL) for multivariate time series, where a model must sequentially learn new classes while selectively querying labels under a fixed annotation budget. We present a systematic evaluation of a wide range of query strategies combined with multiple rehearsal-based approaches, assessing their impact on plasticity, stability, and label efficiency across four benchmark datasets. Our analysis reveals the limitations of uncertainty-based and distribution-aware methods in achieving strong performance under constrained labeling budgets. To address these shortcomings, we propose TypiCore, a novel hybrid query strategy that alternates between typicality-based and diversity-based sample selection across active learning cycles, enabling the construction of memory buffers that are both representative and diverse. Evaluated on the TSCIL benchmark, TypiCore delivers statistically significant improvements over all baselines and matches or surpasses fully supervised continual learning performance on multiple datasets while requiring a fraction of the available labels.
Tags
Links
- Source: https://arxiv.org/abs/2607.17632v1
- Canonical: https://arxiv.org/abs/2607.17632v1
Trouble viewing inline? Open PDF directly →
Full Text
64,110 characters extracted from source content.
Expand or collapse full text
1] of Telecommunications and Artificial Intelligence, University of Technology and Economics, , 2] of Information Engineering, of Padua, , TypiCore: A Hybrid Active Query Strategy for Class-Incremental Learning on Time Series ábor űcs szucs@tmit.bme.hu ámuel émeth nemethm@tmit.bme.hu Pezze davide.dallepezze@unipd.it Antonio gianantonio.susto@unipd.it [ [ Abstract Time series data play a pivotal role across numerous domains, including healthcare and manufacturing. In real-world environments, models must cope with distribution shifts over time, a challenge commonly addressed through Continual Learning (CL) techniques. However, existing CL methods face a critical limitation: real-world data streams are rarely fully labeled, making annotation cost a major practical constraint. This paper investigates Active Class-Incremental Learning (ACIL) for multivariate time series, where a model must sequentially learn new classes while selectively querying labels under a fixed annotation budget. We present a systematic evaluation of a wide range of query strategies combined with multiple rehearsal-based approaches, assessing their impact on plasticity, stability, and label efficiency across four benchmark datasets. Our analysis reveals the limitations of uncertainty-based and distribution-aware methods in achieving strong performance under constrained labeling budgets. To address these shortcomings, we propose TypiCore, a novel hybrid query strategy that alternates between typicality-based and diversity-based sample selection across active learning cycles, enabling the construction of memory buffers that are both representative and diverse. Evaluated on the TSCIL benchmark, TypiCore delivers statistically significant improvements over all baselines and matches or surpasses fully supervised continual learning performance on multiple datasets while requiring a fraction of the available labels. keywords: Continual Learning, Active Learning, Time-series Classification 1 Introduction The deployment of machine learning systems in dynamic real-world environments increasingly demands models capable of adapting to continuously evolving data distributions. This challenge is especially pronounced in the time series domain, where applications such as industrial fault detection, healthcare monitoring, and human activity recognition operate in inherently non-stationary settings. In these scenarios, new classes of events or behaviors emerge over time, a new fault type in a production line, a previously unseen activity pattern, or a novel clinical condition, and models must incorporate this new knowledge without catastrophically overwriting what was previously learned. How to adapt to new incoming data while retaining the previous knowledge is known as Continual Learning (CL). Among its various formulations, Class-Incremental Learning (CIL) represents one of the most challenging and practically relevant settings: the model must sequentially learn new classes as they arise, while remaining capable of classifying all previously seen classes at inference time, and without access to task identifiers [van2022three]. Despite substantial progress in CL in recent years, there are two critical issues that are unexplored. The first is that classic CL scenarios assume incoming data streams are fully labeled, but in practice, this assumption rarely holds. Data acquisition is often automatic and inexpensive, but annotation requires domain expertise, sustained manual effort, and considerable time and financial resources. The second gap concerns the scope of evaluation. The vast majority of continual learning research has been conducted in the computer vision [pezze2025continual] and, more recently, natural language processing domains [carta2026adapting], leaving time series data comparatively underexplored despite its prevalence in high-stakes applications. One of the few exceptions is the work [qiao2024class], which introduced the Time Series Class-Incremental Learning (TSCIL) benchmark to standardize evaluation across a diverse set of time series datasets. However, the benchmark operates under the standard fully-labeled assumption, leaving the label-scarce setting entirely unaddressed. Active Learning (AL) offers a principled solution to the labeling bottleneck by strategically selecting the most informative samples for annotation, maximizing model performance under a fixed labeling budget [settles2009active]. In isolation, both CIL and AL are well-established research areas with rich literature and mature methodologies. Yet their intersection, Active Class-Incremental Learning (ACIL), remains remarkably underexplored, with few works focused on image classification [bhattacharya2026acil]. However, time series classification introduces additional complexity beyond standard CIL benchmarks: temporal dependencies, multivariate channel interactions, inter-subject variability, and noisy acquisition conditions all compound the challenge of learning incrementally from limited labeled data. The first contribution of this work is a comprehensive and systematic evaluation of active learning query strategies in rehearsal-based approaches for the CIL scenario applied to multivariate time series classification. The core of the work involves designing and systematically evaluating a wide range of active learning methodologies, including uncertainty-based, distribution-aware, and hybrid strategies. We then analyze the effectiveness of these strategies in dynamic environments using the TSCIL benchmark. The first insight is that, contrary to the expectation, complex and optimal methods like ASER show that in data-scarce active learning scenarios, the simpler ER mechanism often yields superior stability. The uncertainty-based methods prove consistently detrimental, frequently degrading performance below random selection. In contrast, distribution-aware methods like Core-Set excel at geometric coverage, maximizing exposure to the underlying data distribution while hybrid approaches like TypiClust excels at representativeness by selecting typical high-density samples, thereby promoting stable memory retention. However, neither approach alone achieves a robust balance between plasticity and stability across the benchmark. Therefore, as the third contribution, motivated by this analysis, we introduce TypiCore, a novel hybrid active query strategy that alternates between typicality-based and diversity-based selection across active learning cycles. TypiCore constructs memory buffers that are simultaneously robust against forgetting and expressive enough to capture the complexity of the underlying data distribution. Through experiments on the TSCIL benchmark, we show that TypiCore consistently outperforms all baseline methods with statistically significant gains across multiple datasets. Furthermore, despite operating under a limited labeling budget, it matches or exceeds the performance of fully supervised continual learning approaches on several benchmarks. The remainder of this paper is organized as follows. Section 2 reviews the relevant literature on continual learning, covering the main scenarios and approaches. Section 3 surveys the active learning strategies, from uncertainty-based methods to diversity and typicality-based approaches. Section 4 formalizes the proposed Active Class-Incremental Learning framework, and introduces TypiCore, our novel hybrid query strategy. Section 5 details the experimental setup, including the benchmark datasets, model architecture, training configuration, and evaluation protocol. Section 6 presents and analyzes the empirical results across all query strategies and datasets. Finally, Section 7 concludes the paper, summarizing the key findings and outlining directions for future work. Figure 1: ACIL Framework. Scheme to integrate Active Learning strategies in the Class Incremental Learning scenario. Each task is composed of multiple active learning cycles and each one is composed of three phases: i) Query Strategy, i) Oracle labeling, i) Training. 2 Related Work Traditional machine learning paradigms assume independent and identically distributed samples drawn from a stationary distribution, but real-world applications often encounter evolving data streams where new tasks emerge sequentially. The ability to learn sequentially from non-stationary data streams without forgetting previously acquired knowledge has emerged as a central challenge in modern machine learning and is known as Continual Learning (CL). The core problem is catastrophic forgetting, where a neural network trained sequentially on new tasks tends to lose performance on prior information. This phenomenon occurs because the neural network abruptly overwrites previously learned representations when exposed to new training data. Therefore, CL focuses on developing techniques to mitigate forgetting during network updates and find an optimal balance between stability (preserving old knowledge) and plasticity (acquiring new knowledge) [yamauchi2023quick]. Literature on CL usually adopt the taxonomy proposed in [van2022three] introducing three CL scenarios, (i) Task-Incremental Learning (TIL), where task identity is available at inference time, (i) Domain-Incremental Learning (DIL), where the class set remains fixed but the input distribution shifts, and (i) Class-Incremental Learning (CIL), where new classes arrive sequentially and the model must classify among all classes seen so far without task identity. Of these, CIL represents the most challenging and practically relevant setting, as it most closely mirrors real-world conditions. While continual learning research has historically been concentrated in computer vision, and more recently in natural language processing driven by the rise of large language models, other data modalities have received comparatively little attention. Time series data, despite its prevalence in real-world applications such as industrial monitoring, healthcare, and activity recognition, remains much less explored in the continual learning literature. To address this gap, the Time Series Class-Incremental Learning (TSCIL) benchmark [qiao2024class] was developed, which systematically evaluates the performance of established continual learning methods across four curated time series datasets under the class-incremental learning scenario. To mitigate catastrophic forgetting, the literature has converged on three broad families of approaches: regularization-based, architecture-based and rehearsal-based [wickramasinghe2023continual]. Regularization-based methods impose constraints on parameters or activations to protect knowledge critical to previous tasks. Some well-known methods belonging to this category are Elastic Weight Consolidation (EWC) [kirkpatrick2017overcoming], which introduced a penalty on parameters important for prior tasks, and Learning without Forgetting (LwF) [li2017learning], which instead applies knowledge distillation [hinton2015distilling], constraining the network’s output activations on new data to remain consistent with those of the previously trained model. However, these methods tend to degrade under long task sequences and have been shown to perform poorly in the CIL scenario. Architecture-based methods address forgetting by allocating distinct model components to different tasks, ensuring that learning a new task does not interfere with the parameters storing knowledge from previous ones [fernando2017pathnet]. Representative approaches include Progressive Neural Networks [rusu2016progressive], which grow the architecture with each new task by adding lateral connections to frozen columns, and PackNet [mallya2018packnet], which iteratively masks and prunes subnetworks within a fixed-capacity model. However, these methods have two fundamental limitations: they usually do not scale well with the number of tasks, and task identity is typically required at inference time to route inputs to the correct subnetwork, an assumption not allowed in the CIL scenario. Rehearsal-based methods have emerged as the most practically effective family of approaches for CIL [chaudhry2019tiny, buzzega2020dark]. The core principle, introduced by Experience Replay (ER) [chaudhry2019tiny], is simple yet powerful. A small subset of samples from previous tasks is stored in a fixed-size episodic memory buffer. These samples are revisited together with the new samples when visiting a new task. In this way, the model can retain the accumulated knowledge by periodically revisiting previous data while remaining plastic enough to incorporate new classes. Despite its simplicity, ER has proven a remarkably competitive baseline across diverse benchmarks, motivating a rich line of follow-up work focused on improving memory management strategies. While some methods consider hybrid approaches that combine replay with other strategies [rebuffi2017icarl, lopez2017gradient, buzzega2020dark], a parallel line of work has focused specifically on improving memory retrieval [aljundi2019online, shim2021online]. For example, ASER leverages an efficient k-nearest-neighbor approximation of Shapley values to quantify each sample’s marginal contribution to classification performance [shim2021online] and achieves state-of-the-art performance on the TSCIL benchmark [qiao2024class]. Despite the significant advances, a fundamental limitation persists across the entire continual learning literature: the assumption that incoming data streams are fully labeled. In practice, however, deploying a continual learning system requires continuous human intervention to annotate new data, a process that is costly, time-consuming, and difficult to scale. This bottleneck severely constrains the real-world applicability of existing CIL methods, regardless of their methodological complexity. Therefore, in this paper, we directly address this limitation by incorporating active learning capabilities in the TSCIL benchmark. We analyze the effect of different query strategies on the performance of rehearsal-based methods, with a particular focus on ER and ASER. Finally, we propose TypiCore, a novel hybrid query strategy that alternates between typicality-based and diversity-based sample selection across active learning cycles, enabling the construction of memory buffers that are both representative and diverse. 3 Active Learning Approaches 3.1 Introduction In classification problems, obtaining labels can be expensive, often requiring expert knowledge. Therefore, given a fixed labeling budget, the specific subset of data chosen for labeling can critically impact the resulting model’s performance. Active Learning is the process of strategically selecting the most informative samples from an unlabeled pool for labeling, thereby maximizing learning performance with minimal labeling effort [settles2009active, cherman2019multi]. Active learning systems implement this selection using query strategies in an iterative process. The model is trained on an initial set of labeled samples, resulting in a model state θ. Based on this model state, the active learning strategy selects a new batch of samples from the unlabeled pool, from which the model is expected to gain the most information. These strategies generally fall into two main categories: uncertainty-based and distribution-aware. 3.2 Uncertainty-Based Methods Uncertainty-based methods select samples about which the model, in its current state θ, is most uncertain, based on the assumption that uncertain samples are likely to be the most informative for improving model performance. These methods rely on the model’s softmax output probabilities computed using the model state from the previous step, θa−1 _a-1. In the following, pθa−1(yk∣x)p_ _a-1(y_k x) denotes the predicted probability for class k given the input x. We define pθa−1(ymax1∣x)p_ _a-1(y_ 1 x) and pθa−1(ymax2∣x)p_ _a-1(y_ 2 x) as the probabilities of the most (maximum predicted probability) and second-most likely classes, respectively. Entropy-Based Uncertainty Entropy measures the disorder or uncertainty in the model’s predicted probability distribution [tharwat2023survey]. For a classification task with K classes, the uncertainty is defined as follows, where samples with high entropy are considered uncertain. Uentropy(x)=−∑k=1Kpθa−1(yk∣x)logpθa−1(yk∣x)U_entropy(x)=- _k=1^Kp_ _a-1(y_k x) p_ _a-1(y_k x) (1) Margin-Based Uncertainty This strategy focuses on the difference between the top two predicted classes [tharwat2023survey]. The next equation presents the formula, where samples with small margins are considered uncertain. Umargin(x)=pθa−1(ymax1∣x)−pθa−1(ymax2∣x)U_margin(x)=p_ _a-1(y_ 1 x)-p_ _a-1(y_ 2 x) (2) Least Confidence This strategy selects samples where the model is least confident in its most probable prediction [tharwat2023survey]. Samples with low confidence are considered uncertain, where the confidence is calculated based on the next equation. ULC(x)=1−pθa−1(ymax1∣x)U_LC(x)=1-p_ _a-1(y_ 1 x) (3) 3.3 Distribution-aware Methods Distribution-aware methods select samples that best represent the overall data distribution in the feature space, ensuring good coverage and preventing the model from focusing on narrow regions [settles2009active]. Distribution-aware methods aim to select samples that capture the variety and span the underlying structure of the overall data distribution in the feature space. Core-Set [sener2017active] (as diversity-based method) employs a greedy k-center approximation algorithm to find a subset that effectively covers the data by choosing centers that minimize the maximum distance from any data point to its nearest center. The algorithm operates in the feature space extracted from the model’s embedding layer using a furthest-first traversal strategy. Given labeled samples L and unlabeled candidates U, the algorithm maintains for each unlabeled sample the distance to its nearest labeled neighbor. At each iteration, it selects the unlabeled sample with the maximum such distance, effectively choosing the sample that is furthest from all currently labeled points. After adding this sample to L, the distances are updated incrementally by comparing each unlabeled sample’s current minimum distance with its distance to the newly selected point. This process repeats until n samples are selected. Formally, at each iteration, the algorithm selects: x∗=argmaxx∈Uminx′∈L‖f(x)−f(x′)‖2x^*= _x∈ U _x ∈ L\|f(x)-f(x )\|_2 (4) where f(⋅)f(·) denotes the feature embedding. This greedy approach ensures maximum coverage of the feature space and provides a 2-approximation to the optimal k-center problem. Some methods combine different objectives, such as uncertainty, diversity [he2014active, giouroukis2025dual]. However, although combining uncertainty and diversity can enhance performance, these two criteria alone may be insufficient in low-budget scenarios. Therefore, TypiClust [hacohen2022active] (typicality-based method) introduces a third dimension, representativeness, which proves equally critical: rather than selecting samples that are merely uncertain or geometrically spread, a robust query strategy should prioritize samples that are typical of their class distribution. Representativeness describes how typical a sample is of its class, or equivalently, how similar it is to other samples in the same region of the feature space. Building on this principle, TypiClust [hacohen2022active] combines clustering with typicality scoring to systematically identify and select the most representative samples from each region of the data distribution. Typicality measures a sample’s density in feature space, quantified as the inverse of the average Euclidean distance to its K nearest neighbors: Typicality(x)=(1K∑xi∈K-N(x)‖x−xi‖2)−1Typicality(x)= ( 1K _x_i∈$K$-N(x)\|x-x_i\|_2 )^-1 (5) where x is the feature vector, K-N(x)$K$-N(x) denotes the K nearest neighbors of x, and ‖x−xi‖2\|x-x_i\|_2 is the Euclidean distance between x and neighbor xix_i. The method proceeds through three steps: 1. Representation learning: Learn a feature space from the unlabeled pool 0U_0 using self-supervised learning. 2. Clustering for diversity: At iteration i, partition the data into k=|ℒi−1|+Bk=|L_i-1|+B clusters, where B is the batch size and |ℒi−1||L_i-1| is the number of labeled examples. This ensures that at least B clusters contain no labeled examples. 3. Querying typical examples: Select the most typical example (Eq. 5) from each of the B largest clusters without labeled examples. Input: Memory ℳM; Parameters θt−1 _t-1, Dataset tD_t; Task t 1 21ex 3Initialize parameters: θ′←θt−1θ ← _t-1 4 5while not converged do 6 for B∼tB _t do 7 if t=1t=1 then θ′←SGD(B,θ′)θ (B,θ ) // first task, empty memory 8 9 else 10 Bℳ←MemoryRetrieval(ℳ,B,θ′)B_M (M,B,θ ) θ′←SGD(Bℳ∪B,θ′)θ (B_M∪ B,θ ) // train on combined batch 11 12 13 θt←θ′ _t←θ // converged, set as optimal for task t 14 151ex 16for B∼tB _t do ℳ←MemoryUpdate(ℳ,B,θ′)M (M,B,θ ) // memory update 17 18 return θt,ℳ _t,M Algorithm 1 Generic ER-based method for Task t 4 Methodology: TypiCore in ACIL Framework 4.1 Replay Approach Among the approaches proposed to address catastrophic forgetting, replay-based methods have emerged as one of the most effective and practical. The core idea is to maintain a fixed-size memory buffer ℳM containing a small subset of samples from previously learned tasks. During training on a new task, previously stored exemplars are retrieved from the memory buffer and interleaved with the current task’s data, exposing the model simultaneously to old and new class distributions and thereby counteracting the forgetting. Formally, the sequential learning scenario consists of T incremental tasks. Each task t∈1,…,Tt∈\1,…,T\ introduces a disjoint subset of new classes tC_t, such that i∩j=∅C_i _j= for all i≠ji≠ j. The set of all classes encountered up to and including task t is defined as ≤t=⋃i=1tiC_≤ t= _i=1^tC_i. At the onset of each task t, a dataset t=iti=1NtD_t=\x_i^t\_i=1^N_t of NtN_t samples becomes available. Each sample ∈ℝd×τx ^d×τ is a multivariate time series with d channels and τ time steps. The learner’s objective is to incrementally train a classifier fθ:ℝd×τ→≤tf_θ:R^d×τ _≤ t that, after completing task t, correctly classifies instances from the full joint label space ≤tC_≤ t. Furthermore, we operate under the class-incremental learning protocol, in which no task identifier is provided at inference time and the model must discriminate among all previously seen classes without access to task identifiers. Experience Replay (ER) [chaudhry2019tiny] is the most famous replay-based method and consists of two components. 1. Rehearsal. During training on task t, each mini-batch BℓB_ sampled from the current dataset tD_t is augmented with a batch BmB_m retrieved uniformly at random from the memory buffer ℳM. The model is then updated on the combined batch Bm∪BℓB_m∪ B_ , exposing it simultaneously to new and old class distributions. The model parameters θ are updated by minimizing the combined loss: L(θt)=LCE(θt;Bm)+LCE(θt;Bℓ)L( _t)=L_CE( _t;B_m)+L_CE( _t;B_ ) (6) where LCEL_CE denotes the cross-entropy loss. 2. Memory update. After processing each task, the buffer ℳM is updated via reservoir sampling [vitter1985random], which guarantees that every observed sample has an equal probability of being retained regardless of when it was encountered. This ensures that ℳM remains a uniformly random subset of all samples seen so far. The complete procedure is detailed in Algorithm 1. 4.2 ASER While ER provides a simple and effective foundation for replay-based continual learning, its reliance on uniform random sampling treats all stored exemplars as equally valuable. In practice, however, samples differ substantially in their contribution to preventing catastrophic forgetting: exemplars that are representative of their class distribution or that occupy critical regions near decision boundaries are far more informative during rehearsal than outliers or redundant samples. Adversarial Shapley Value Experience Replay (ASER) [shim2021online] addresses this limitation by replacing both random memory retrieval and reservoir-based memory update with importance-driven selection based on the shapley values. The Shapley value was originally developed in cooperative game theory. Given a dataset of N samples indexed by ℐ=1,…,NI=\1,…,N\ and a utility function v()v(S) representing model performance when trained on subset ⊆ℐS , the Shapley value for sample i is defined as: s(i)=∑⊆ℐ∖i||!(N−||−1)!N![v(∪i)−v()]s(i)= _S \i\ |S|!(N-|S|-1)!N! [v(S∪\i\)-v(S) ] (7) This formulation computes the average marginal contribution of sample i across all possible subsets that exclude it. However, computing exact Shapley values is computationally prohibitive, requiring (2N)O(2^N) evaluations. ASER addresses this by leveraging an efficient k-nearest neighbour (KNN) based approximation that reduces complexity to (NlogN)O(N N). This approximation exploits the natural clustering of classes in the embedding space and defines a KNN utility function that measures the likelihood of correct classification. The resulting KNN Shapley value sj(i)s_j(i) quantifies the average marginal contribution of candidate sample i with respect to a reference sample j. When i and j share the same label then sj(i)>0s_j(i)>0, with magnitude |sj(i)||s_j(i)| reflecting their proximity in the latent space. Building on this, ASER introduces the Adversarial Shapley Value (ASV) score to balance the competing objectives of continual learning: maintaining stability on previously learned tasks while enabling plasticity for new tasks. The ASV score is formulated as: ASV(i)=maxj∈subsj(i)−mink∈ℬnsk(i)ASV(i)= _j _subs_j(i)- _k _ns_k(i) (8) where i∈ℳ∖subi _sub, subS_sub is a class-balanced subsample from memory ℳM and ℬnB_n is the incoming batch. The first term captures stability while the second term captures plasticity. A softer variant replaces the max and min operators with mean aggregation over the same sets, providing more stable estimates: ASVμ(i)=1|sub|∑j∈subsj(i)−1|ℬn|∑k∈ℬnsk(i).ASV_μ(i)= 1|S_sub| _j _subs_j(i)- 1|B_n| _k _ns_k(i). (9) ASER modifies two critical components of the generic ER procedure described in Algorithm 1. 1. Memory Retrieval. Instead of random sampling, ASER computes ASV(i) as defined in Eq. 8 or in Eq. 9 for candidate samples in ℳM and retrieves the ℬMB_M samples with the highest scores. 2. Memory Update. Rather than reservoir sampling, ASER employs a value maximization strategy. It considers the union of the current memory and the incoming batch, =ℳ∪ℬnC=M _n, and computes the average KNN-SV score: v(i)=1|sub|∑j∈subsj(i)v(i)= 1|S_sub| _j _subs_j(i) for each candidate i∈i . Here, the evaluation set sub⊂ℳS_sub is a random subsample drawn from the current memory, serving as a reference for class representation. The buffer is updated by retaining the top-|ℳ||M| samples with the highest v(i)v(i). Together, these two modifications transform ER from a passive, random rehearsal mechanism into an active, value-driven memory management system, achieving state-of-the-art performance on the TSCIL benchmark [qiao2024class, szHucs2025active]. 1 2 Input: Task t, unlabeled pool tD_t, consolidated memory ℳM, previous model θt−1,Na _t-1,N_a, AL policy A, budget b, cycles NaN_a 3 // 1. Initialization θt,0←θt−1,Na _t,0← _t-1,N_a // Parameters from end of task t−1t-1 4 ℒt,0←∅L_t,0← , ℒt,0acc←∅L^acc_t,0← t,0←tU_t,0 _t // Initialize unlabeled pool 5 // 2. Active learning cycles 6 for a=1a=1 to NaN_a do // 2.1. Query and Update t,a←(t,a−1,θt,a−1,b)Q_t,a (U_t,a-1, _t,a-1,b) // Select informative batch 7 Acquire labels for t,aQ_t,a from oracle ℒt,a←(x,y)∣x∈t,aL_t,a←\(x,y) x _t,a\ // Form current training batch ℒt,aacc←ℒt,a−1acc∪ℒt,aL^acc_t,a ^acc_t,a-1 _t,a // Append to cumulative set 8 t,a←t,a−1∖t,aU_t,a _t,a-1 _t,a 9 // 2.2. Incremental Training Step 10 θ′←θt,a−1θ ← _t,a-1 11 while not converged do 12 for Bℓ∼ℒt,aaccB_ ^acc_t,a do 13 if t=1t=1 then 14 θ′←SGD(Bℓ,θ′)θ (B_ ,θ ) 15 16 else Bℳ←MemoryRetrieval(ℳ,Bℓ,θ′)B_M (M,B_ ,θ ) // Retrieve replay batch θ′←SGD(Bℳ∪Bℓ,θ′)θ (B_M∪ B_ ,θ ) // Train with replay 17 18 19 θt,a←θ′ _t,a←θ // Update model state for cycle a 20 21 // 3. Memory Consolidation 22 for Bℓ∼ℒt,NaaccB_ ^acc_t,N_a do ℳ←MemoryUpdate(ℳ,Bℓ,θ′)M (M,B_ ,θ ) // Update consolidated memory 23 24 return θt,Na _t,N_a, ℳM Algorithm 2 ACIL Framework for Task t 4.3 ACIL Framework Standard continual learning methods, including both ER and ASER, operate under the assumption that all incoming data is fully labeled. While this assumption simplifies the learning protocol, it is rarely satisfied in practice. In real-world deployments, data acquisition is often automatic and inexpensive, sensors continuously generate readings, cameras capture frames, and devices log activity, but annotation requires domain expertise, sustained manual effort, and considerable time and financial resources. This disconnect between methodological assumptions and deployment constraints severely limits the practical applicability of existing CIL systems. Active learning is the natural complement to this problem, rather than labeling everything, the learner strategically selects the most informative samples for annotation, maximizing learning performance under a fixed budget. We therefore propose integrating active learning directly into replay-based approaches, thereby introducing the Active Class Incremental Learning (ACIL) framework, as shown in Figure 1. At each task t, the learner has access to an unlabeled pool tD_t of NtN_t samples but may only query labels for at most B≪NtB N_t of them. In other words, we assume a limited annotation budget B per task, which must be distributed among multiple query cycles. The central challenge lies in designing query strategies that select samples that are simultaneously informative for learning the current task and representative enough to populate a memory buffer that supports long-term retention across all previously seen classes. Active Learning Cycle Formally, we structure the annotation process within each task t as a sequence of NaN_a active learning cycles, as shown in Figure 1. The dataset tD_t is partitioned into q equal slices, defining a query batch size of b=⌊Nt/q⌋b= N_t/q . The learner is permitted to query Na≤qN_a≤ q of these slices, resulting in a total annotation budget of B=Na×bB=N_a× b and a budget ratio ρ=Na/qρ=N_a/q representing the fraction of the total data that is annotated. Query Batch (Qt,a)(Q_t,a): At cycle a of task t, an active learning policy A selects a query set Qt,aQ_t,a of b samples from the current unlabeled pool t,a−1U_t,a-1: Qt,a=(t,a−1,θt,a−1,b)Q_t,a=A(U_t,a-1,\, _t,a-1,\,b) where θt,a−1 _t,a-1 denotes the model state at the end of the previous cycle. Labeled Set (Lt,a)(L_t,a): Labels are then acquired from an oracle, representing a human annotator or equivalent labeling process, to form the current labeled batch: Lt,a=(,y)∣∈Qt,aL_t,a=\(x,y) ∈ Q_t,a\ Cumulative Labeled Set (Lt,aacc)(L^acc_t,a) This batch is appended to the cumulative labeled set, which aggregates all annotations acquired within the current task up to cycle a: Lt,acc=Lt,a−1acc∪Lt,aL^acc_t,a=L^acc_t,a-1∪ L_t,a Crucially, model training at each cycle operates on the full cumulative set Lt,accL^acc_t,a rather than solely on the most recent batch Lt,aL_t,a. This design choice ensures that the model retains knowledge of all classes encountered within the current task, regardless of when their samples were queried. Algorithm 2 presents the complete ACIL framework for a single task t. The procedure unfolds in three phases. 1. Initialization. The model parameters θt,0 _t,0 are inherited from the end of the previous task, θt−1,Na _t-1,N_a. Both the current labeled batch Lt,0L_t,0 and the cumulative set Lt,0accL^acc_t,0 are initialized as empty, and the full dataset tD_t constitutes the initial unlabeled pool t,0U_t,0. 2. Cycle loop. For each cycle a∈1,…,Naa∈\1,…,N_a\, the protocol proceeds as follows. First, the active learning policy A selects b samples from the unlabeled pool, which are labeled by the oracle and appended to the cumulative set. The model then trains to convergence on Lt,accL^acc_t,a: for the first task, each mini-batch BℓB_ is used directly for gradient updates; for subsequent tasks, every mini-batch is augmented with a replay batch BMB_M retrieved from ℳM, and the model is updated on the combined batch BM∪BℓB_M∪ B_ . The updated model state θt,a _t,a is then carried forward to the next cycle, where it serves as the basis for the next query. 3. Memory consolidation. Once all NaN_a cycles are complete, the consolidated memory ℳM is updated by iterating through Lt,NaaccL^acc_t,N_a in mini-batches using the strategy-specific Memory Update procedure. The cumulative labeled set is then discarded, as its role is fulfilled by ℳM for all future tasks. Memory Retrieval and Memory Update A critical design decision in the ACIL framework concerns how the memory ℳM interacts with the active learning process. In our framework, Memory Retrieval and Memory Update are not fixed procedures but are determined by the underlying continual learning method, ER or ASER. During the cycle loop, Memory Retrieval is invoked at every training iteration to augment the current mini-batch BℓB_ with a replay batch BMB_M drawn from ℳM. Under ER, this retrieval is uniform random; under ASER, it is importance-driven, prioritizing exemplars with the highest ASV scores. Memory Update, by contrast, is invoked only once per task, at the memory consolidation phase after all NaN_a active learning cycles have been completed. At this point, the full cumulative labeled set Lt,NaaccL^acc_t,N_a, comprising all samples annotated during the task, is streamed through the update procedure in mini-batches. Under ER, reservoir sampling ensures that a uniformly random subset of all seen samples is retained. Under ASER, a value-maximization strategy retains the top-|ℳ||M| samples according to their KNN Shapley value. 4.4 TypiCore From the experimental analysis of individual active learning strategies showed later in Section 6 emerges a fundamental limitation. Specifically, no single method is sufficient on its own for the active class-incremental learning setting. Uncertainty-based approaches systematically fail to outperform random selection. Also, distribution-aware methods underperform with Core-Set that maximizes coverage, ensuring plasticity and immediate learning accuracy, but at the cost of catastrophic forgetting, as the memory becomes populated with atypical, boundary-adjacent samples that lack the robust features necessary for long-term retention. On the contrary, TypiClust, which builds a stable and representative memory buffer but underrepresents regions of the feature space. Therefore, we propose a novel approach, TypiCore, that considers a trade-off of the two objectives: representativeness and coverage. Representativeness prioritizes the selection of high-density, prototypical samples that accurately reflect the core structure of each class, ensuring stability as the model encounters new tasks. Coverage, instead, focuses on selecting samples from underrepresented regions of the feature space, preserving diversity and preventing the memory buffer from collapsing onto a narrow, potentially unrepresentative subset of the data distribution. Neither objective alone is adequate: pure representativeness leads to a memory that is stable but lacks diversity, while pure coverage leads to diversity without the robustness needed to resist forgetting. TypiCore addressed these two complementary distribution-aware objectives through a dynamic alternating mechanism that interleaves two phases across successive active learning cycles. Concretely, the following two phases alternate within each task: 1. A TypiClust selection step to find the most typical samples from the densest regions of the current unlabeled pool. 2. A Core-Set selection step to identify samples that maximally extend the geometric coverage of the already-labeled set by applying the greedy k-center heuristic. This strict alternation prevents any prolonged period of strategic misalignment and ensures that the cumulative labeled set simultaneously captures the distributional core of each class and spans the broader feature space. The choice to initialize the alternation sequence with TypiClust rather than Core-Set is not arbitrary. At the onset of the first active learning cycle for each task, the model has had no opportunity to observe any labeled samples from the incoming classes, placing it in a cold-start condition where prediction-based methods are unreliable. In this regime, beginning with TypiClust ensures that the first queried samples are prototypical, representatives of the underlying distribution. This initialization provides a stable foundation for the subsequent Core-Set phase, which can then exploit the labeled anchors already placed in high-density regions to identify the largest remaining unlabeled voids and extend coverage outward. Figure 2: Average accuracy across sequential tasks on the GRABMyo dataset for four active learning query strategies (TypiClust, CoreSet, Uncertainty-margin, Random) combined with two replay mechanisms (ER: solid lines; ASER: dashed lines).TypiClust-ER achieves the highest final accuracy (55%), while uncertainty-margin and CoreSet paired with ASER exhibit the steepest forgetting curves. Table 1: Overview of the TSCIL benchmark datasets. d denotes the channel dimensionality and τ the sequence length. Dataset Shape (d×τd×τ) Train size Test size #Classes #Tasks UCI-HAR 9×1289× 128 5,952 2,947 6 3 UWave 3×3153× 315 722 3,582 8 4 GRABMyo 28×12828× 128 20,315 7,525 10 5 WISDM 3×2003× 200 10,825 4,010 12 6 5 Experimental Setting 5.1 Benchmark Datasets We evaluate our approach on the benchmark datasets established in the TSCIL (Time Series Class-Incremental Learning) framework [qiao2024class]. These datasets encompass a diverse range of time series classification tasks, varying in sequence length, channel dimensionality, application domain, and complexity. All datasets consist of fixed-length multivariate time series with a consistent shape d×τd×τ, where d represents the number of channels and τ denotes the temporal length of each sequence. Table 5.1 provides a comprehensive overview of the datasets, including their dimensionality, train/test splits, class counts, and task divisions for the incremental learning setting. UCI-HAR (Human Activity Recognition Using Smartphones) [anguita2013human] contains sensor data from smartphones worn by 30 subjects performing six daily activities (walking, walking upstairs, walking downstairs, sitting, standing, and laying). The dataset comprises 9-channel accelerometer and gyroscope readings sampled at 50 Hz, with each sequence containing 128 time steps. This dataset is widely used for evaluating activity recognition systems and represents a relatively balanced, moderate-complexity classification task. UWave is a gesture recognition dataset collected from accelerometer sensors [middlehurst2026multiverse]. It contains 3-channel time series of length 315, representing 8 different hand gestures performed by multiple users. Despite having the smallest training set among the benchmarks (896 samples), it presents challenges due to inter-subject variability and the temporal complexity of gesture patterns. GRABMyo is a hand gesture recognition dataset based on surface electromyography (sEMG) signals [jiang2022gesture]. It contains 28-channel sEMG recordings of length 128, capturing 16 different hand and wrist gestures. With over 36,000 training samples, GRABMyo is the largest dataset in our benchmark suite and presents unique challenges due to the noisy nature of sEMG signals and the subtle differences between certain gesture classes. WISDM (Wireless Sensor Data Mining) [kwapisz2011activity] is an activity recognition dataset collected from smartphone and smartwatch accelerometer sensors. It features 3-channel time series of length 200, representing 18 different activities including various forms of walking, running, and daily tasks. The dataset’s class imbalance and real-world collection conditions make it particularly challenging for incremental learning scenarios. We preserve the original train/test splits established in the TSCIL [qiao2024class] to ensure fair comparison with existing methods. For the incremental learning setting, classes are randomly shuffled and partitioned into mutually exclusive subsets corresponding to sequential tasks, as described in Section 4.1. This partitioning simulates realistic scenarios where new classes arrive over time and must be learned without access to previous task data. 5.2 Evaluation Metrics We follow the standard TSCIL task construction protocol. For each dataset, classes are randomly permuted and partitioned into tasks with mutually exclusive label spaces. To ensure robustness against class ordering effects, all experiments are repeated with five independent runs with distinct random class orderings. Let acci,jacc_i,j denote the classification accuracy on the test set of task j after completing the training of task i (where j≤ij≤ i). We report the following metrics, averaged over the five runs with 95% confidence intervals: Average Accuracy (AiA_i): The average accuracy at the end of task i is defined as: Ai=1i∑j=1iacci,jA_i= 1i _j=1^iacc_i,j (10) The final average accuracy ACCACC corresponds to ATA_T and serves as the primary summary metric for overall performance. Learning Accuracy: To assess the model’s ability to acquire new knowledge (plasticity), we calculate the learning accuracy acci,iacc_i,i on the current task immediately after learning it and the average learning accuracy AcurA_cur, which is the average of the task accuracies: Acur=1T∑i=1Tacci,iA_cur= 1T _i=1^Tacc_i,i (11) Average Forgetting (FiF_i): Forgetting measures the performance drop on previous tasks. For a specific task j<ij<i, where i>1i>1, forgetting is defined as: fi,j=maxk<iacck,j−acci,jf_i,j= _k<i\,acc_k,j-acc_i,j (12) The average forgetting after task i is: Fi=1i−1∑j=1i−1fi,jF_i= 1i-1 _j=1^i-1f_i,j (13) FTFT (FTF_T) defines the Final Average Forgetting after all tasks have been learned. Moreover, we define the Stability metric as the retention of previously acquired knowledge after learning all tasks: Stability=Acurr−FTStability=A_curr-FT (14) where AcurrA_curr is the average accuracy on the current task and FT=FTFT=F_T is the Final Average Forgetting, measuring the average performance drop on previous tasks after the full task sequence has been learned. This metric is shown in Figure 3 to compare all the methods under the stability (Stability) and plasticity (AcurrA_curr). Figure 3: Plasticity vs. Stability trade-off for each dataset under the Experience Replay (ER) approach. Methods closer to the top-right corner achieve a better balance between learning new tasks (plasticity) and retaining knowledge of previous ones (stability). 5.3 Model Architecture We employ the 1D-CNN backbone from the TSCIL framework [qiao2024class] across all experiments. The network fθf_θ is composed of a feature extractor fext:ℝd×τ→ℝhf_ext:R^d×τ ^h and a classifier fcl:ℝh→ℝ|≤t|f_cl:R^h ^|C_≤ t|, such that fθ(x)=fcl(fext(x))f_θ(x)=f_cl(f_ext(x)). The feature extractor fextf_ext consists of four convolutional blocks. Each block contains a 1D convolutional layer, Batch Normalization (BN), ReLU activation, 1D max-pooling, and dropout as presented in paper [qiao2024class]. 5.4 Training Configuration We control the granularity of the active learning process via two parameters: the number of query cycles NaN_a and the total number of dataset partitions q. The query batch size is derived as b=⌈Ntq⌉b= N_tq , where NtN_t is the size of the current task’s dataset. The optimization mini-batch size BℓB_ is set equal to the query batch size, i.e., |Bℓ|=b|B_ |=b, and is sampled from the cumulative labeled set ℒt,aaccL_t,a^acc during training. For tasks t>1t>1, we maintain a balanced replay strategy with |Bℓ|=|BM||B_ |=|B_M|, where BMB_M denotes the memory replay batch, resulting in a total mini-batch size of |B|=2b|B|=2b. The configurations were chosen to balance annotation costs with learning stability. UCI-HAR employs fine-grained partitioning (q=300q=300) with a strict budget ratio (ρ=0.01ρ=0.01), whereas other datasets utilize coarser partitioning (q∈20,25,40q∈\20,25,40\) with ratios between 0.120.12 and 0.300.30. We utilize the following optimization protocol: • Optimizer: Adam with an initial learning rate of 10−310^-3. • Stopping Criterion: Training proceeds for up to 100100 epochs per cycle, utilizing early stopping based on validation loss to prevent overfitting on small query batches. The same backbone architecture, hyperparameters, and training schedule are used for all memory-based baselines (e.g., ER, ASER) to ensure fair comparison of query strategies. Memory Buffer Configuration Similar to the TSCIL benchmark, we retain the original CIL replay-memory configuration, where the memory is nominally set to 5%5\% of the training-set size. While active learning imposes strict annotation budgets, this does not necessitate reducing the consolidated memory capacity. Dataset Metric Uncertainty-based Distribution-aware Random Entropy Margin LC CoreSet TypiClust TypiCore (ours) UCIHAR ACC↑ 67.8467.84 69.5469.54 69.8369.83 72.5272.52 63.1963.19 75.2675.26 70.7070.70 FT ↓ 36.3036.30 28.7928.79 36.7036.70 29.3629.36 47.6647.66 29.9729.97 35.6935.69 AcurrA_curr ↑ 91.9591.95 87.5387.53 94.2994.29 92.0992.09 94.9794.97 95.2495.24 94.4994.49 UWave ACC↑ 77.0177.01 75.4675.46 78.4578.45 76.7976.79 74.7774.77 81.0381.03 82.8882.88 FT ↓ 21.8521.85 21.8621.86 17.9017.90 23.0823.08 26.3226.32 16.6416.64 16.3516.35 AcurrA_curr ↑ 93.4093.40 91.8691.86 91.8391.83 94.1094.10 94.5094.50 93.5193.51 95.1495.14 GRABMyo ACC↑ 51.2551.25 44.8744.87 49.1749.17 49.5849.58 44.0944.09 54.8954.89 56.1056.10 FT ↓ 23.9923.99 20.7620.76 32.5432.54 32.0632.06 53.1153.11 22.4022.40 29.2729.27 AcurrA_curr ↑ 67.6667.66 60.2160.21 75.0975.09 75.0675.06 86.5786.57 69.2069.20 78.3478.34 WISDM ACC↑ 46.4146.41 36.0236.02 42.6642.66 41.1341.13 40.9040.90 50.6950.69 51.7351.73 FT ↓ 40.2940.29 31.7831.78 40.1240.12 34.4734.47 50.9950.99 41.2741.27 39.1239.12 AcurrA_curr ↑ 79.7679.76 62.5062.50 76.1076.10 69.8569.85 83.3983.39 85.0885.08 84.2584.25 Table 2: Results across datasets and query strategies for Experience Replay (ER) Dataset Metric Uncertainty-based Distribution-aware Random Entropy Margin LC CoreSet TypiClust TypiCore (ours) UCIHAR ACC↑ 63.0063.00 61.1061.10 62.5762.57 57.4657.46 63.0363.03 62.5262.52 69.1169.11 FT ↓ 46.2446.24 43.6643.66 45.8045.80 53.1553.15 46.9946.99 47.0247.02 38.8938.89 AcurrA_curr ↑ 93.8393.83 88.5088.50 92.8792.87 92.9092.90 94.3694.36 93.8693.86 95.0495.04 UWave ACC↑ 59.7559.75 60.9660.96 61.4061.40 62.5362.53 61.1061.10 62.2662.26 63.6563.65 FT ↓ 43.2343.23 41.8541.85 44.2944.29 40.0040.00 44.6744.67 41.1741.17 42.3942.39 AcurrA_curr ↑ 92.1892.18 92.3592.35 94.6294.62 92.5392.53 94.6094.60 93.1493.14 95.4495.44 GRABMyo ACC↑ 49.7949.79 42.8342.83 46.0746.07 46.0646.06 41.1941.19 52.9152.91 52.8452.84 FT ↓ 31.3831.38 23.3123.31 27.5427.54 30.4230.42 53.8553.85 29.8029.80 32.8832.88 AcurrA_curr ↑ 73.3873.38 58.8258.82 67.2667.26 69.6869.68 84.1884.18 76.3576.35 78.1878.18 WISDM ACC↑ 42.9342.93 37.5637.56 42.3042.30 39.3939.39 39.6539.65 47.3747.37 47.9847.98 FT ↓ 42.8842.88 28.3428.34 40.4040.40 33.7533.75 51.3151.31 44.0044.00 42.3542.35 AcurrA_curr ↑ 78.3778.37 60.0760.07 75.9775.97 67.5167.51 82.4182.41 84.0484.04 83.2783.27 Table 3: Results across datasets and query strategies for ASER 6 Results aspects Random Entropy Margin LC CoreSet TypiClust TypiCore ER 4.504.50 4.924.92 4.504.50 4.084.08 5.255.25 2.582.58 2.172.17 ASER 4.504.50 4.924.92 4.084.08 4.584.58 4.504.50 3.253.25 2.172.17 ACC 4.004.00 6.126.12 4.004.00 4.504.50 5.755.75 2.252.25 1.381.38 All 4.50∗4.50^* 4.92∗4.92^* 4.29∗4.29^* 4.33∗4.33^* 4.88∗4.88^* 2.922.92 2.172.17 Table 4: Comparison of rank averages of methods from several perspectives. Smaller is better, and the best average rank in each row is highlighted by bold characters. Competing methods that were significantly outperformed by our method (i.e., the pairwise p-value was less than 0.02 in the Nemenyi test) were marked with an asterisk in the last row. Method UCIHAR UWave GRABMyo WISDM Fine-Tuning 32.9 26.0 19.4 15.5 Joint Training 93.9 96.6 93.8 85.7 LwF 40.0 47.3 19.4 15.9 MAS 48.0 51.9 16.9 11.2 ER 72.8 72.7 46.5 41.7 ASER 89.1 83.2 55.9 51.6 Random (ER) 67.84 77.01 51.25 46.41 Random (ASER) 63.00 59.75 49.79 42.93 Unc-Entropy (*) 69.54 75.46 44.87 36.02 Unc-Margin (*) 69.83 78.45 49.17 42.66 Unc-LC (*) 72.52 76.79 49.58 41.13 CoreSet (*) 63.19 74.77 44.09 40.90 TypiClust (*) 75.26 81.03 54.89 50.69 TypiCore (ER) 70.70 82.88 56.10 51.73 TypiCore (ASER) 69.11 63.65 52.84 47.98 Table 5: ACC results across datasets including baselines, continual learning methods, and active learning strategies. TypiCore is reported under ER and ASER settings. The sign (*) means the better version among ER and ASER variants. CIL Reference corresponds to the active-task (AT) performance of the continual learning reference model under ER and ASER. 6.1 Uncertain-based Methods Tables 2 and 3 report the full performance comparison across all query strategies under the ER and ASER replay settings, respectively. In each experiment, the annotation was limited according to the active learning scenario, which was solved differently: the Random method used random selection; the Uncertainty-based and Distribution-aware methods solved the problem based on scores specified in their algorithms. Across both ER and ASER, uncertainty-based strategies consistently fail to improve over random selection and frequently degrade performance. Under ER, entropy sampling reduces ACC on GRABMyo from 51.25 to 44.87 and on WISDM from 46.41 to 36.02, a drop of more than ten percentage points on the latter. Learning accuracy (AcurrA_curr) follows the same pattern: entropy with ER reaches only 62.50 on WISDM against the random baseline of 79.76. The degradation is equally pronounced under ASER. Margin sampling is the most competitive of the three uncertainty variants, occasionally matching or slightly exceeding the random baseline in ACC (e.g., 78.45 vs. 77.01 on UWave with ER), but it never establishes a consistent advantage. Therefore, the systematic underperformance of uncertainty methods across datasets and replay strategies confirms that boundary-focused selection is fundamentally misaligned with the requirements of rehearsal-based continual learning. 6.2 Distribution-aware Methods The results for distribution-aware methods are reported in Tables 2 and 3 for ER and ASER, respectively, and the accuracy trends across sequential tasks on GRABMyo are shown in Figure 2. CoreSet produces a sharp and consistent plasticity–stability trade-off. Under ER, it achieves the highest or near-highest AcurrA_curr on several datasets, reaching 94.97 on UCI-HAR, 94.50 on UWave, and a striking 86.57 on GRABMyo, outperforming the random baseline by nearly nineteen percentage points on the latter. However, this immediate learning gain comes at a severe cost to long-term retention: FT on GRABMyo rises to 53.11 under ER and 53.85 under ASER, more than doubling the random baseline values of 23.99 and 31.38, respectively. TypiClust presents the inverse profile. It consistently achieves competitive or best-in-class ACC values under ER, reaching 75.26 on UCI-HAR, 81.03 on UWave, 54.89 on GRABMyo, and 50.69 on WISDM, all above their respective random baselines. Its FT figures are also among the lowest across all strategies, particularly on UCI-HAR (29.97) and UWave (16.64). Under ASER, TypiClust’s advantage over the random baseline largely disappears, with ACC values close to or below random on UCI-HAR (62.52 vs. 63.00) and UWave (62.26 vs. 59.75), suggesting that its benefits are more strongly realized when paired with the simpler replay mechanism. 6.3 Our Approach Tables 2 and 3 present that TypiCore achieves the best overall ACC on three out of four datasets under ER (82.88 on UWave, 56.10 on GRABMyo, 51.73 on WISDM) and under ASER as well, including a clear margin over all other methods on UCI-HAR (69.11 vs. the next best of 63.03 for CoreSet-ASER). We created a ranking based on the values (under Experience Replay) of the Table 4 by sorting all seven methods (in the case of ACC and AcurrA_curr, the method with the highest value received rank 1, while in the case of FT, the method with the lowest value was the best). The average rank of the three indicators calculated on the four data sets (out of a total of twelve data) is shown in the first row of the Table 4. The best average rank in each row is highlighted by bold characters. We calculated the same for the ASER values also, and the corresponding average ranks are shown in the 2nd row of this table. Since the ACC is the most important indicator for us, we examined and averaged the ACC ranks separately (on all data sets, with both ER and ASER); these average ranks are placed in the 3rd row. The last row shows the average of all rankings (i.e. not only ACC, but also the other two indicators). For the last row (since this is already calculated from the average of 24 data), we performed a Friedman test, which shows with a p-value of 7.1−067.1^-06 that there is a significant difference between the methods. Then, we performed a post-hoc Nemenyi test between TypiCore and all competing methods. Setting the significance level to 98%, we marked with an asterisk those competing methods that our method significantly outperformed (i.e. the pairwise p-value was less than 0.02). As can be seen from the table, TypiCore achieved significantly better values than all competitors (except one). Figure 3 further contextualizes these results by examining the plasticity–stability trade-off across all query strategies. TypiCore consistently occupies the top-right region of the plot, indicating that its accuracy gains do not come at the expense of catastrophic forgetting. Notably, CoreSet, despite achieving competitive AcurrA_curr scores, suffers from substantially higher forgetting, resulting in lower stability across all four datasets. 6.4 Comparison among CL methods Table 5 places the active learning results within the wider context of continual learning methods, where TypiCore-ER is the best on three datasets, and the second best on UCIHAR dataset. The methods in the first two blocks (marked in italics) are those that used full labeled dataset, unlike the methods below them, which only had a limited number of such instances available. The second block contains methods that were developed exclusively for continuous learning. Regularization-based approaches such as LwF [li2017learning] and MAS [aljundi2018memory] remain far below all rehearsal methods, with ACC values as low as 11.2 (MAS on WISDM) and 16.9 (MAS on GRABMyo). Fine-tuning, as expected, collapses to near-chance performance across all datasets. Joint training (where there is no annotation limit and no forgetting, as the model learns all classes simultaneously), establishes the practical upper bound, reaching 93.9 on UCI-HAR and 93.8 on GRABMyo. Both TypiCore versions (ER and ASER) surpass the fully supervised LwF and MAS methods on all datasets, demonstrating that intelligent sample selection can compensate for the absence of full label supervision. One possible reason is that by systematically selecting prototypical and geometrically diverse samples, TypiCore effectively filters out noisy, redundant, or ambiguous annotations that, when included indiscriminately under full supervision. A consistent finding across all strategies is that ER outperforms ASER in the active learning setting. The gap is particularly pronounced for TypiCore on UWave, where TypiCore-ER achieves 82.88 versus 63.65 for TypiCore-ASER. Under severe annotation budgets, the simpler and more robust random rehearsal mechanism of ER appears better suited to the constraints of the active learning regime. 7 Conclusion In this paper, we addressed the problem of Active Class-Incremental Learning (ACIL) for multivariate time series classification, a setting that combines the sequential nature of continual learning with the practical constraint of limited label availability. We conducted a systematic evaluation of a broad range of active learning query strategies integrated into rehearsal-based continual learning approaches. We assessed their impact on plasticity, stability, and label efficiency across four benchmark datasets from the TSCIL framework. Our analysis revealed several key insights. Uncertainty-based methods consistently fail to improve over random selection and frequently degrade performance in the ACIL setting, as boundary-focused sample selection is fundamentally misaligned with the requirements of memory-based replay. Distribution-aware methods have better performance, but neither strategy alone achieves a robust and consistent balance across datasets and task sequences. Motivated by these findings, we proposed TypiCore, a novel hybrid query strategy that dynamically alternates between typicality-based and diversity-based selection across active learning cycles. By initializing each task with a TypiClust step to anchor prototypical samples in high-density regions, and subsequently applying CoreSet to extend coverage into underrepresented areas of the feature space, TypiCore constructs memory buffers that are simultaneously representative and diverse. Evaluated on the TSCIL benchmark, TypiCore achieves statistically significant improvements over all baselines under both ER and ASER replay settings, and on several datasets exceeds the performance of fully supervised continual learning methods while annotating a fraction of the available data. This shows that intelligent label selection can act as an implicit regularizer, filtering out noisy and redundant samples that would otherwise destabilize rehearsal-based learning. Moreover, a consistent finding across all experiments is that the simpler ER mechanism outperforms ASER in the active learning regime, particularly under severe annotation budgets. This suggests that the importance-driven memory management of ASER, while effective under full supervision, may be less robust when the labeled pool is small and potentially unrepresentative in early cycles. Future work will explore several promising directions. First, future methods could consider dynamic budget allocation: rather than distributing the annotation budget uniformly across tasks, methods could estimate the degree of distribution shift between incoming and previously seen data, and allocate more labeling resources to tasks that deviate most significantly from prior knowledge, as these are likely to require more annotated samples to be learned effectively without destabilizing the existing memory buffer. Second, future work could investigate more complex scenarios that combine elements of both Domain-Incremental and Class-Incremental Learning, where the same classes may reappear across tasks with shifted distributions alongside the introduction of entirely new ones. In this setting, the model must simultaneously distinguish between genuine new knowledge and distributional variations of already-known classes, posing new challenges for both query strategy design and memory management. References