Class-incremental learning

Class-incremental learning aims to enable a model to effectively retain knowledge of previously learned classes while continuously receiving information about new classes [11,19,20], thus avoiding catastrophic forgetting. Existing methods mainly fall into three categories: regularization methods, replay methods, and dynamic network methods. Among them, regularization methods [21–24] introduce additional constraints during training to limit the update magnitude of critical parameters, maintaining stable representations of old tasks. Replay methods preserve a portion of samples from old tasks [8,25,26] or use generative models to synthesize old-class data [27,28], and jointly train them with new data to help the model retain previously learned knowledge. Dynamic network methods expand the model structure [4, 5, 6, 7, 8, 29–31], for example, by adding new neurons, layers, or task-specific modules, effectively isolating knowledge between tasks and thereby improving the model’s ability to jointly adapt to and learn from both old and new tasks.

Pre-trained model-based CIL

Class-incremental learning based on pre-trained models (PTMs) [11,31–33] has become a research hotspot in recent years. With the development of pre-training techniques, an increasing number of methods incorporate PTMs into class-incremental learning to enhance model performance and generalization ability. These methods typically keep the pre-trained weights frozen and achieve lightweight parameter updates through prompt tuning [15–18], encoding new task features into a prompt pool to effectively alleviate forgetting. In addition, some approaches adopt model fusion or model merging strategies [9,31,34–37] by saving and integrating models from multiple training stages to further improve the retention of old knowledge. Prototype-based classification methods leverage the powerful representations of PTMs combined with nearest class mean (NCM) classifiers [19,38–40] to achieve stable recognition of old classes.

Problem definition

Class-Incremental Learning (CIL) is a learning scenario where a model continuously learns to classify new classes to build a unified classifier [1]. Given a sequence of B training datasets denoted as , where the b-th dataset is containing instances. Each instance comes from class . Here, is the label space of task b, and for , , meaning the classes across different tasks do not overlap. We follow the exemplar-free setting in [16], where no samples from old classes are saved. Therefore, at the b-th incremental stage, we only have access to data from for training. In CIL, our goal is to build a unified classifier for all seen classes as data evolves. Specifically, we want to find a model that minimizes the expected risk:

(1)

where is the hypothesis space, is the indicator function, and denotes the data distribution of task b. Following typical PTM-based CIL works [16–18], we assume a pretrained model is available for initializing f(x). We decouple the PTM into a feature embedding and a linear classifier . The embedding function refers to the final [CLS] token in ViT, and the model output is expressed as . For clarity, we decouple the classifier as , where is the classifier weight for the j-th class.

Model overview

Dynamic Gated Adapter for Subspace Alignment (DGASA) is an efficient framework specifically designed for class-incremental learning (CIL), with its overall workflow illustrated in Fig 2. In the base class training stage, DGASA freezes the pretrained backbone network, which serves as a shared feature extractor across all tasks. On top of this backbone, a set of Gated Adapter (GA) modules is introduced for each incremental task to construct task-specific embedding subspaces. This design enables effective task isolation and alleviates catastrophic forgetting.

Download:

• PNG
  larger image
• TIFF
  original image

Fig 2. Inference pipeline of the proposed DGASA framework.

GA modules are inserted in each Transformer block for task-specific adaptation.

https://doi.org/10.1371/journal.pone.0348270.g002

As tasks incrementally progress, the feature subspaces continuously evolve and expand, potentially rendering old class prototypes ineffective in the current subspace. To address this, DGASA proposes a subspace drift compensation mechanism, which leverages prototype pairs of new classes generated from both the old and current subspaces as supervision signals. A linear mapping is then learned to explicitly project old class prototypes from their original subspace into the current one. This process requires no access to data from previous tasks, thereby maintaining prototype consistency while ensuring privacy friendliness.

During the inference stage, DGASA incorporates an instance-aware adaptive weighting mechanism to enable collaborative decision-making across multiple subspaces. Specifically, the model adjusts the contribution of each subspace to the final classification result based on how well the test sample matches the class prototypes in each subspace. The primary task subspace provides the main discriminative power, while the remaining subspaces are weighted based on their semantic saliency scores, leading to more refined and robust ensemble predictions.

In summary, DGASA integrates pretrained knowledge sharing, task-adaptive subspace modeling via GA modules, prototype mapping compensation, and saliency-aware inference into a unified multi-subspace incremental learning framework. Without requiring access to old data, it achieves excellent generalization, memory efficiency, and resistance to forgetting.

Gated Adapter (GA) Module

In Class-Incremental Learning (CIL), a typical challenge lies in fine-tuning pre-trained models on new tasks without incurring significant computational overhead or suffering from catastrophic forgetting. Full fine-tuning of the entire model requires extensive computation and may cause the model to forget previously learned tasks. To address this, we propose a more parameter-efficient solution using adapter modules, which offer a lightweight way to incorporate task-specific knowledge into pre-trained models. Adapters are small bottleneck structures inserted within each Transformer layer, allowing task-specific adaptations while keeping the core model frozen.

Our approach builds on this concept and introduces a Gated Adapter (GA) module, which enhances the standard adapter’s flexibility by incorporating a gating mechanism to control activation dynamically. We clarify the naming: while the term attention-gated was used in earlier versions, the actual mechanism is a pooled linear gating rather than standard QKV attention. Specifically, each Transformer layer in the backbone network contains a feed-forward module with an additional gated residual branch, which is activated conditionally based on the input features. For an input feature , the output is formulated as:

(2)

where and are weight matrices that reduce and then expand the dimensionality, is a nonlinear activation function (GELU), and g(x) is the gating function defined as:

(3)

where is a linear transformation parameter, and performs global average pooling across the input feature dimensions. This pooling step captures high-level characteristics of the input, producing a scalar gate that adaptively weights the importance of the residual branch.

Module vs. Framework Distinction. To avoid confusion, we explicitly distinguish:

• GA module: The individual gated adapter unit inserted in each Transformer layer (Fig 3). This is the basic building block for task-specific adaptation.
• DGASA framework: The complete method comprising: (1) a frozen pre-trained backbone, (2) a set of GA modules for each task, (3) the drift compensation mechanism for prototype alignment, and (4) the adaptive weighting mechanism for inference.

Download:

• PNG
  larger image
• TIFF
  original image

Fig 3. Architecture of the Gated Adapter (GA) module.

The gating mechanism uses global pooling followed by a linear layer with sigmoid activation to produce a scalar gate g(x), which modulates the adapter residual branch.

https://doi.org/10.1371/journal.pone.0348270.g003

When the b-th task arrives, we introduce a new set of GA modules (one per Transformer layer) denoted as . As tasks progress, the model accumulates an adapter sequence . During inference, we concatenate the outputs of each task adapter to construct a joint feature representation:

(4)

where denotes the feature mapping through the GA modules of task b.

Since training for each task only optimizes its corresponding GA modules, learning new tasks does not affect knowledge retention of old tasks. Each GA module contains (2 dr + d) parameters, so the total storage cost is , where B is the number of tasks and L is the number of Transformer blocks (12 for ViT-B/16). With d = 768 and r = 16, each GA module has 25,344 parameters, totaling 304,128 parameters per task.

For classification prediction, we adopt a prototype-based classifier. After training the b-th task, we extract the prototype of the i-th class in the adapter subspace :

(5)

where denotes the training sample set of class i in task b, and . Then, the prototype vectors of this class in all task subspaces are concatenated to form the joint prototype:

(6)

During prediction, cosine similarity is used to compare the input feature embedding with the class prototypes , and the class with the highest similarity is chosen as the predicted label.

Reconstructing prototypes under distribution drift

In incremental learning, as new tasks and distributions arrive, the model adapts by adding new adapters that construct embedding subspaces for each task. However, a challenge arises when it becomes necessary to recompute the prototypes for each class to ensure consistency with the current feature embedding space. Since accessing past data is often not feasible, directly computing the prototypes of old classes in the new subspace is problematic, leading to a mismatch between the prototype matrices at different stages of learning. This mismatch impacts the classifier’s ability to provide a unified and accurate representation of the feature space across all tasks.

To address this issue, we formalize it as a prototype completion task. Given two embedding subspaces (old and new) and two class sets (old and new), we aim to estimate the prototypes of old classes in the new subspace, denoted as , by leveraging the following three observable prototype matrices: prototypes of old classes in the old subspace , prototypes of new classes in the old subspace , and prototypes of new classes in the new subspace .

To reconstruct the prototypes, we adopt the concept of drift compensation [41], which models the geometric transformation between embedding subspaces. Unlike semantic-based approaches, this formulation does not rely on semantic similarity between classes, making it applicable even when new classes are sparse or semantically distant.

Specifically, we construct a paired sample set using the prototypes of new classes in both the old and new subspaces. These paired prototypes serve as anchors to estimate a linear mapping from the old subspace to the new subspace. We formulate the mapping estimation as a least-squares problem:

(7)

which admits a closed-form solution via the normal equations:

(8)

After obtaining the mapping matrix W, we reconstruct the prototypes of old classes by projecting the old subspace prototypes into the new subspace:

(9)

This projection does not require access to past data and enables consistent prototype alignment across tasks. In addition to downstream classification accuracy, we also evaluate the quality of drift compensation using direct metrics such as prototype reconstruction error and cosine similarity before and after alignment.

Mapping Strategy: It is crucial to clarify that the mapping matrix W is estimated globally with respect to all previously learned tasks, rather than being composed sequentially between adjacent tasks. Specifically, when a new task b arrives, the old subspace is defined by the concatenated feature space of all previous adapters , and the new subspace is defined by the concatenated space including the new adapter . The prototypes of the new classes ( and ) are computed in these two respective subspaces and used to solve for a single, unified mapping W. This global mapping is then applied to all old class prototypes () to project them into the new subspace. This approach ensures that the mapping is solved only once per incremental session and avoids the potential for error accumulation that could arise from composing multiple sequential transformations. Computationally, solving this mapping requires operations per task, which is negligible compared to the cost of training the adapters.

Numerical Stability and Robust Formulation. In practice, the matrix may be ill-conditioned or even singular, particularly when the number of new classes is small relative to the embedding dimension d, or when the prototype matrix is rank-deficient. In such cases, directly computing the inverse may lead to numerical instability and degraded reconstruction quality.

To address this issue, we adopt a regularized least-squares formulation based on ridge (Tikhonov) regularization:

(10)

where is a regularization parameter and I is the identity matrix. This formulation improves numerical stability by ensuring that the matrix to be inverted is well-conditioned. In addition, we consider an alternative formulation based on the Moore–Penrose pseudoinverse:

(11)

which provides a minimum-norm solution even when is rank-deficient.

In our implementation, is selected as a small constant (e.g., ) and further validated via a sensitivity analysis. We empirically evaluate the robustness of the mapping with respect to , the number of new classes, and the conditioning of .

After obtaining the mapping matrix W, we reconstruct the prototypes of old classes by projecting the old subspace prototypes into the new subspace:

(12)

This projection does not require access to past data and enables consistent prototype alignment across tasks. In addition to downstream classification accuracy, we also evaluate the quality of drift compensation using direct metrics such as prototype reconstruction error and cosine similarity before and after alignment.

Adaptive weighting by instance-level significance

So far, we have introduced subspace expansion and adapter incremental learning mechanisms, and restored the prototypes of old classes through a prototype completion strategy. After completing adapter expansion and prototype completion, we construct a complete classifier with the following prototype matrix:

(13)

where the off-diagonal terms above the main diagonal are completed according to the estimation formula.

During inference, to obtain the classification logits for the b-th task, we perform multiple prototype-embedding matches across different subspaces and aggregate them into the final score:

(14)

where denotes the features extracted by the i-th adapter . Although this ensemble approach helps leverage information from multiple subspaces, we note that only the adapter corresponding to the b-th task is specifically trained for that task, so the features are more task-discriminative.

To address this, we propose a new inference mechanism — Adaptive Weighting by Instance-level Significance. Its core idea is to quantify the matching degree of the input sample across different subspaces and dynamically adjust each subspace’s contribution weight to the final classification result based on this significance. Compared to using fixed scaling coefficients for all non-primary subspaces, our method is more flexible and better reflects the semantic correlation between the sample and each subspace.

The specific steps are as follows:

First, compute subspace significance. For a given input sample x, we input it into all adapters corresponding to the subspaces and extract feature representations for each subspace. Then, we calculate the similarity between these features and the corresponding prototypes to measure the matching degree of the sample in the i-th subspace. This matching degree is called the significance score , calculated as:

(15)

where denotes a similarity function; here, we use cosine similarity. Note that to emphasize the primary subspace for the current task, we compute significance only for non-primary subspaces .

Next, normalize the significance scores into a weight distribution. To ensure comparability of contributions across subspaces, we apply the softmax function to the significance scores to obtain the weight distribution for each non-primary subspace:

(16)

This normalization can be seen as an adaptive attention allocation over all non-primary subspaces, where higher significance scores correspond to larger weights, thereby enhancing the role of that subspace in the final inference.

Finally, construct the weighted classification score. After obtaining the primary subspace matching score , we combine it with the significance-weighted scores of all non-primary subspaces to obtain the final classification logits:

(17)

where is a balancing parameter controlling the relative contribution of non-primary subspaces in the overall score. In our experiments, we set .

Experiments

To analyze the impact of each component on the overall performance of the model, we performed ablation experiments on the Cifar-100 dataset for the Inc5 task, validating the effectiveness of the four key components proposed: PTM, Attention-Gated Adapter, Reconstructing Prototypes under Distribution Drift, and Adaptive Weighting by Instance-level Significance. The experimental results confirm the effectiveness of these methods. In this section, we first provide an overview of the datasets and evaluation metrics used, followed by a comprehensive description of the model architecture and experimental setup. We then present and analyze the results of the comparative experiments. Finally, we conduct ablation studies to validate the effectiveness of each component of the model.

Datasets

Since pre-trained models may possess extensive knowledge from upstream tasks, they are often evaluated on a variety of datasets to assess their transferability and generalization capabilities in different learning scenarios. In this work, we follow the experimental setups in [18,19] to evaluate performance on several widely-used benchmark datasets, including CIFAR-100 [42], CUB-200 [43], ImageNet-R [44], ObjectNet [45], and OmniBenchmark [46]. These datasets are particularly useful for evaluating class-incremental learning (CIL) approaches, as they consist of a variety of task distributions and domain shifts. The datasets we use for evaluation include both standard CIL benchmarks and out-of-distribution datasets, offering a wide range of challenges that test the model’s ability to generalize across domains. CIFAR-100 consists of 100 classes, which are commonly used in incremental learning tasks. CUB-200, containing 200 classes, is widely used for fine-grained recognition and provides a higher level of class granularity. ImageNet-R and ObjectNet, each containing 200 classes, represent more challenging benchmarks, as they come from distribution shifts or domain gaps compared to the ImageNet dataset, which is typically used for pre-training. OmniBenchmark, with 300 classes, is another large-scale benchmark that provides diverse challenges in out-of-distribution testing, offering a more complex scenario for evaluating domain adaptation and generalization. These datasets provide a comprehensive testing ground for evaluating both generalization to new tasks and robustness in the face of domain drift.

Dataset split: To ensure consistency and comparability across different methods, we follow the established benchmark settings outlined in [1,18]. Specifically, we use the notation Inc-n to represent the class split, where n indicates the number of classes introduced at each incremental stage. In this framework, the first training stage starts with zero classes, meaning the model must progressively learn to recognize new classes as they are introduced. This incremental learning setup closely mirrors real-world scenarios where a model must continually adapt to new information without the luxury of accessing previous data. For a fair comparison across all methods, we adopt the same random seed for shuffling the class order before performing data splitting, as recommended in [1]. This ensures that the class order is randomized in a consistent manner across all experiments, preventing any potential bias introduced by a particular class ordering. Furthermore, we maintain consistency in the training and testing sets by aligning them with the settings used in [19] across all compared methods. This consistent dataset partitioning ensures a rigorous and fair evaluation of the methods under consideration, allowing us to draw reliable conclusions about their performance in incremental and out-of-distribution learning tasks.

Evaluation metrics

Following the benchmark protocol [42], we use to represent the model’s accuracy after the b-th stage. Specifically, we adopt (the performance after the last stage) and

(18)

(the average performance over all incremental stages) as evaluation metrics

Implementation details

All experiments are conducted on a single NVIDIA RTX 4090 GPU (24 GB VRAM) using the PyTorch framework (version 2.0.1) [47]. Following prior works [18,19], we adopt a ViT-B/16 backbone pre-trained on ImageNet-21K (“vit_base_patch16_224” from the timm library, 86.6M parameters), and further fine-tuned on ImageNet-1K under the standard protocol. For all incremental tasks, DGASA is trained using the AdamW optimizer with , , and weight decay of 0.01. The initial learning rate is set to and decayed by a factor of 0.1 at 50% and 75% of the total training steps. We use a batch size of 64 and train for 15 epochs per task with an input resolution of . The training objective consists of a cosine-similarity-based cross-entropy loss over the current task classes, with temperature , where class prototypes are computed as the mean feature representations of all samples belonging to each class in the current subspace. It employs global average pooling for gating, GELU activation in the adapter, sigmoid activation for the gate, and a dropout rate of 0.1 applied to the adapter output. For prototype-based alignment, prototypes are updated after each task, and the drift compensation mapping is solved using ridge regularization with . The adaptive weighting coefficient is set to , selected via validation on a held-out subset. To ensure robustness, all experiments are repeated with five random seeds (42, 1234, 5678, 91011, 121314), and we report the mean and standard deviation. The class order is consistently shuffled across all methods for each seed to ensure fair comparison.

Comparisons with the State-of-the-arts

In this section, we provide a comprehensive evaluation of DGASA by comparing its performance with several state-of-the-art methods on five widely used benchmark datasets. The results, summarized in Table 1, show that DGASA achieves the best performance across all datasets, significantly surpassing existing methods, including CODA-Prompt and ADAM, when using the ViT-B/16-IN21K pre-trained model. Specifically, DGASA excels in both average accuracy across incremental stages and accuracy after the final incremental stage , outperforming the other methods by substantial margins.

Download:

• PNG
  larger image
• TIFF
  original image

Table 1. Comparison of different methods on five benchmark datasets. denotes average accuracy over incremental stages, and is the accuracy after the last stage. The best performance is shown in bold. All methods are implemented without using exemplars.

https://doi.org/10.1371/journal.pone.0348270.t001

To ensure a fair comparison, we selected several representative class-incremental learning (CIL) methods based on pre-trained transformers (PTMs), including both recent and classical approaches. These methods include L2P [18], DualPrompt [17], CODA-Prompt [16], SimpleCIL [19], EASE [31], and ADAM [19]. In addition, we also compare DGASA to traditional CIL methods that are equipped with the same pre-trained models, such as LwF [23], SDC [41], iCaRL [1], DER [29], FOSTER [8], and MEMO [11]. These comparisons provide a comprehensive evaluation of DGASA’s performance against the most prominent methods in the field.

The results from Table 1 clearly demonstrate the superiority of DGASA across all five benchmark datasets: CIFAR Inc5, CUB Inc10, IN-R Inc5, ObjNet Inc10, and Omnibench Inc30. For instance, DGASA achieves the highest average accuracy and final stage accuracy on CIFAR Inc5, with values of 92.11 and 86.25, respectively, outperforming the second-best method, EASE, by a notable margin. Similar trends are observed in the other datasets, where DGASA consistently outperforms the competing methods in both metrics. This highlights DGASA’s strong generalization ability and robustness across different incremental learning scenarios. In addition to comparing DGASA with other PTM-based CIL methods, we also evaluate its performance against traditional exemplar-based methods, as shown in Table 2. These traditional methods typically rely on storing a fixed number of exemplars for each class to mitigate catastrophic forgetting and maintain previous knowledge. For the comparison, we follow the standard practice in class-incremental learning by setting the number of exemplars to 20 per class, as in the method proposed by Rebuffi et al. [1]. Despite not utilizing exemplars, DGASA maintains competitive performance when compared to these exemplar-based methods. This is a significant achievement, as it shows that DGASA’s approach—which does not rely on memory replay or exemplar storage—can still effectively preserve knowledge and achieve superior performance across incremental learning tasks.

Download:

• PNG
  larger image
• TIFF
  original image

Table 2. Comparison of different methods with exemplar usage and accuracies on benchmark datasets.

https://doi.org/10.1371/journal.pone.0348270.t002

Overall, these results validate the effectiveness and efficiency of DGASA as a state-of-the-art method for class-incremental learning, demonstrating its ability to outperform both recent PTM-based approaches and traditional exemplar-based methods, all while avoiding the need for storing exemplars.

Ablation study

To analyze the impact of each component on the overall performance of the model, we performed ablation experiments on the Cifar-100 dataset for the Inc5 task, validating the effectiveness of the four key components proposed: PTM, Gated Adapter (GA) module, Drift Compensation, and Adaptive Weighting by Instance-level Significance. The experimental results, as shown in Table 3, confirm the effectiveness of these methods. Among them, PTM refers to using a frozen pre-trained model solely as a feature extractor; GA indicates the introduction of Gated Adapter modules for task-specific subspace modeling; Drift Compensation refers to compensating for the drift of old class prototypes through the Reconstructing Prototypes under Distribution Drift mechanism; Adaptive Weighting dynamically adjusts the contribution of different subspaces during inference using the Adaptive Weighting by Instance-level Significance method.

Download:

• PNG
  larger image
• TIFF
  original image

Table 3. Ablation Study Results on CIFAR-100 Inc5 Task.

https://doi.org/10.1371/journal.pone.0348270.t003

We next conducted an ablation study to investigate the impact of the number and positions of Attention-Gated Adapters on model performance, as shown in Table 4. The ablation results demonstrate that the insertion position of the Attention-Gated Adapter significantly affects model performance. Specifically, inserting Adapters into all layers (a total of 12) achieved the best performance on the CIFAR100 datasets, reaching 92.11% and 86.25%, respectively. This result indicates that full-layer insertion enables comprehensive feature adaptation from low-level to high-level representations while keeping the pre-trained parameters frozen, thereby enhancing the model’s expressiveness and generalization ability for new tasks. In contrast, inserting Adapters only in the early or late layers leads to slightly degraded performance due to limited adaptation scope.

Download:

• PNG
  larger image
• TIFF
  original image

Table 4. Ablation study on the number and positions of Attention-Gated Adapters.

https://doi.org/10.1371/journal.pone.0348270.t004

An additional ablation study was conducted to evaluate the effect of the inference weighting coefficient , with results summarized in Table 5. The study demonstrates that significantly affects model performance. As increases from 0.05 to 0.15, performance steadily improves on both datasets, indicating that moderate amplification of the Adapter’s modulation of backbone features facilitates adaptation to new tasks. Further increasing to 0.2 or 0.25 slightly degrades performance, suggesting that excessive modulation disrupts the original feature distribution and reduces stability on previous tasks. Based on these observations, is selected as the optimal setting and is used consistently across all benchmarks, achieving the best balance between the main and non-main subspaces.

Download:

• PNG
  larger image
• TIFF
  original image

Table 5. Ablation study on the weighting coefficient .

https://doi.org/10.1371/journal.pone.0348270.t005

Finally, to verify the effectiveness of the proposed adaptive weighting mechanism, we conducted an ablation study comparing Adaptive Weighting by Instance-level Significance with the simpler Fixed Weight Fusion by Subspace Prototypes. Fig 4 presents the t-SNE visualizations of the feature embeddings generated by the two methods: Fig 4(a) corresponds to the adaptive weighting approach, while Fig 4(b) represents the fixed weight fusion baseline. The results clearly demonstrate that the adaptive weighting mechanism produces more compact clusters with higher inter-class separability, indicating improved class discriminability and better alignment of features within subspaces. This visualization confirms that incorporating instance-level weighting effectively enhances the model’s adaptability to incremental tasks, alleviates feature confusion, and leads to superior performance.

Download:

• PNG
  larger image
• TIFF
  original image

Fig 4. t-SNE visualization comparison between (a) Adaptive Weighting by Instance-level Significance and (b) Fixed Weight Fusion by Subspace Prototypes.

https://doi.org/10.1371/journal.pone.0348270.g004

Analysis

In this section, we provide a comprehensive analysis of DGASA across multiple dimensions, including parameter efficiency, inference cost, continual learning metrics, the adaptive weighting mechanism, and the stability of drift compensation.

Scalability and efficiency analysis

A key contribution of DGASA is its parameter-efficient design. To rigorously evaluate this claim, we provide a comprehensive analysis of model scalability, memory growth, and inference efficiency as the number of tasks B increases. All experiments are conducted on CIFAR-100 with the Inc5 setting (20 tasks total) using a single NVIDIA RTX 4090 GPU.

Parameter growth analysis

DGASA maintains a frozen pre-trained ViT-B/16 backbone and only adds lightweight adapters for each new task. The trainable parameters per adapter consist of:

• Down-projection: , with d = 768, r = 16
• Up-projection:
• Gating layer: (after pooling)

Thus, the number of trainable parameters per adapter is:

(19)

Since each Transformer block contains one adapter and ViT-B/16 has L = 12 blocks, the total parameters per task are:

(20)

After B tasks, the total trainable parameters are M, while the frozen backbone contains approximately 86 M parameters. Table 6 summarizes the parameter growth across different numbers of tasks.

Download:

• PNG
  larger image
• TIFF
  original image

Table 6. Parameter growth analysis across incremental tasks.

https://doi.org/10.1371/journal.pone.0348270.t006

Prototype memory cost

In addition to adapter parameters, DGASA stores class prototypes for classification. For each class, we store a prototype vector of dimension (concatenated across all task subspaces). The memory cost for prototypes is:

(21)

For CIFAR-100 with , B = 20, and d = 768, this equals:

(22)

Table 7 shows the prototype memory growth across tasks.

Download:

• PNG
  larger image
• TIFF
  original image

Table 7. Prototype memory cost across incremental tasks (CIFAR-100, 100 total classes).

https://doi.org/10.1371/journal.pone.0348270.t007

Inference latency and throughput

We measure inference efficiency by evaluating latency (ms per sample) and throughput (samples per second) as the number of tasks increases. For each test sample, DGASA must:

1. Forward pass through the frozen backbone (shared across all tasks)
2. Forward pass through all B task-specific adapters
3. Compute cosine similarity with class prototypes

The inference cost scales linearly with the number of adapters and prototypes.

As shown in Table 8, latency increases from 4.21 ms to 7.38 ms as tasks grow from 1 to 20, while throughput decreases from 237.5 to 135.5 samples per second. The FLOPs increase modestly (16.8 G to 18.4 G) since the frozen backbone computation dominates. Peak memory usage remains under 1.2 GB, well within typical GPU limits.

Download:

• PNG
  larger image
• TIFF
  original image

Table 8. Inference efficiency analysis across tasks (batch size = 64).

https://doi.org/10.1371/journal.pone.0348270.t008

Break-even analysis

To determine when modular growth begins to harm inference efficiency, we compare DGASA against two baselines:

• Full Fine-tuning: A single model updated on all data (upper bound on accuracy but suffers catastrophic forgetting)
• Static Adapter Baseline: A single adapter trained on the union of all tasks (lower memory but lower accuracy)
• We summarize the efficiency–accuracy trade-off under different numbers of tasks in Table 9.

Download:

• PNG
  larger image
• TIFF
  original image

Table 9. Break-even analysis: efficiency vs. accuracy trade-off. All results are reported on CIFAR-100 Inc5.

https://doi.org/10.1371/journal.pone.0348270.t009

Key observations:

1. Accuracy-efficiency trade-off: DGASA achieves significantly higher accuracy (86.25% vs. 49.08%) than the static adapter baseline, with only 1.75 higher latency (7.38 ms vs. 4.21 ms) after 20 tasks.
2. Break-even point: The modular growth begins to show diminishing returns in terms of efficiency around B = 10 tasks, where latency increases by approximately 35% compared to the single-task setting. However, the accuracy continues to improve from 84.52% (B = 5) to 86.25% (B = 20), demonstrating sustained performance gains from incremental adapter addition.
3. Comparison to full fine-tuning: Full fine-tuning achieves lower latency (4.21 ms) but catastrophically forgets previous tasks (19.71% accuracy). DGASA trades a modest 3.17 ms increase in latency for a 66.54% absolute accuracy improvement.

Practical recommendations: For applications with strict latency constraints (e.g., real-time systems), practitioners can limit the number of adapters by grouping tasks or using a smaller backbone. For most practical scenarios, DGASA’s linear scaling provides an acceptable trade-off given the substantial accuracy benefits.

Comprehensive CIL metrics analysis

To provide a more complete evaluation of DGASA’s performance beyond average and final accuracy, we report standard continual learning metrics: average forgetting, backward transfer (BWT), and old/new class accuracy splits.

Definition of metrics. Following standard practice [25,26], we define:

• Average Forgetting measures how much the model forgets previously learned classes:

(23)

where is the accuracy on task b after training task t.

• Backward Transfer (BWT) measures the influence of learning new tasks on old task performance:

(24)

where negative BWT indicates forgetting.

• Old vs. New Class Accuracy decomposes final-stage accuracy into performance on classes learned in previous tasks and classes learned in the current task.

Forgetting and backward transfer analysis. Table 10 reports average forgetting and backward transfer across all benchmark datasets.

Download:

• PNG
  larger image
• TIFF
  original image

Table 10. Forgetting and backward transfer analysis across benchmark datasets. Lower forgetting and higher (less negative) BWT indicate better preservation of old knowledge.

https://doi.org/10.1371/journal.pone.0348270.t010

Key observations:

• DGASA achieves the lowest forgetting across all datasets (4.87% on CIFAR, 5.23% on CUB, 5.56% on ImageNet-R), demonstrating superior stability in preserving old knowledge
• The backward transfer of DGASA is closest to zero among all methods (less negative), indicating that learning new tasks has minimal detrimental impact on previously learned classes
• The combination of low forgetting and high backward transfer confirms that our drift compensation mechanism effectively maintains old class representations

Old vs. New Class Accuracy Across Sessions. We analyze the evolution of old and new class accuracy across incremental sessions. Fig 5 shows the per-session accuracy decomposition for CIFAR-100 Inc5.

Download:

• PNG
  larger image
• TIFF
  original image

Fig 5. Old vs. new class accuracy across incremental sessions on CIFAR-100 Inc5.

https://doi.org/10.1371/journal.pone.0348270.g005

The analysis reveals:

• Old class accuracy remains stable throughout the incremental sequence (ranging from 85.2% to 86.1%), confirming effective mitigation of catastrophic forgetting
• New class accuracy is consistently high (around 87–89%), indicating strong adaptation to novel tasks
• The gap between old and new class accuracy is minimal (within 2–3%), demonstrating balanced performance across all classes

Statistical significance testing

To validate that DGASA’s improvements are statistically significant, we conduct paired t-tests comparing DGASA against the second-best method (EASE) across 5 random seeds. Table 11 reports the p-values.

Download:

• PNG
  larger image
• TIFF
  original image

Table 11. Statistical significance analysis (paired t-test, p-values). Values < 0.05 indicate significant improvement.

https://doi.org/10.1371/journal.pone.0348270.t011

Per-Task Accuracy Matrix. To provide a complete picture of performance across all tasks, Fig 6 presents the per-task accuracy matrix for CIFAR-100 Inc5, where entry (i, j) shows the accuracy on task j after training task i.

Download:

• PNG
  larger image
• TIFF
  original image

Fig 6. Per-task accuracy matrix on CIFAR-100 Inc5.

Diagonal entries show performance on the current task; off-diagonal entries show retention of previous tasks.

https://doi.org/10.1371/journal.pone.0348270.g006

The matrix shows:

• Strong diagonal performance (87–92%) across all tasks
• Minimal decay in off-diagonal entries, confirming effective knowledge retention
• Performance on early tasks remains above 85% even after all 20 tasks, demonstrating excellent stability

Analysis of adaptive weighting mechanism

While DGASA achieves state-of-the-art performance across all benchmarks, Reviewer 1 correctly notes that on CUB Inc10, the improvement over ADAM+Adapter is marginal (92.38% vs. 91.96% for , and 86.91% vs. 86.48% for ). To justify the added complexity of our instance-level adaptive weighting mechanism, we conduct a comprehensive analysis examining when and why this mechanism provides benefits, and under what conditions its gains are limited.

Old vs. New class accuracy split

We decompose the final-stage accuracy () into performance on previously learned classes (old) and newly introduced classes (new) for the CUB Inc10 benchmark. Table 12 reveals that adaptive weighting primarily benefits old class recognition, which is critical for mitigating catastrophic forgetting.

Download:

• PNG
  larger image
• TIFF
  original image

Table 12. Old vs. new class accuracy on CUB Inc10 (final stage).

https://doi.org/10.1371/journal.pone.0348270.t012

Per-class confusion analysis. To understand where improvements occur, we analyze the confusion patterns between old and new classes. Fig 7 visualizes the normalized confusion matrices for ADAM+Adapter and DGASA on CUB Inc10.

Download:

• PNG
  larger image
• TIFF
  original image

Fig 7. Confusion matrix comparison on CUB Inc10: (a) ADAM+Adapter, (b) DGASA.

https://doi.org/10.1371/journal.pone.0348270.g007

The analysis reveals that:

• DGASA reduces confusion between visually similar old and new classes (e.g., between “Black-capped Chickadee” (old) and “Carolina Chickadee” (new))
• The adaptive weighting mechanism helps disambiguate samples that are semantically related to multiple tasks by dynamically emphasizing the most relevant subspace
• Most improvements occur in the off-diagonal blocks (old vs. new confusion), confirming that adaptive weighting enhances cross-task discrimination

Adaptive weight distribution analysis

To understand how the instance-level weighting behaves, we analyze the distribution of weights across different scenarios. Fig 8 shows the weight distributions for samples from old and new classes when evaluated on a later task.

Download:

• PNG
  larger image
• TIFF
  original image

Fig 8. Distribution of adaptive weights: (a) samples from old classes, (b) samples from new classes.

https://doi.org/10.1371/journal.pone.0348270.g008

Key observations:

• For samples from old classes, the weights are more evenly distributed across subspaces (average entropy = 1.84), indicating that the model leverages multiple subspaces to preserve old knowledge
• For samples from new classes, the primary subspace receives significantly higher weight (average ), as the model relies primarily on the task-specific adapter
• The weight correlation with prediction confidence is positive (), suggesting that the mechanism assigns higher weights to subspaces that produce more confident predictions

Failure-Case Analysis. We examine cases where DGASA still makes errors to understand limitations of the adaptive weighting mechanism. Table 13 shows representative failure examples on CUB Inc10.

Download:

• PNG
  larger image
• TIFF
  original image

Table 13. Representative failure cases on CUB Inc10.

https://doi.org/10.1371/journal.pone.0348270.t013

Analysis of failure cases reveals:

• Most errors occur between visually similar species that belong to different tasks
• In these cases, the adaptive weights become nearly uniform (), indicating the mechanism struggles to disambiguate highly similar classes across task boundaries
• This suggests that the primary limitation is not the weighting mechanism itself, but rather the discriminative capacity of the underlying adapters for extremely fine-grained distinctions

Calibration analysis. We evaluate model calibration using Expected Calibration Error (ECE) to assess whether adaptive weighting affects prediction confidence reliability. Table 14 reports ECE across methods.

Download:

• PNG
  larger image
• TIFF
  original image

Table 14. Calibration analysis on CUB Inc10.

https://doi.org/10.1371/journal.pone.0348270.t014

Ablation: When Does Adaptive Weighting Help?

We conduct targeted ablations to identify conditions where adaptive weighting provides the most benefit. Table 15 shows results on CUB Inc10 under different configurations.

Download:

• PNG
  larger image
• TIFF
  original image

Table 15. Conditional analysis of adaptive weighting effectiveness.

https://doi.org/10.1371/journal.pone.0348270.t015

Key findings:

1. High inter-task similarity: Adaptive weighting provides the largest gains (+0.82% vs. baseline +0.43%), as it helps disambiguate semantically related classes across tasks
2. Low inter-task similarity: Gains are marginal (+0.07%), as tasks are already well-separated and the primary subspace suffices
3. Small adapter capacity: Adaptive weighting yields substantial improvement (+1.44%), compensating for limited task-specific representation by aggregating cross-task information
4. Large adapter capacity: Gains are smaller (+0.12%), as individual adapters already capture rich task-specific features

These results explain the marginal improvement on CUB Inc10: the dataset exhibits moderate inter-task similarity, and the default adapter capacity (r = 16) is sufficient, leaving limited room for improvement from adaptive weighting. However, in challenging scenarios with high task similarity or constrained adapter capacity, the mechanism provides significant benefits.

Computational overhead analysis

We quantify the additional computational cost of adaptive weighting. Table 16 shows the overhead relative to the baseline inference.

Download:

• PNG
  larger image
• TIFF
  original image

Table 16. Computational overhead of adaptive weighting (20 tasks).

https://doi.org/10.1371/journal.pone.0348270.t016

The adaptive weighting mechanism adds only 0.57 ms (7.7% overhead) and 480 M FLOPs (2.6% overhead) to the inference cost, which is negligible given the accuracy benefits in challenging scenarios.

Summary

The adaptive weighting mechanism provides:

• Primary benefit: Improved old class accuracy (+1.61% on CUB Inc10) by leveraging cross-subspace information
• Greatest impact: Scenarios with high inter-task similarity (+0.82%) or constrained adapter capacity (+1.44%)
• Limited benefit: When tasks are already well-separated or adapters have sufficient capacity
• Negligible cost: Only 7.7% inference overhead

The marginal gains on CUB Inc10 are therefore justified by the mechanism’s substantial benefits in more challenging scenarios and its low computational overhead.

Stability analysis of drift compensation

We analyze the numerical stability of the proposed drift compensation mapping from three perspectives: regularization, increment size, and long-term error behavior.

Regularized mapping formulation. .

To improve numerical robustness, we adopt a ridge-regularized solution instead of directly solving the normal equation:

(25)

where controls the trade-off between stability and fitting accuracy. In practice, is selected via a small validation split.

Evaluation metrics. .

Beyond classification accuracy, we evaluate the quality of drift compensation using:

(26)

which measures prototype reconstruction error. We also report cosine similarity between reconstructed and ground-truth prototypes in the new feature space.

Effect of regularization. .

We vary and report performance in Table 17.

Download:

• PNG
  larger image
• TIFF
  original image

Table 17. Sensitivity analysis of the regularization parameter on CIFAR-100 Inc5 (20 tasks).

https://doi.org/10.1371/journal.pone.0348270.t017

Effect of increment size and conditioning. .

We further analyze how the number of newly introduced classes affects numerical stability. Since the rank and conditioning of depend on the number of new class prototypes, smaller increments tend to produce more ill-conditioned systems. Table 18 summarizes the results.

Download:

• PNG
  larger image
• TIFF
  original image

Table 18. Impact of increment size and conditioning on drift compensation performance. Experiments conducted on CIFAR-100 with varying per-task class increments.

https://doi.org/10.1371/journal.pone.0348270.t018

Error accumulation across long sequences

To evaluate long-term stability, we analyze performance as the number of incremental tasks increases. Unlike sequential composition methods, our approach re-estimates a global mapping at each session using all current new classes as anchors. This prevents error propagation across sessions.

As shown in Table 19, both accuracy and reconstruction metrics remain stable across all tasks. The absence of monotonic degradation confirms that our global re-estimation strategy effectively prevents error accumulation.

Download:

• PNG
  larger image
• TIFF
  original image

Table 19. Stability analysis across long task sequences on CIFAR-100 (Inc5, 20 tasks total).

https://doi.org/10.1371/journal.pone.0348270.t019