Paper deep dive
BPG: Balancing Plasticity and Generalization for Domain Incremental Learning
Qiang Wang, Songlin Dong, Shaokun Wang, Jizhou Han, Xiang Song, Chenhao Ding, Yuhang He, Yihong Gong
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 94%
Last extracted: 8/16/2026, 3:22:28 AM
Summary
The paper introduces BPG, a unified framework for Domain Incremental Learning (DIL) that balances plasticity and generalization. It addresses the limitations of uniform parameter-isolation methods by proposing BPG-Adapter, which dynamically allocates adapter hidden dimensions based on domain-specific feature separability, and BPG-Inference, a soft domain mixture strategy for test-time prediction. Experiments on DomainNet, CDDB, and CORe50 show BPG achieves state-of-the-art accuracy and minimal forgetting.
Entities (9)
Relation Signals (8)
BPG → consistsof → BPG-Adapter
confidence 95% · BPG, a unified framework that addresses both challenges through two complementary components: BPG-Adapter... and BPG-Inference
BPG → consistsof → BPG-Inference
confidence 95% · BPG, a unified framework that addresses both challenges through two complementary components: ... and BPG-Inference
BPG → evaluatedon → DomainNet
confidence 95% · Experimental results on DomainNet, CDDB, and CORe50 demonstrate that BPG consistently outperforms
BPG → evaluatedon → CDDB
confidence 95% · Experimental results on DomainNet, CDDB, and CORe50 demonstrate that BPG consistently outperforms
BPG → evaluatedon → CORe50
confidence 95% · Experimental results on DomainNet, CDDB, and CORe50 demonstrate that BPG consistently outperforms
BPG → solves → plasticity and generalization tension
confidence 92% · BPG: Balancing Plasticity and Generalization for Domain Incremental Learning... addresses both challenges through two complementary components
BPG-Adapter → determines → adapter hidden dimension
confidence 90% · BPG-Adapter, which dynamically determines each domain's adapter hidden dimension based on domain-specific feature separability
BPG-Inference → mitigates → domain ID misselection
confidence 90% · BPG-Inference, a soft domain mixture strategy that integrates multiple domain-specific models at test time, mitigating domain ID misselection.
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Deep neural networks excel in various tasks but struggle to generalize across evolving data distributions, leading to significant performance degradation under domain shifts. Domain incremental learning (DIL) addresses this challenge by enabling models to continuously adapt while retaining prior knowledge. Among existing DIL approaches, the parameter-isolation paradigm achieves state-of-the-art performance. However, these methods often adopt a one-size-fits-all approach to adapt to new domains, resulting in either insufficient learning capacity or redundant parameters. In this work, we propose BPG, a unified framework that addresses both challenges through two complementary components: BPG-Adapter, which dynamically determines each domain's adapter hidden dimension based on domain-specific feature separability, and BPG-Inference, a soft domain mixture strategy that integrates multiple domain-specific models at test time, mitigating domain ID misselection. Experimental results on DomainNet, CDDB, and CORe50 demonstrate that BPG consistently outperforms uniform adapter-based approaches and hard domain selection strategies, achieving state-of-the-art average accuracy while reducing forgetting to as low as 0.22% on DomainNet.
Tags
Links
- Source: https://arxiv.org/abs/2608.10804v1
- Canonical: https://arxiv.org/abs/2608.10804v1
Trouble viewing inline? Open PDF directly →
Full Text
82,984 characters extracted from source content.
Expand or collapse full text
BPG: Balancing Plasticity and Generalization for Domain Incremental Learning Qiang Wang, Songlin Dong, Shaokun Wang, Jizhou Han, Xiang Song, Chenhao Ding, Yuhang He, and Yihong Gong Qiang Wang, Jizhou Han, Yuhang He, and Yihong Gong are with the College of Artificial Intelligence, Xi’an Jiaotong University, Xi’an, China. Songlin Dong is with Shenzhen University of Advanced Technology, Shenzhen, China. Shaokun Wang is with Harbin Institute of Technology, Shenzhen, China. Xiang Song and Chenhao Ding are with the School of Software Engineering, Xi’an Jiaotong University, Xi’an, China. Abstract Deep neural networks excel in various tasks but struggle to generalize across evolving data distributions, leading to significant performance degradation under domain shifts. Domain incremental learning (DIL) addresses this challenge by enabling models to continuously adapt while retaining prior knowledge. Among existing DIL approaches, the parameter-isolation paradigm achieves state-of-the-art performance. However, these methods often adopt a one-size-fits-all approach to adapt to new domains, resulting in either insufficient learning capacity or redundant parameters. In this work, we propose BPG, a unified framework that addresses both challenges through two complementary components: BPG-Adapter, which dynamically determines each domain’s adapter hidden dimension based on domain-specific feature separability, and BPG-Inference, a soft domain mixture strategy that integrates multiple domain-specific models at test time, mitigating domain ID misselection. Experimental results on DomainNet, CDDB, and CORe50 demonstrate that BPG consistently outperforms uniform adapter-based approaches and hard domain selection strategies, achieving state-of-the-art average accuracy while reducing forgetting to as low as 0.22% on DomainNet. I Introduction Deep neural networks (DNNs) have achieved remarkable success in visual recognition tasks such as image classification [1, 2, 3, 4, 5], object detection [6, 7, 8, 9], and semantic segmentation [10, 11]. However, these models typically assume that training and test data share the same distribution, making them prone to catastrophic forgetting [12, 13, 14] in non-stationary environments where lighting conditions [15], sensor characteristics, or visual styles change [16, 17] over time. This is especially concerning in safety-critical applications such as autonomous driving [18], medical imaging [19], and surveillance systems [20, 21]. Domain Incremental Learning (DIL) [22, 23, 24, 25, 26, 27, 28, 29] addresses this challenge: a model is sequentially exposed to domains that exhibit distinct visual characteristics, and must incorporate new domain knowledge while preserving performance on all previously learned domains. Existing DIL approaches fall into three paradigms: rehearsal-based methods [30, 31, 32] that replay stored past samples but incur storage and privacy costs, regularization-based methods [33, 34, 35, 36, 37, 38] that constrain parameter updates to protect old knowledge but limit the absorption of new knowledge, and parameter-isolation methods [22, 39, 40, 41, 42] that freeze a shared backbone and learn lightweight domain-specific modules, achieving state-of-the-art performance by explicitly preventing cross-domain interference. While parameter-isolation methods have shown strong results, they struggle to balance the fundamental tension between plasticity (the ability to learn effectively from new domains) and generalization (the capacity to maintain robust performance across all encountered domains). Figure 1: Motivation of BPG. (a) Domains from DomainNet exhibit varying levels of visual complexity. (b) t-SNE visualizations of pre-trained backbone (ViT-B/16) features confirm that harder domains have lower feature separability scores (s1>s2>s3s_1>s_2>s_3). (c) The optimal adapter dimension differs across domains: easier domains peak at smaller capacities while harder domains benefit from larger ones, motivating our adaptive allocation strategy (BPG-Adapter). (d) Hard domain selection at inference can misassign ambiguous samples near decision boundaries, whereas our soft mixture strategy (BPG-Inference) aggregates predictions from multiple domain-specific models weighted by confidence, improving robustness. The Plasticity Challenge: One Size Does Not Fit All. Most existing methods assign fixed-capacity modules (e.g., uniform adapters or prompts) to every domain, overlooking the substantial variation in domain difficulty. As illustrated in Fig. 1 (a-b), applying a pre-trained backbone to three DomainNet domains yields markedly different feature-space separability, ranging from well-separated clusters in the Painting domain to heavily entangled ones in the Quickdraw domain. This disparity has direct implications for model design. As shown in Fig. 1 (c), easier domains attain peak performance at small adapter dimensions and may even degrade when granted excessive capacity through overfitting, whereas harder domains continue to benefit from larger capacity. Consequently, a uniform adapter design is suboptimal: allocating too few parameters to a hard domain undermines plasticity, while allocating too many to an easy domain induces overfitting and impairs generalization. The Generalization Challenge: Hard Selection is Brittle. Maintaining separate parameters per domain requires a domain identification step at inference: given a test sample, the model selects a single domain ID and applies only the corresponding parameters. This hard selection is inherently fragile. As illustrated in Fig. 1 (d), samples near domain boundaries are prone to misassignment, causing a catastrophic mismatch between the test sample and the applied domain-specific model. The problem worsens as more domains are learned, and our analysis shows that domain ID errors in hard selection can degrade early-domain accuracy by over seven points. We propose BPG, a unified framework that addresses both challenges through complementary mechanisms. For plasticity, we introduce BPG-Adapter, an adaptive capacity allocation strategy that matches adapter parameters to each domain’s intrinsic difficulty: domains already well separated by the pre-trained backbone need only lightweight adaptation, while domains with entangled representations require richer parameterization. Guided by a qualitative risk decomposition, BPG-Adapter operationalizes this insight through a simple inverse-proportionality rule that directs capacity where it is most needed. For generalization, we introduce BPG-Inference, a soft domain mixture strategy that replaces hard selection with confidence-weighted aggregation over multiple domain-specific models. Rather than committing to a single domain, it estimates a distribution over all learned domains for each test sample, prunes unlikely candidates, and fuses the surviving predictions, drawing on complementary domain knowledge when a sample is ambiguous. Together, these components reduce average forgetting to as low as 0.22% on DomainNet while attaining state-of-the-art average accuracy. The main contributions are summarized below. • We identify the plasticity-generalization tension in parameter-isolation DIL and propose BPG, a unified framework that addresses both challenges through complementary mechanisms. • We introduce BPG-Adapter, which dynamically allocates adapter capacity by feature separability, supported by a qualitative risk decomposition that motivates the inverse-proportionality allocation rule. • We present BPG-Inference, a soft domain mixture strategy that mitigates the fragility of hard domain ID selection and serves as a plug-and-play module for other parameter-isolation methods. • Extensive experiments on three multi-domain benchmarks (DomainNet, CDDB, and CORe50) show that BPG consistently achieves state-of-the-art performance in both average accuracy and forgetting rate. I Related Work I-A Domain Incremental Learning Domain Incremental Learning (DIL) methods fall into three paradigms: rehearsal-based, regularization-based, and parameter-isolation. Rehearsal-based methods replay stored or generated past samples during subsequent training, via exemplar selection [43, 44], prototype preservation [45], or generative replay [46, 47]. On frozen pre-trained models, these ideas resurface in a data-free form for class-incremental learning: RanPAC [48] and APER [49] build prototype-based classifiers over frozen or first-session-adapted features, while SLCA [50] models each class as a Gaussian and replays sampled pseudo-features to debias the classifier. However, their performance degrades as the exemplar budget shrinks [51, 52], and storing raw data raises privacy concerns [53]. Regularization-based methods add loss terms that constrain parameter updates to protect learned representations, e.g., EWC [33] penalizes changes to parameters important for earlier domains and distillation variants [38] enforce feature-space consistency. For vision-language models, ZSCL [54] follows the same regularization philosophy, distilling against the initial CLIP model and averaging weights to prevent zero-shot transfer degradation. Although they avoid data storage, the finite capacity of a single model makes them overly conservative, struggling to absorb substantially different domains while retaining old knowledge [55]. Parameter-isolation methods instead maintain domain-specific parameters to prevent cross-domain interference. S-Prompts [22] learns per-domain prompts on a frozen transformer and selects domains by K-N matching over K-Means centroids, and MoP-CLIP [39] extends this to CLIP-based prompt mixtures. Later works differ mainly in the isolated module: PINA [40] adds a per-domain alignment module with a Patch Shuffle Selector, C-Prompt [41] pools learnable prompts for cross-domain compositionality, ISPSL [42] decouples domain-specific and domain-shared low-rank subspaces, and KA-Prompt [56] aligns knowledge across prompts component-wise. Pre-trained-model methods for class-incremental learning follow the same spirit with per-task modules, e.g., LAE [57] ensembles online and offline expert adapters, and EASE [58] learns a per-task adapter to form expandable subspaces. Despite strong performance, two limitations persist: a uniform-capacity module is attached to every domain, ignoring the wide variation in domain difficulty; and hard domain selection at inference is fragile near domain boundaries. Our BPG tackles both by allocating adapter capacity according to domain difficulty and replacing hard selection with a soft mixture over domain-specific experts. I-B Adaptive Parameter-Efficient Fine-Tuning Parameter-efficient fine-tuning (PEFT) methods, such as adapters [59] and LoRA [60], adapt pre-trained models by updating only a small fraction of parameters, but typically fix the rank or hidden dimension across all weight matrices and tasks. Since performance is highly sensitive to this choice [61], a uniform budget overlooks that different matrices and tasks demand varying adaptation capacity. To address this, recent works adaptively allocate capacity, e.g., by pruning or budgeting ranks according to importance or intrinsic dimensionality [62, 63, 64, 65], or by gating and selecting adapters at the layer, token, or module level [66, 67, 68]. However, these methods target single- or multi-task fine-tuning and allocate capacity across layers within a task; none explicitly links adapter capacity to the intrinsic difficulty of the target distribution, leaving open how to determine the right capacity per domain in incremental learning. Our BPG-Adapter fills this gap with a data-driven separability metric that guides hidden-dimension allocation across domains, motivated by a qualitative risk decomposition. I-C Test-Time Domain Identification Parameter-isolation methods for DIL must decide, at inference, which domain-specific parameters to activate for a given test sample, and the design of this mechanism critically affects performance. Most existing methods rely on hard selection. S-Prompts [22] stores per-domain K-Means centroids during training and assigns a single domain label via K-N matching in the frozen feature space. Later methods refine this selection: PINA [40] introduces a Patch Shuffle Selector that suppresses class-dependent cues and outperforms K-N and Nearest Mean classifiers, while ESN [69] selects the most confident domain via a temperature-controlled energy metric over stage classifiers. C-Prompt [41] instead pools and recomposes prompts across domains, implicitly softening the domain boundary. Nevertheless, committing to a single domain remains fragile for samples near domain boundaries. A related paradigm is Mixture-of-Experts (MoE), which softly routes inputs across expert sub-networks via a learned gating network. In continual learning, Lifelong-MoE [70] adds experts for emerging distributions while regularizing experts and gates to retain old knowledge, and MoE-Adapters [71, 72] treat adapters as experts within CLIP, using a Distribution Discriminative Auto-Selector to route between adapted and zero-shot models. Although these methods confirm the benefit of soft routing over hard selection, they train the gating mechanism jointly with the experts, incurring extra training cost and risking forgetting in the router itself. In contrast, our BPG-Inference is a training-free, plug-and-play soft domain mixture. For each test sample, it estimates a confidence-weighted distribution over all learned domains, prunes unlikely candidates, and fuses predictions from the surviving domain-specific models. This retains the robustness of soft routing without any additional trainable module or test-time parameter update, and can be applied on top of existing parameter-isolation DIL methods. I Method Figure 2: Overall architecture of the proposed BPG framework. An input image is tokenized by the patch embedding layer and concatenated with trainable prompt tokens and a class token. The token sequence is processed by a stack of frozen vision transformer layers equipped with domain-specific adapters. For each domain t, the adapter hidden dimension rtr_t is determined by the feature separability score sts_t. I-A Problem Formulation We consider a domain incremental learning scenario with T domains, where the dataset is written as =tt=1TD=\D_t\_t=1^T. Each domain dataset t=(t,t)D_t=(X_t,Z_t) consists of a training set tX_t and a test set tZ_t. Following the DIL protocol, during the t-th training session only samples in tX_t are accessible, while data from other domains is not stored or replayed. After completing session t, the model is evaluated on previously seen test sets ≤t=1∪2∪⋯∪t,Z_≤ t=Z_1 _2∪·s _t, (1) and the performance across sessions is summarized by standard metrics, i.e., average accuracy and forgetting. The details of metrics will be provided in Section IV-A. I-B Vanilla Adapter for Domain-Specific Knowledge Before introducing BPG-Adapter, we describe the vanilla adapter-based architecture that serves as the building block for our framework. This subsection explains how domain-specific adapters are inserted into a ViT encoder and how they interact with prompt tokens and classification heads. Tokenization and Encoder Backbone Let x denote an input image from domain t. x is first divided into non-overlapping image patches, which are linearly projected to patch tokens and added with positional embeddings. We denote the resulting sequence of N patch tokens as =[1,…,N]∈ℝN×dx=[x_1,…,x_N] ^N× d, where d is the embedding dimension. For domain t, we introduce domain-specific prompt tokens t∈ℝM×dp_t ^M× d that are prepended to the patch tokens and a class token cls∈ℝ1×dx_cls ^1× d that aggregates image-level information. The input sequence to the encoder at layer ℓ=0 =0 is t(0)=[cls,1,…,N,t]∈ℝ(N+M+1)×d.z^(0)_t=[x_cls,\,x_1,…,x_N,\,p_t] ^(N+M+1)× d. (2) We employ a stack of L transformer encoder layers with frozen parameters θ. Each layer consists of a multi-head self-attention (MHSA) block and a feed-forward multi-layer perceptron (MLP) block with residual connections and layer normalization (LN), as shown in Fig. 2 (b). Let t(ℓ)z^( )_t be the input to layer ℓ . The standard ViT update is t(ℓ) ^( )_t =t(ℓ)+MHSA(LN(t(ℓ));θatt(ℓ)), =z^( )_t+MHSA (LN(z^( )_t); _att^( ) ), (3) t(ℓ+1) ^( +1)_t =t(ℓ)+MLP(LN(t(ℓ));θmlp(ℓ)), =h^( )_t+MLP (LN(h^( )_t); _mlp^( ) ), (4) where θatt(ℓ) _att^( ) and θmlp(ℓ) _mlp^( ) are frozen pre-trained parameters. Adapter Structure To capture domain-specific characteristics with a small number of trainable parameters, we insert an adapter module as an additional residual branch in each encoder layer, running in parallel to the feed-forward MLP block. For domain t and layer ℓ , the adapter is a two-layer bottleneck MLP Adaptert(ℓ)()=σ(t(ℓ)↓⊤)t(ℓ)↑⊤,Adapter_t^( )(u)=σ\! (u\,W^( ) _t )W^( ) _t, (5) where ∈ℝ(N+M+1)×du ^(N+M+1)× d stacks all token embeddings as rows (shared with the MLP branch), t(ℓ)↓∈ℝrt×dW^( ) _t ^r_t× d and t(ℓ)↑∈ℝd×rtW^( ) _t ^d× r_t are the down- and up-projection matrices, rtr_t is the adapter hidden dimension of domain t, and σ(⋅)σ(·) is a non-linear activation function (ReLU). Each matrix multiplication is applied independently to every token row, yielding an output in ℝ(N+M+1)×dR^(N+M+1)× d. Because the adapter output is added to the same residual path as the MLP output and the adapter is initialized to produce near-zero outputs, the overall layer recovers the frozen pre-trained parameters at initialization, which stabilizes training. Concretely, for domain t, the attention sub-layer in (3) is unchanged. We then apply layer normalization and branch into two parallel paths: a frozen MLP branch and a trainable adapter branch: t(ℓ) ^( )_t =MLP(LN(t(ℓ));θmlp(ℓ)), =MLP (LN(h^( )_t); _mlp^( ) ), (6) t(ℓ) ^( )_t =Adaptert(ℓ)(LN(t(ℓ))). =Adapter_t^( )\! (LN(h^( )_t) ). (7) The output of layer ℓ is obtained by adding the two branches to the residual connection: t(ℓ+1)=t(ℓ)+t(ℓ)+t(ℓ).z^( +1)_t=h^( )_t+m^( )_t+a^( )_t. (8) When the adapter branch is disabled (t(ℓ)=a^( )_t=0), (8) reduces to the standard ViT update in (4). All backbone parameters θ=θatt(ℓ),θmlp(ℓ)ℓ=1Lθ=\ _att^( ), _mlp^( )\_ =1^L are frozen, whereas adapter parameters t(ℓ)↓,t(ℓ)↑ℓ=1L\W^( ) _t,W^( ) _t\_ =1^L and the prompt token tp_t are trainable for domain t. This parallel-residual design creates an isolated parameter set per domain while fully reusing the same pre-trained transformer layer. Domain-Specific Classification Head After passing through L encoder layers, we obtain the final token sequence t(L)z^(L)_t. We use the output of the class token (the first token in the sequence) as the image representation, denoted as t=t(L)[0]∈ℝdh_t=z^(L)_t[0] ^d. Each domain t is associated with its own linear classifier t=gt(t;ηt)=tt+t,y_t=g_t(h_t; _t)=W_th_t+b_t, (9) where ηt=t,t _t=\W_t,b_t\ and t∈ℝCy_t ^C are the class logits. For domain t, only tp_t, the adapter parameters and classifier ηt _t are updated, while parameters from previous domains remain fixed. In the next subsections, we describe how BPG allocates the adapter capacity across domains and how it performs soft inference at test time. I-C BPG-Adapter: Domain-wise Capacity Allocation The vanilla adapter in Section I-B uses the same hidden dimension for all domains, i.e., ∀t∈[1,T],rt=r∀ t∈[1,T],r_t=r. However, domains may exhibit different levels of difficulty: some align well with the pre-trained backbone, while others contain more confusing or fine-grained categories. Allocating an equal number of parameters to all domains may thus fail to model hard domains and over-parameterize easy ones. BPG-Adapter addresses this issue by dynamically determining the hidden dimension rtr_t for each domain according to a feature separability score. Domain-wise Feature Separability Let t∈1,…,Tt∈\1,…,T\ index domains, c∈1,…,Cc∈\1,…,C\ index classes, and i∈1,…,Nt,ci∈\1,…,N_t,c\ index training samples from class c in domain t. We use a pre-trained feature extractor to extract a d-dimensional feature vector t,c,i∈ℝdx_t,c,i ^d for each sample. The class mean and domain mean are t,c=1Nt,c∑i=1Nt,ct,c,i,t=1C∑c=1Ct,c. μ_t,c= 1N_t,c _i=1^N_t,cx_t,c,i, μ_t= 1C _c=1^C μ_t,c. (10) We define the between-class scatter (BCS) and within-class scatter (WCS) of domain t as Rtbcs R^bcs_t =1C∑c=1C‖t,c−t‖22, = 1C _c=1^C \| μ_t,c- μ_t \|_2^2, (11) Rtwcs R^wcs_t =1C∑c=1C1Nt,c∑i=1Nt,c‖t,c,i−t,c‖22, = 1C _c=1^C 1N_t,c _i=1^N_t,c \|x_t,c,i- μ_t,c \|_2^2, (12) where ∥⋅∥2\|·\|_2 is the Euclidean norm. Intuitively, a large RtbcsR^bcs_t and a small RtwcsR^wcs_t indicate that classes in domain t are well separated and compact, which is favorable for classification. A clear example is shown in Fig. 2 (a). Then we combine these quantities into a scalar feature separability score st=RtbcsRtwcs+ε,s_t= R^bcs_tR^wcs_t+ , (13) where ε=10−6 =10^-6 prevents division by zero. A higher sts_t implies better separability and thus an easier domain. Capacity Allocation Rule To balance plasticity and generalization, we assume that each domain is allocated a certain amount of trainable capacity through its adapter hidden dimension rtr_t. We desire an inverse relationship between sts_t and rtr_t: hard domains (low sts_t) should receive more parameters to improve plasticity, while easy domains (high sts_t) can be modeled with smaller adapters to avoid unnecessary capacity. The detailed justification and derivation are provided in Section I-E. We impose a simple multiplicative constraint λ=strtλ=s_tr_t, t=1,…,Tt=1,…,T, where λ is a constant controlling the overall capacity budget. In practice, instead of tuning λ directly, we use a reference domain with its separability s0s_0 and a reference hidden dimension r0r_0, and set λ=s0r0λ=s_0r_0. Substituting into this constraint yields rt=s0str0.r_t= s_0s_tr_0. (14) We treat the ImageNet dataset [73] as the reference domain because it is the pre-training dataset of the backbone and typically exhibits relatively high separability. By using Eq. 14, BPG-Adapter automatically assigns more trainable parameters to challenging domains and less to easier ones, without manual per-domain tuning. I-D BPG-Inference: Soft Mixture for More Generalization The previous subsections describe how BPG learns a collection of domain-specific adapters and classifiers. At inference time, a crucial question is how to leverage these domain-specific models for an unseen test sample. Most existing methods perform hard domain selection: a domain-ID predictor is first used to choose one domain, and only the corresponding adapter and classifier are applied. This strategy is brittle: when the predicted domain is wrong or when the sample lies near the boundary of multiple domains, the final prediction can be severely degraded. BPG-Inference replaces hard selection with a soft domain mixture. Each domain-specific model is treated as an expert, and their logits are combined according to similarities between the test sample and each domain. Prototype-based Domain Affinity For each domain t, we run k-means clustering (k=5k=5) on the frozen feature representations of its training samples (the same features used in Eqs. 11 and 12). This yields k prototypes t,jj=1k\ ν_t,j\_j=1^k that summarize the feature distribution of domain t. Given a test image, we extract its feature vector ∈ℝdz ^d using the frozen backbone and compute the distance to domain t as the nearest-prototype distance at=minj∈1,…,k‖−t,j‖2.a_t= _j∈\1,…,k\ \|z- ν_t,j \|_2. (15) Smaller ata_t indicates that the sample is closer to domain t in the feature space and thus more likely to be well handled by its adapter and classifier. We convert distances into normalized domain confidences via wt=exp(−at)∑i=1Texp(−ai),t=1,…,T.w_t= (-a_t) _i=1^T (-a_i), t=1,…,T. (16) This softmax over negative distances assigns larger weights to domains whose prototypes are closer to the test sample. Confidence-Guided Sparse Domain Mixture To suppress noisy contributions from irrelevant domains, we apply a parameter-free pruning step on the confidence scores wtt=1T\w_t\_t=1^T. We treat the uniform distribution over domains as a threshold: domains whose confidence is lower than this threshold are considered unlikely to be helpful for the current sample and their weights are set to zero. The remaining domains keep their original confidences, which are then rescaled as wt′w _t so that the surviving weights sum to one. In this way, each test sample is associated with a small set of high-confidence domains whose classifiers are linearly combined, using the rescaled confidences as mixture weights, to produce the final logits, i.e., final=∑t=1Twt′ty_final= _t=1^Tw _ty_t. The final prediction is obtained by applying the softmax function to finaly_final. This soft domain mixture allows multiple domains to jointly contribute to decision making when appropriate and reduces the risk of catastrophic errors caused by incorrect hard domain selection. I-E Theoretical Insight for Capacity Allocation We now provide a qualitative theoretical motivation for the capacity allocation rule in Eq. 14 and discuss how it helps balance plasticity and generalization. The goal is not to derive a tight bound or claim global optimality; rather, we use this analysis as intuitive guidance for why assigning larger adapters to harder domains and smaller adapters to easier domains is a sensible design choice. A Toy Risk Decomposition Consider the expected classification risk on domain t as a function of its adapter dimension rtr_t: ℛt(rt)=ℛtapprox(rt)⏟approximation error+ℛtgen(rt)⏟estimation error.R_t(r_t)= R^approx_t(r_t)_approximation error+ R^gen_t(r_t)_estimation error. (17) The approximation error ℛtapprox(rt)R^approx_t(r_t) decreases as rtr_t increases, because a larger adapter offers higher expressive power to fit domain-specific variations. The estimation error ℛtgen(rt)R^gen_t(r_t), on the other hand, typically increases with rtr_t, since a more complex model tends to have larger capacity and thus higher generalization error on finite samples [74, 75]. For analytical convenience, we adopt the following simple parametric forms: ℛtapprox(rt) ^approx_t(r_t) ≈Atexp(−κtrt), ≈ A_t (- _tr_t), (18) ℛtgen(rt) ^gen_t(r_t) ≈BrtNt, ≈ B r_tN_t, (19) where At>0A_t>0 and κt>0 _t>0 describe how fast the approximation error decays with rtr_t for domain t, B>0B>0 is a constant, and NtN_t is the number of training samples. We emphasize that these two expressions are illustrative surrogates rather than exact laws: the exponential form captures the diminishing returns of adding capacity, echoing the geometric error decay of expressive models in classical approximation arguments, while the rt/Nt r_t/N_t term mirrors standard capacity-based generalization bounds [74, 75]. Importantly, the derivation that follows uses only their qualitative shape, namely an approximation error that decreases in rtr_t and an estimation error that increases in rtr_t, so the same conclusion holds for any pair of terms sharing this monotone structure. The parameter κt _t reflects domain difficulty: when classes are well separated (large sts_t), the error can be reduced quickly with small rtr_t (larger κt _t); when classes are highly entangled (small sts_t), more parameters are needed, corresponding to smaller κt _t. Qualitative Allocation Under a Capacity Budget Suppose that the total adapter capacity is constrained by a budget ∑t=1Trt≤Rtot _t=1^Tr_t≤ R_tot. We approximate the average risk by ℛ¯=1T∑t=1Tℛt(rt). R= 1T _t=1^TR_t(r_t). (20) Minimizing ℛ¯ R under the budget constraint can be approached via the Lagrangian ℒ=1T∑t=1T(Ate−κtrt+BrtNt)+α(∑t=1Trt−Rtot),L= 1T _t=1^T (A_te^- _tr_t+B r_tN_t )+α ( _t=1^Tr_t-R_tot ), (21) where α≥0α≥ 0 is a Lagrange multiplier. We differentiate ℒL with respect to rtr_t and set ∂ℒ∂rt=0 ∂ r_t=0, which yields the stationarity condition Atκte−κtrt⋆⏟marginal plasticity gain=B2Ntrt⋆+αT⏟marginal generalization / budget cost. A_t _te^- _tr_t _marginal plasticity gain= B2 N_tr_t +α T_marginal generalization / budget cost. (22) Eq. 22 is precisely the plasticity–generalization balance we seek: at the optimum, the marginal reduction of approximation error obtained by enlarging the adapter (left-hand side, plasticity) is equated with the marginal increase of estimation error together with the shadow price of the capacity budget (right-hand side, generalization). The allocation is thus determined by the equality of the two competing terms, rather than by discarding either of them. Although Eq. 22 admits no elementary closed-form solution, its structure is informative. The left-hand side decays exponentially in rtr_t, whereas the right-hand side, gt(rt):=B2Ntrt+αTg_t(r_t):= B2 N_tr_t+α T, varies only slowly (algebraically) with rtr_t. Solving for rt⋆r_t therefore gives rt⋆≈1κtln(Atκtgt(rt⋆)),r_t ≈ 1 _t \! ( A_t _t\,g_t(r_t )\, ), (23) where ln denotes the natural logarithm. Because the generalization/budget cost gtg_t enters only through the logarithm, it acts as a slowly varying factor and is retained rather than neglected: a stronger generalization penalty (larger B or smaller sample size NtN_t) or a tighter budget (larger α) uniformly shrinks every rt⋆r_t , while the relative allocation across domains is governed by the fast exponential term. Consequently, rt⋆r_t scales roughly like 1/κt1/ _t up to this slowly varying logarithmic factor: harder domains (smaller κt _t) are assigned larger adapter dimensions, whereas easier domains (larger κt _t) can be modeled with smaller adapters. The remaining step is to connect the abstract decay rate κt _t to the observable separability score sts_t. Crucially, obtaining the desired trend does not require an exact functional relationship: since rt⋆r_t in Eq. 23 decreases with κt _t, any monotonically increasing map κt=φ(st) _t= (s_t) already yields rt⋆r_t decreasing in sts_t, i.e., more separable (easier) domains receive smaller adapters. This monotone relationship is corroborated by the empirical behavior reported in Section IV-F: the least separable domains (e.g., Infograph, s2=0.124s_2=0.124, and Quickdraw, s4=0.151s_4=0.151) keep benefiting from larger r up to r=1024r=1024, whereas the most separable one (Real, s5=0.530s_5=0.530) already peaks at a small r and degrades under excess capacity; uniformly enlarging r therefore helps hard domains at the cost of more severe degradation on easier ones, indicating a faster error decay (larger κt _t) for easier domains. Adopting the simplest such map, κt∝st _t s_t, Eq. 23 then reduces to the clean trend rt⋆∝1st,r_t 1s_t, (24) which is consistent with our capacity allocation rule in Eq. 14. Therefore, BPG-Adapter can be viewed as a practical heuristic that approximates an optimal allocation of limited capacity across domains with different difficulties. Implications for Plasticity and Generalization The analysis above highlights the trade-off between plasticity and generalization. Allocating too few parameters to a hard domain results in high approximation error and thus poor plasticity; allocating too many parameters to an easy domain inflates the total capacity, which can harm global generalization under a fixed budget. By adapting rtr_t according to 1/st1/s_t, BPG-Adapter increases plasticity where it is most needed and saves parameters where the backbone already captures the domain well. Together with BPG-Inference, which promotes cross-domain sharing at test time via soft mixtures, the BPG framework achieves a more balanced trade-off between learning new domains and preserving performance on past ones. IV Experiments IV-A Experimental Settings Datasets To evaluate our method, we conduct experiments on three widely used multi-domain datasets: DomainNet, CDDB, and CORe50. DomainNet [76] is a large-scale dataset designed for domain adaptation and domain incremental learning. It consists of six distinct domains with significant inter-domain variations, each containing 345 categories. The training set comprises 409,832 images, while the test set includes 176,743 images. CDDB [77] is tailored for continual deepfake detection, encompassing multiple deepfake techniques. Following previous works, we adopt the Hard track, which includes GauGAN, BigGAN, WildDeepfake, WhichFaceReal, and SAN as representative deepfake generation methods. CORe50 [78] is an object recognition dataset structured into 11 domains, with eight designated for training and three for testing. Each domain contains 50 classes and approximately 15,000 images. Evaluation Metrics To assess the performance of DIL methods, we utilize two key evaluation metrics. We denote by B∈ℝT×TB ^T× T a lower triangular matrix, where Bi,jB_i,j is the test accuracy on the j-th domain after training on the i-th domain. (1) Average Accuracy (ATA_T) measures the classification performance after training on the T-th domain; it is computed as the overall accuracy over all test images from the T learned domains. (2) Average Forgetting (FTF_T), which measures the retention of knowledge from previous domains, is computed as: FT=1T−1∑j=1T−11T−j∑i=j+1T(Bj,j−Bi,j).F_T= 1T-1 _j=1^T-1 1T-j _i=j+1^T(B_j,j-B_i,j). (25) A higher ATA_T and a lower FTF_T indicate better performance of a DIL method. Backbones Following [22], we adopt pre-trained ViT-B/16 [79] and CLIP [80] as backbones. ViT extracts image features with a classifier trained from scratch; CLIP additionally encodes class-name text features and uses image-text similarity as classification logits. Implementation Details We train the model for 30, 50, and 20 epochs on the DomainNet, CDDB, and CORe50 datasets, respectively. The model is optimized using SGD with an initial learning rate of 0.01, following a cosine decay schedule. The batch size is set to 128, and all training images are resized to 224×224224× 224. Each experiment is repeated three times with different random seeds, and we report the mean and standard deviation. The between-class scatter (RtbcsR^bcs_t), within-class scatter (RtwcsR^wcs_t), and feature separability score (sts_t) for each domain in these datasets are presented in Tables I, I and I, where t=0t=0 denotes ImageNet as the reference domain for computing rtr_t. The reference hidden dimension r0r_0 is set to 64 for DomainNet and CORe50, and to 1 for CDDB. All experiments are conducted on a workstation with an Intel Xeon Gold 6226R CPU, 320 GB RAM, and NVIDIA RTX 4090 GPUs; each run requires a single GPU with approximately 18–22 GB of GPU memory. TABLE I: Between-class scatter RtbcsR^bcs_t, within-class scatter RtwcsR^wcs_t, and feature separability score sts_t on the DomainNet dataset. t 0 1 2 3 4 5 6 RtbcsR^bcs_t 0.392 0.120 0.072 0.192 0.029 0.298 0.088 RtwcsR^wcs_t 0.518 0.543 0.579 0.656 0.193 0.562 0.568 sts_t 0.756 0.221 0.124 0.293 0.151 0.530 0.156 TABLE I: Between-class scatter RtbcsR^bcs_t, within-class scatter RtwcsR^wcs_t, and feature separability score sts_t on the CDDB dataset. t 0 1 2 3 4 5 RtbcsR^bcs_t 0.392 0.007 0.004 0.002 0.004 0.009 RtwcsR^wcs_t 0.518 0.832 0.892 0.440 0.547 0.842 sts_t 0.756 0.008 0.004 0.005 0.008 0.011 TABLE I: Between-class scatter RtbcsR^bcs_t, within-class scatter RtwcsR^wcs_t, and feature separability score sts_t on the CORe50 dataset. t 0 1 2 3 4 5 6 7 8 RtbcsR^bcs_t 0.392 0.205 0.208 0.178 0.162 0.219 0.167 0.199 0.185 RtwcsR^wcs_t 0.518 0.355 0.331 0.347 0.368 0.336 0.363 0.388 0.307 sts_t 0.756 0.579 0.629 0.513 0.441 0.650 0.460 0.513 0.604 TABLE IV: Experimental results on the DomainNet dataset. “Upper Bound” denotes an ideal scenario where the domain ID of the test set is known. * Results reported in the original paper. Bold/underline: best/second-best. Backbone Method Buffer (↓ ) ATA_T (↑ ) FTF_T (↓ ) ViT DyTox [81] 50/class 62.94 - EWC [33] 0/class 47.62± 1.35 12.85± 1.03 LwF [82] 49.19± 1.13 5.01± 0.59 L2P [83] 40.15± 2.73 2.25± 0.51 DualPrompt [84] 43.79± 1.55 2.03± 0.89 S-iPrompts [22] 50.62± 0.15 2.85± 0.28 CODA-P [85] 47.42± 0.78 3.46± 0.89 PINA [40] 54.86± 0.71 2.24± 0.84 DUCT* [86] 67.01± 1.35 - C-Prompt [41] 58.68± 1.28 1.34± 0.36 DualCP [87] 60.13± 2.16 1.96± 0.75 SOYO [88] 65.25± 0.92 1.26± 0.41 CONEC-LoRA* [89] 66.42± 0.38 - KA-Prompt* [56] 62.91± 0.14 1.93± 0.26 DCE [90] 63.50± 0.50 - PC [91] 58.82± 0.46 1.27± 0.18 ICON [92] 67.95± 1.87 8.18± 1.80 BPG (ours) 0/class 72.19± 0.86 0.22± 0.12 Upper Bound 74.21± 0.25 0.00 CLIP S-liPrompts [22] 0/class 67.78± 0.90 1.64± 0.68 MoP-CLIP* [39] 69.70 - PINA [40] 69.06± 1.61 1.59± 0.33 HiDe-Prompt* [93] 60.15 - CP-Prompt* [94] 73.35 - BPG (ours) 0/class 75.72± 0.15 0.59± 0.03 Upper Bound 77.53± 0.39 0.00 TABLE V: Experimental results on the CDDB dataset. “Upper Bound” denotes an ideal scenario where the domain ID of the test set is known. * Results reported in the original paper. Bold/underline: best/second-best. Backbone Method Buffer (↓ ) ATA_T (↑ ) FTF_T (↓ ) ViT LRCIL [95] 100/class 76.39 4.39 iCaRL [96] 79.76 8.73 LUCIR [97] 82.53 5.34 LRCIL [95] 50/class 74.01 8.62 iCaRL [96] 73.98 14.50 LUCIR [97] 80.77 7.85 DyTox [81] 86.21 1.55 EWC [33] 0/class 50.59± 3.79 42.62± 1.83 LwF [82] 60.94± 1.69 13.53± 0.50 DyTox [81] 51.27± 5.07 45.85± 1.85 L2P [83] 61.28± 0.52 9.23± 0.23 DualPrompt [84] 64.80± 1.82 8.74± 0.73 S-iPrompts [22] 74.51± 1.96 1.30± 1.12 CODA-P [85] 70.54± 0.37 5.53± 0.94 PINA [40] 77.35± 1.46 0.98± 0.22 C-Prompt [41] 78.44± 0.87 1.55± 0.15 KA-Prompt [56] 80.78± 1.21 0.96± 0.26 DualCP [87] 82.16± 1.53 0.73± 0.25 CONEC-LoRA* [89] 88.21± 0.88 - DUCT* [86] 85.10± 0.52 - DCE* [90] 71.80± 4.20 - BPG (ours) 0/class 88.55± 0.32 0.68± 0.09 Upper Bound 89.17± 0.40 0.00 CLIP S-liPrompts [22] 0/class 88.65± 0.64 0.69± 0.26 MoP-CLIP* [39] 88.54 0.79 PINA [40] 85.71± 1.99 0.51± 0.27 HiDe-Prompt* [93] 84.32 2.61 CP-Prompt* [94] 93.65 0.25 BPG (ours) 0/class 93.91± 0.39 0.12± 0.06 Upper Bound 94.40± 0.25 0.00 TABLE VI: Experimental results on the CORe50 dataset. Since the training and testing domains do not overlap, average forgetting and upper bound accuracy are not applicable. * Results reported in the original paper. Bold/underline: best/second-best. Backbone Method Buffer (↓ ) ATA_T (↑ ) ViT ER [98] 50/class 80.10 GDumb [99] 74.92 BiC [100] 79.28 DER++ [101] 79.70 Co2L [102] 79.75 DyTox [81] 79.21 L2P [83] 81.07 EWC [33] 0/class 74.82± 1.81 LwF [82] 75.45± 1.27 L2P [83] 78.33± 2.12 DualPrompt [84] 80.25± 1.09 S-iPrompts [22] 83.13± 1.62 ICON [92] 74.98± 0.03 CODA-P [85] 85.68± 0.31 C-Prompt [41] 85.31± 1.87 KA-Prompt [56] 85.61± 1.64 PINA [40] 86.74± 0.82 DCE* [90] 84.80± 0.30 DualCP [87] 88.10± 0.89 CONEC-LoRA* [89] 90.24± 1.64 SOYO [88] 90.77± 0.53 PC [91] 91.35± 0.39 BPG (ours) 0/class 91.87± 0.31 Upper Bound N/A CLIP S-liPrompts [22] 0/class 89.06± 1.44 MoP-CLIP* [39] 92.29 PINA [40] 87.38± 1.92 HiDe-Prompt* [93] 80.81± 0.76 CP-Prompt* [94] 90.67± 0.55 BPG (ours) 0/class 92.46± 0.42 Upper Bound N/A IV-B Main Results Compared Methods We compare BPG with representative continual learning methods across three paradigms: rehearsal-based (iCaRL [96], LUCIR [97], DyTox [81]), rehearsal-free regularization (EWC [33], LwF [82]), and rehearsal-free parameter isolation, including prompt-based methods (L2P [83], DualPrompt [84], S-Prompts [22], CODA-P [85], C-Prompt [41]) and recent approaches (ICON [92], DUCT [86], CONEC-LoRA [89], DCE [90], PC [91], PINA [40]). On the CLIP backbone, we additionally include MoP-CLIP [39], HiDe-Prompt [93], and CP-Prompt [94]. BPG is a rehearsal-free method that requires no replay buffer. We also report the Upper Bound accuracy, which assumes oracle domain IDs at test time, as a performance ceiling. Results on DomainNet Table IV summarizes results on DomainNet, which comprises six visually distinct natural image domains. On ViT, BPG achieves AT=72.19%A_T=72.19\% and FT=0.22%F_T=0.22\%, surpassing the second-best rehearsal-free method ICON [92] (67.95%67.95\%) by 4.24% in accuracy and SOYO [88] (1.26%1.26\%) by 1.04% in forgetting. Without any replay, BPG also exceeds DyTox [81] (50 samples/class; 62.94%62.94\%) by 9.25%. The near-zero forgetting indicates that BPG-Inference mitigates errors from hard domain ID selection by softly combining domain-specific experts. BPG further narrows the gap to the Upper Bound (74.21%74.21\%) to 2.02%. On CLIP, BPG attains 75.72%75.72\% and 0.59%0.59\% in ATA_T and FTF_T, respectively, exceeding CP-Prompt [94] (73.35%73.35\%) by 2.37% while maintaining low forgetting. Results on CDDB Table V reports results on CDDB, a continual deepfake detection benchmark where each domain corresponds to a distinct generation method. On ViT, BPG achieves the best ATA_T (88.55%88.55\%) and FTF_T (0.68%0.68\%). Without storing past samples, it outperforms all rehearsal-based methods, including DyTox [81] (50 samples/class; 86.21%86.21\%) and LUCIR [97] (100 samples/class; 82.53%82.53\%). Its forgetting is 0.05% lower than DualCP [87] (0.73%0.73\%). On CLIP, BPG reaches 93.91%93.91\% with 0.12%0.12\% forgetting, surpassing CP-Prompt [94] (93.65%93.65\%) and approaching the Upper Bound (94.40%94.40\%) within 0.49%. Results on CORe50 Table VI reports results on CORe50, where training and test domains do not overlap; consequently, FTF_T and the Upper Bound are not applicable. BPG-Inference therefore softly aggregates predictions from all learned domain-specific models according to feature-space affinity, rather than committing to a single domain ID. On ViT, BPG attains 91.87%91.87\%, outperforming the second-best method PC [91] (91.35%91.35\%) and exceeding L2P [83] with a 50-sample buffer (81.07%81.07\%) by 10.80%. On CLIP, BPG reaches 92.46%92.46\%, surpassing MoP-CLIP [39] (92.29%92.29\%) by 0.17%. These results confirm that BPG generalizes effectively to entirely unseen test domains. IV-C Ablation Study Component-wise Analysis Table VII presents the ablation results, where the baseline trains only the domain prompt and classifier on top of the frozen backbone and performs hard domain selection at inference. Both BPG-Adapter and BPG-Inference independently improve accuracy while reducing forgetting. By adaptively allocating larger capacity to harder domains, BPG-Adapter attains 68.33% accuracy with 1.28% forgetting on DomainNet (ViT), and BPG-Inference is particularly effective at reducing forgetting. Generality of BPG-Inference To demonstrate the broad applicability of our soft mixture strategy, we integrate BPG-Inference into several representative prompt-based continual learning methods, as shown in Table VIII. BPG-Inference consistently improves all baseline methods across all three benchmarks. For instance, when applied to S-iPrompts, it yields +5.42% accuracy gain on DomainNet with 0.74% forgetting reduction. Similar improvements are observed for PINA (+4.48% on DomainNet), C-Prompt (+4.83% on DomainNet), and KA-Prompt (+2.52% on DomainNet). These results confirm that BPG-Inference is a general and effective strategy that can enhance existing parameter-isolation methods by mitigating the brittleness of hard domain selection at inference time. TABLE VII: Ablation study on BPG components. We evaluate the individual and combined contributions of BPG-Adapter (adaptive capacity allocation) and BPG-Inference (soft mixture strategy) using both ViT-B/16 and CLIP-ViT-B/16 backbones. “Baseline” trains only the domain prompt and classifier (without adapters) and uses hard domain selection at inference. Both components consistently improve performance, and their combination achieves the best results across all benchmarks. Method Backbone BPG-Adapter BPG-Inference DomainNet CDDB CORe50 ViT CLIP ATA_T (↑ ) FTF_T (↓ ) ATA_T (↑ ) FTF_T (↓ ) ATA_T (↑ ) Baseline ✓ 61.69± 1.68 1.86± 0.46 80.52± 1.21 0.93± 0.07 83.23± 1.07 Baseline + BPG-Adapter ✓ ✓ 68.33± 0.89 1.28± 0.17 86.94± 1.93 0.85± 0.42 90.15± 1.09 Baseline + BPG-Inference ✓ ✓ 66.25± 1.53 1.54± 0.30 83.84± 2.07 0.77± 0.51 84.55± 0.58 BPG (ours) ✓ ✓ ✓ 72.19± 0.86 0.22± 0.12 88.55± 0.32 0.68± 0.09 91.87± 0.31 Baseline ✓ 67.85± 0.72 1.43± 0.26 91.07± 1.49 0.30± 0.44 86.87± 1.12 Baseline + BPG-Adapter ✓ ✓ 73.59± 0.79 1.15± 0.41 93.42± 0.32 0.26± 0.21 92.09± 1.06 Baseline + BPG-Inference ✓ ✓ 70.46± 0.47 1.21± 0.23 91.76± 1.38 0.31± 0.29 87.50± 1.91 BPG (ours) ✓ ✓ ✓ 75.72± 0.15 0.59± 0.03 93.91± 0.39 0.12± 0.06 92.46± 0.42 TABLE VIII: Generality of BPG-Inference. We integrate our soft mixture inference strategy into existing prompt-based continual learning methods. BPG-Inference consistently improves all baselines across benchmarks, demonstrating its broad applicability as a plug-and-play enhancement. Numbers in parentheses indicate improvements over the original methods. Method DomainNet CDDB CORe50 ATA_T (↑ ) FTF_T (↓ ) ATA_T (↑ ) FTF_T (↓ ) ATA_T (↑ ) S-iPrompts [22] 50.62 2.85 74.51 1.30 83.13 S-iPrompts + BPG-Inference 56.04 (+5.42) 2.11 (-0.74) 77.69 (+3.18) 1.10 (-0.20) 83.80 (+0.67) PINA [40] 54.86 2.24 77.35 0.98 86.74 PINA + BPG-Inference 59.34 (+4.48) 1.72 (-0.52) 79.49 (+2.14) 0.84 (-0.14) 87.35 (+0.61) C-Prompt [41] 58.68 1.34 78.44 1.55 85.31 C-Prompt + BPG-Inference 63.51 (+4.83) 1.03 (-0.31) 80.57 (+2.13) 1.30 (-0.25) 86.45 (+1.14) KA-Prompt [56] 62.91 1.93 80.78 0.96 85.61 KA-Prompt + BPG-Inference 65.43 (+2.52) 1.19 (-0.74) 83.52 (+2.74) 0.75 (-0.21) 86.02 (+0.41) IV-D Additional Analysis on BPG-Adapter Figure 3: Ablation study on the hidden dimension r and BPG-Adapter. The two curves compare models with and without BPG-Adapter under varying hidden dimensions, reporting both average accuracy ATA_T (left) and average forgetting FTF_T (right) on DomainNet. Effect of BPG-Adapter and Hidden Dimension To evaluate the impact of the adapter’s hidden dimension on model performance, we conducted experiments on the DomainNet dataset, as illustrated in Fig. 3. For models without BPG-Adapter, a standard adapter with a uniform hidden dimension is assigned to each domain. We set the hidden dimension r to 4, 16, 64, 256, 512, and 1024, measuring both average accuracy and average forgetting. For models equipped with BPG-Adapter, we set the base hidden dimension r0r_0 to 4, 16, and 64. Since BPG-Adapter dynamically determines the actual hidden dimension for each domain according to feature separability, the resulting dimension is generally larger than r0r_0. To enable a fair comparison, we report the equivalent hidden dimension in this figure. The results reveal two key findings. First, BPG-Adapter consistently outperforms the uniform counterpart in both accuracy and forgetting across comparable hidden dimensions, confirming that adaptively allocating capacity according to domain complexity is more effective than assigning a fixed size to all domains. Second, with BPG-Adapter, a small base dimension (r0=64r_0=64, corresponding to an equivalent dimension around 256) already achieves near-optimal accuracy while maintaining the lowest forgetting, demonstrating that our method enables efficient parameter utilization by assigning larger adapters only to domains that genuinely require additional capacity. TABLE IX: Ablation on different fine-tuning methods based on ViT. BPG-A: BPG-Adapter; BPG-I: BPG-Inference. Dataset BPG-A BPG-I Adapter LoRA ATA_T (↑ ) FTF_T (↓ ) ATA_T (↑ ) FTF_T (↓ ) DomainNet 61.69 1.86 61.69 1.86 ✓ 68.33 1.28 68.04 1.39 ✓ ✓ 72.19 0.22 71.83 0.27 CDDB 80.52 0.93 80.52 0.93 ✓ 86.94 0.85 86.92 0.88 ✓ ✓ 88.55 0.68 88.48 0.73 CORe50 83.23 – 83.23 – ✓ 90.15 – 90.36 – ✓ ✓ 91.87 – 92.14 – Different Tuning Methods In existing parameter-isolation DIL methods, two common parameter-efficient fine-tuning approaches are Adapter and LoRA. Our primary experiments are conducted using Adapter. To evaluate the generalizability of our method, we also present experimental results using LoRA in Table IX. The results demonstrate that the proposed adaptive capacity allocation transfers well to both fine-tuning paradigms. Adapter-based tuning yields slightly stronger results on DomainNet, where domain shifts are more pronounced, whereas LoRA remains competitive on CDDB and CORe50. Figure 4: t-SNE visualizations of domain-specific features on DomainNet under uniform adapter hidden dimensions. Each column is a domain and each row a fixed r; solid/dashed boxes mark the highest and second-highest accuracy among tested r per column. IV-E Additional Analysis on BPG-Inference Detailed Analysis on BPG-Inference Table X compares BPG-Adapter with hard domain selection (BPG-Adapter only) against the full BPG framework on DomainNet. Hard selection causes Domain 1 accuracy to drop from 78.49% to 71.06% as more domains are added, reflecting growing domain-ID misselection. BPG-Inference mitigates this via multi-expert logit fusion. After training on the third domain, the accuracy of Domain 1 improves from 73.64% to 75.71% and eventually recovers to 76.83%. TABLE X: Per-domain accuracy matrix on DomainNet: BPG-Adapter only (hard selection) vs. full BPG. D1D_1 represents Domain 1, and so forth. BPG-Adapter only ATA_T (↑ ): 68.33 FTF_T (↓ ): 1.28 Test D1D_1 Test D2D_2 Test D3D_3 Test D4D_4 Test D5D_5 Test D6D_6 Train D1D_1 78.49 Train D2D_2 74.95 43.04 Train D3D_3 73.64 42.84 67.16 Train D4D_4 72.81 42.43 66.85 69.31 Train D5D_5 71.95 41.80 66.29 69.31 78.16 Train D6D_6 71.06 40.58 65.70 69.13 77.94 63.94 BPG (full) ATA_T (↑ ): 72.19 FTF_T (↓ ): 0.22 Test D1D_1 Test D2D_2 Test D3D_3 Test D4D_4 Test D5D_5 Test D6D_6 Train D1D_1 78.49 Train D2D_2 74.95 43.04 Train D3D_3 75.71 42.99 70.44 Train D4D_4 76.09 43.50 71.56 70.82 Train D5D_5 76.31 44.04 71.07 70.81 82.92 Train D6D_6 76.83 44.10 70.85 70.57 83.03 68.31 Ablation on Weighting Methods in BPG-Inference We further ablate logit fusion on the BPG-Adapter-only baseline (Table XI). Naive averaging (Mean) and max pooling (Max) underperform hard selection, whereas threshold-filtered fusion with L1 normalization (Thres+L1, our default) improves ATA_T by 3.86% and reduces FTF_T to 0.22%, confirming that ambiguous samples benefit from selective multi-domain aggregation. TABLE XI: Ablation on BPG-Inference weighting. Hard selection: BPG-Adapter only; Mean: simple average of all logits; Max: select the highest logit value across all domains as the class prediction; Thres: confidence thresholding; L1/L2: weight normalization. Hard selection Mean Max Thres+Mean Thres+L1 Thres+L2 ATA_T (↑ ) 68.33 56.87 66.67 71.25 72.19 72.24 FTF_T (↓ ) 1.28 N/A 2.08 0.49 0.22 0.26 ΔAT A_T 0 -11.46 -1.66 +2.92 +3.86 +3.91 IV-F Visualization Fig. 4 complements the ablation in Fig. 3 with t-SNE visualizations of learned features on DomainNet, varying a uniform adapter hidden dimension r∈4,16,64,256,1024r∈\4,16,64,256,1024\ across all domains (test accuracy annotated per subplot). Domain-wise optima are heterogeneous: easier domains such as Real (s5=0.530s_5=0.530) peak at smaller r and degrade when given excess capacity, whereas the hardest domains, Infograph (s2=0.124s_2=0.124) and Quickdraw (s4=0.151s_4=0.151), continue to improve up to r=1024r=1024; the remaining domains reach their best accuracy at intermediate values (e.g., r=256r=256). Crucially, uniformly increasing r is not globally optimal. Although hard domains benefit from larger capacity, the same setting increasingly over-parameterizes easier domains and more severely impairs performance on the others, as also evidenced by the rising forgetting in Fig. 3. This per-domain asymmetry motivates difficulty-aware capacity allocation in BPG-Adapter. IV-G Efficiency Analysis We analyze parameter budget, training overhead, and inference cost on DomainNet (ViT-B/16, L=12L=12, d=768d=768, C=345C=345, T=6T=6). Per domain, trainable parameters comprise adapters (2Ldrt+Ld+Lrt2Ldr_t+Ld+Lr_t), prompt tokens (MdMd), and a linear classifier (Cd+CCd+C). BPG-Adapter reallocates capacity via Eq. 14 instead of fixing rt=r_t=r. Parameter Budget Table XII reports per-domain sts_t, rtr_t, and trainable parameter counts. At r0=64r_0=64, harder domains receive larger adapters (e.g., Infograph: r2=390r_2=390) and easier ones smaller capacities (e.g., Real: r5=91r_5=91). Total capacity (∑trt=1495 _tr_t=1495, r¯≈249 r≈249) matches a uniform adapter at r=249r=249 (Fig. 3). With 29.3 M parameters, BPG surpasses a uniform r=64r=64 baseline (8.8 M; AT=66.79%A_T=66.79\%, Fig. 3) at AT=68.33%A_T=68.33\%. Matched to uniform r=256r=256 (30.0 M), it still wins on both ATA_T (68.33% vs. 67.51%) and FTF_T (1.28% vs. 1.34%), showing gains from difficulty-aware reallocation over uniform scaling. TABLE XII: Parameter budget on DomainNet (ViT-B/16, r0=64r_0=64). Adapter params. are computed as 2Ldrt+Ld+Lrt2Ldr_t+Ld+Lr_t with L=12L=12 and d=768d=768. Per-domain total includes adapters, prompt tokens, and the linear classifier. Domain t sts_t rtr_t Adapter (M) Domain total (M) 1 0.221 219 4.05 4.32 2 0.124 390 7.20 7.48 3 0.293 165 3.05 3.33 4 0.151 320 5.91 6.18 5 0.530 91 1.69 1.96 6 0.156 310 5.73 6.00 BPG (adaptive, r0=64r_0=64) 27.63 29.26 Uniform (r=64r=64) 7.14 8.77 Uniform (r=256r=256) 28.39 30.02 Training Overhead BPG follows the same sequential protocol: each session updates only the current domain’s prompt, adapter, and classifier for 30 epochs. Table XIII reports wall-clock time on DomainNet (ViT-B/16). All methods share a one-time prototype cost of 0.34 h (k-means, k=5k=5); BPG adds 0.38 h for separability scoring (one frozen-backbone forward pass per new domain), less than a single training epoch. Larger adapters on harder domains slightly extend main training (22.30 h vs. 21.62 h at r=64r=64 and 21.83 h at r=256r=256). Overall, BPG finishes in 23.02 h, only +4.8% over uniform r=64r=64 (21.96 h) and +3.8% over r=256r=256 (22.17 h). Crucially, BPG introduces no learnable router and therefore incurs no joint router-training overhead. TABLE XIII: Wall-clock training time on DomainNet (ViT-B/16, 30 epochs per domain, T=6T=6), in hours on a single GPU aggregated over incremental sessions. Training: main epoch-wise optimization; Separability: one-time feature separability scoring; Prototypes: one-time domain prototype building via k-means. Method Training Separability Prototypes Total Uniform (r=64r=64) 21.62 0 0.34 21.96 Uniform (r=256r=256) 21.83 0 0.34 22.17 BPG (adaptive, r0=64r_0=64) 22.30 0.38 0.34 23.02 Inference Latency BPG-Inference fuses logits from all T domain-specific models at test time; hard selection uses only the highest-confidence expert. On DomainNet (ViT-B/16, T=6T=6, single GPU), average per-image latency increases from 11.5 ms to 74.2 ms. The overhead is confined to inference and does not alter the training schedule (Table XIII). For offline DIL deployments that prioritize robustness over throughput, 74.2 ms per image remains modest. Unlike MoE-based soft routing, BPG achieves comparable logit aggregation without a learnable gating module or joint router training. When peak throughput is required, hard selection provides a simple latency-accuracy knob within the same framework. V Conclusion We address two key bottlenecks in domain incremental learning: insufficient plasticity from uniform adapter capacity and brittle generalization from hard domain selection at inference. We propose BPG, a unified framework comprising BPG-Adapter, which adaptively allocates adapter hidden dimensions from feature separability, and BPG-Inference, which soft-mixes logits from multiple domain-specific models. Experiments on DomainNet, CDDB, and CORe50 show that BPG achieves state-of-the-art average accuracy with near-zero forgetting, validating the need to jointly adapt plasticity and generalization in lifelong learning. Limitations and Future Work BPG operates within the parameter-isolation paradigm for rehearsal-free DIL, learning domain-specific parameters sequentially without storing past samples. When a rehearsal buffer is available and privacy constraints permit, combining BPG with selective replay may yield further gains. BPG-Inference increases per-image latency by aggregating logits from all domain experts; this overhead is confined to inference, requires no learnable router, and hard domain selection remains available when peak throughput is critical. References [1] Z. Zhang, D. Chang, R. Zhu, X. Li, Z. Ma, and J.-H. Xue, “Query-aware cross-mixup and cross-reconstruction for few-shot fine-grained image classification,” IEEE Transactions on Circuits and Systems for Video Technology, vol. 35, no. 2, p. 1276–1286, 2024. [2] J. Li, S. Wang, B. Qian, Y. He, X. Wei, and Y. Gong, “Dynamic integration of task-specific adapters for class incremental learning,” arXiv preprint arXiv:2409.14983, 2024. [3] C. Ding, S. Dong, Z. Zhou, J. Han, Q. Wang, Y. He, and Y. Gong, “Class-independent increment: An efficient approach for multi-label class-incremental learning,” arXiv preprint arXiv:2503.00515, 2025. [4] J. Han, C. Ding, Y. He, S. Dong, Q. Wang, X. Gao, and Y. Gong, “Learn by reasoning: Analogical weight generation for few-shot class-incremental learning,” IEEE Transactions on Circuits and Systems for Video Technology, 2025. [5] S. Lu, Y. He, J. Li, Q. Wang, and Y. Gong, “Gfpl: Generative federated prototype learning for resource-constrained and data-imbalanced vision task,” arXiv preprint arXiv:2602.21873, 2026. [6] B.-H. Chen, L.-F. Shi, and X. Ke, “A robust moving object detection in multi-scenario big data for video surveillance,” IEEE Transactions on Circuits and Systems for Video Technology, vol. 29, no. 4, p. 982–995, 2018. [7] X. Song, Y. He, J. Li, Q. Wang, and Y. Gong, “Learning endogenous attention for incremental object detection,” in Proceedings of the Computer Vision and Pattern Recognition Conference, 2025, p. 30 354–30 364. [8] J. Zhao, C. Ding, S. Dong, J. Li, Q. Wang, Y. He, and Y. Gong, “Shared & domain self-adaptive experts with frequency-aware discrimination for continual test-time adaptation,” in Proceedings of the AAAI Conference on Artificial Intelligence, vol. 40, no. 34, 2026, p. 28 697–28 705. [9] Z. Shi, Z. Wu, J. Wen, M. Li, X. Fan, Y. Wang, and L. Shen, “Decenter: Density-center guided perception enhancement for uav object detection,” IEEE Transactions on Circuits and Systems for Video Technology, 2026. [10] X. Li, Y. Liu, G. Sun, M. Wu, L. Zhang, and C. Zhu, “Towards open-vocabulary video semantic segmentation,” IEEE Transactions on Multimedia, 2025. [11] Y. Tang, T. Chen, X. Jiang, Y. Yao, G.-S. Xie, and H.-T. Shen, “Holistic prototype attention network for few-shot video object segmentation,” IEEE Transactions on Circuits and Systems for Video Technology, vol. 34, no. 8, p. 6699–6709, 2023. [12] M. McCloskey and N. J. Cohen, “Catastrophic interference in connectionist networks: The sequential learning problem,” in Psychology of learning and motivation. Elsevier, 1989, vol. 24, p. 109–165. [13] C. Ding, X. Gao, S. Dong, Y. He, Q. Wang, A. Kot, and Y. Gong, “Lobg: less overfitting for better generalization in vision-language model,” arXiv preprint arXiv:2410.10247, 2024. [14] J. Han, C. Ding, S. Dong, Y. He, S. Wang, Q. Wang, and Y. Gong, “Goal: Geometrically optimal alignment for continual generalized category discovery,” in Proceedings of the AAAI Conference on Artificial Intelligence, vol. 40, no. 6, 2026, p. 4565–4573. [15] J. Li, C. Wan, S. Dong, C. Ding, Q. Wang, Z. Ma, and Y. Gong, “Trajectory-diversity-driven robust vision-and-language navigation,” arXiv preprint arXiv:2603.15370, 2026. [16] J. Han, S. Wang, Y. He, C. Ding, Q. Wang, X. Gao, S. Dong, and Y. Gong, “Consistent supervised-unsupervised alignment for generalized category discovery,” arXiv preprint arXiv:2507.04725, 2025. [17] S. Dong, C. Ding, J. Li, J. Han, Q. Wang, Y. He, and Y. Gong, “Beyond clip generalization: Against forward&backward forgetting adapter for continual learning of vision-language models,” arXiv preprint arXiv:2505.07690, 2025. [18] R. Yang, T. Yang, Z. Yan, T. Krajnik, and Y. Ruichek, “Preventing catastrophic forgetting in continuous online learning for autonomous driving,” in 2024 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS). IEEE, 2024, p. 5505–5512. [19] M. Perkonigg, J. Hofmanninger, C. J. Herold, J. A. Brink, O. Pianykh, H. Prosch, and G. Langs, “Dynamic memory to alleviate catastrophic forgetting in continual learning with medical imaging,” Nature communications, vol. 12, no. 1, p. 5678, 2021. [20] K. Doshi and Y. Yilmaz, “Continual learning for anomaly detection in surveillance videos,” in Proceedings of the IEEE/CVF conference on computer vision and pattern recognition workshops, 2020, p. 254–255. [21] Q. Wang, X. Gao, S. Dong, J. Han, J. Li, Y. He, and Y. Gong, “Vdc-agent: When video detailed captioners evolve themselves via agentic self-reflection,” arXiv preprint arXiv:2511.19436, 2025. [22] Y. Wang, Z. Huang, and X. Hong, “S-prompts learning with pre-trained transformers: An occam’s razor for domain incremental learning,” Advances in Neural Information Processing Systems, vol. 35, p. 5682–5695, 2022. [23] D. S. Tan, Y.-X. Lin, and K.-L. Hua, “Incremental learning of multi-domain image-to-image translations,” IEEE Transactions on Circuits and Systems for Video Technology, vol. 31, no. 4, p. 1526–1539, 2020. [24] X. Gao, S. Dong, Y. He, Q. Wang, and Y. Gong, “Beyond prompt learning: Continual adapter for efficient rehearsal-free continual learning,” in European Conference on Computer Vision. Springer, 2024, p. 89–106. [25] Y. Hu, J. Hou, X. Liu, X. Sun, and W. Guo, “Video domain incremental learning for human action recognition in home environments,” in International Conference on Image and Graphics. Springer, 2025, p. 316–327. [26] Z. Tao, L. Yu, H. Yao, S. Huang, and C. Xu, “Class incremental learning for light-weighted networks,” IEEE Transactions on Circuits and Systems for Video Technology, vol. 34, no. 12, p. 12 210–12 220, 2024. [27] L. Ding, X. Song, Y. He, C. Wang, S. Dong, X. Wei, and Y. Gong, “Domain incremental object detection based on feature space topology preserving strategy,” IEEE Transactions on Circuits and Systems for Video Technology, vol. 34, no. 1, p. 424–437, 2023. [28] Y.-S. Liang and W.-J. Li, “Inflora: Interference-free low-rank adaptation for continual learning,” in Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, 2024, p. 23 638–23 647. [29] L. Li, S. Wang, C. Li, Y. Yuan, and G. Wang, “Dc-lora: Domain correlation low-rank adaptation for domain incremental learning,” High-Confidence Computing, p. 100270, 2025. [30] D. Isele and A. Cosgun, “Selective experience replay for lifelong learning,” in Proceedings of the AAAI Conference on Artificial Intelligence, vol. 32, no. 1, 2018. [31] D. Rolnick, A. Ahuja, J. Schwarz, T. Lillicrap, and G. Wayne, “Experience replay for continual learning,” Advances in Neural Information Processing Systems, vol. 32, 2019. [32] H. Zhao, H. Wang, Y. Fu, F. Wu, and X. Li, “Memory-efficient class-incremental learning for image classification,” IEEE Transactions on Neural Networks and Learning Systems, vol. 33, no. 10, p. 5966–5977, 2021. [33] J. Kirkpatrick, R. Pascanu, N. Rabinowitz, J. Veness, G. Desjardins, A. A. Rusu, K. Milan, J. Quan, T. Ramalho, A. Grabska-Barwinska et al., “Overcoming catastrophic forgetting in neural networks,” Proceedings of the national academy of sciences, vol. 114, no. 13, p. 3521–3526, 2017. [34] F. Zenke, B. Poole, and S. Ganguli, “Continual learning through synaptic intelligence,” in International conference on machine learning. PMLR, 2017, p. 3987–3995. [35] R. Aljundi, F. Babiloni, M. Elhoseiny, M. Rohrbach, and T. Tuytelaars, “Memory aware synapses: Learning what (not) to forget,” in Proceedings of the European conference on computer vision (ECCV), 2018, p. 139–154. [36] A. F. Akyürek, E. Akyürek, D. T. Wijaya, and J. Andreas, “Subspace regularizers for few-shot class incremental learning,” arXiv preprint arXiv:2110.07059, 2021. [37] H. Liu, L. Gu, Z. Chi, Y. Wang, Y. Yu, J. Chen, and J. Tang, “Few-shot class-incremental learning via entropy-regularized data-free replay,” in European Conference on Computer Vision. Springer, 2022, p. 146–162. [38] Y. Shi, D. Shi, Z. Qiao, Z. Wang, Y. Zhang, S. Yang, and C. Qiu, “Multi-granularity knowledge distillation and prototype consistency regularization for class-incremental learning,” Neural Networks, vol. 164, p. 617–630, 2023. [39] J. Nicolas, F. Chiaroni, I. Ziko, O. Ahmad, C. Desrosiers, and J. Dolz, “Mop-clip: A mixture of prompt-tuned clip models for domain incremental learning,” in Proceedings of the IEEE/CVF Winter Conference on Applications of Computer Vision, 2024, p. 1762–1772. [40] Q. Wang, Y. He, S. Dong, X. Gao, S. Wang, and Y. Gong, “Non-exemplar domain incremental learning via cross-domain concept integration,” in European Conference on Computer Vision. Springer, 2024, p. 144–162. [41] Z. Liu, Y. Peng, and J. Zhou, “Compositional prompting for anti-forgetting in domain incremental learning,” International Journal of Computer Vision, p. 1–18, 2024. [42] S. Wang, C. Li, J. Tang, X. Gong, Y. Yuan, and G. Wang, “Importance-aware shared parameter subspace learning for domain incremental learning,” in Proceedings of the 32nd ACM International Conference on Multimedia, 2024, p. 8874–8883. [43] C. D. Kim, J. Jeong, and G. Kim, “Imbalanced continual learning with partitioning reservoir sampling,” in Computer Vision–ECCV 2020: 16th European Conference, Glasgow, UK, August 23–28, 2020, Proceedings, Part XIII 16. Springer, 2020, p. 411–428. [44] C. Ding, X. Gao, S. Dong, Y. He, Q. Wang, X. Song, A. Kot, and Y. Gong, “Space rotation with basis transformation for training-free test-time adaptation,” arXiv preprint arXiv:2502.19946, 2025. [45] M. Zhang, T. Wang, J. H. Lim, G. Kreiman, and J. Feng, “Variational prototype replays for continual learning,” arXiv preprint arXiv:1905.09447, 2019. [46] H. Shin, J. K. Lee, J. Kim, and J. Kim, “Continual learning with deep generative replay,” Advances in neural information processing systems, vol. 30, 2017. [47] G. M. Van De Ven, Z. Li, and A. S. Tolias, “Class-incremental learning with generative classifiers,” in Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, 2021, p. 3611–3620. [48] M. D. McDonnell, D. Gong, A. Parvaneh, E. Abbasnejad, and A. Van den Hengel, “Ranpac: Random projections and pre-trained models for continual learning,” Advances in Neural Information Processing Systems, vol. 36, p. 12 022–12 053, 2023. [49] D.-W. Zhou, Z.-W. Cai, H.-J. Ye, D.-C. Zhan, and Z. Liu, “Revisiting class-incremental learning with pre-trained models: Generalizability and adaptivity are all you need,” International Journal of Computer Vision, vol. 133, no. 3, p. 1012–1032, 2025. [50] G. Zhang, L. Wang, G. Kang, L. Chen, and Y. Wei, “Slca: Slow learner with classifier alignment for continual learning on a pre-trained model,” in Proceedings of the IEEE/CVF International Conference on Computer Vision, 2023, p. 19 148–19 158. [51] P. Buzzega, M. Boschini, A. Porrello, D. Abati, and S. Calderara, “Dark experience for general continual learning: a strong, simple baseline,” Advances in neural information processing systems, vol. 33, p. 15 920–15 930, 2020. [52] J. Li, C. Ding, S. Dong, Q. Wang, J. Zhao, Y. He, and Y. Gong, “Is parameter isolation better for prompt-based continual learning?” arXiv preprint arXiv:2601.20894, 2026. [53] T. Verma, L. Jin, J. Zhou, J. Huang, M. Tan, B. C. M. Choong, T. F. Tan, F. Gao, X. Xu, D. S. Ting et al., “Privacy-preserving continual learning methods for medical image classification: a comparative analysis,” Frontiers in Medicine, vol. 10, p. 1227515, 2023. [54] Z. Zheng, M. Ma, K. Wang, Z. Qin, X. Yue, and Y. You, “Preventing zero-shot transfer degradation in continual learning of vision-language models,” in Proceedings of the IEEE/CVF international conference on computer vision, 2023, p. 19 125–19 136. [55] G. M. Van de Ven, N. Soures, and D. Kudithipudi, “Continual learning and catastrophic forgetting,” arXiv preprint arXiv:2403.05175, 2024. [56] K. Xu, X. Zou, G. Hua, and J. Zhou, “Componential prompt-knowledge alignment for domain incremental learning,” in International Conference on Machine Learning. PMLR, 2025, p. 70 032–70 046. [57] Q. Gao, C. Zhao, Y. Sun, T. Xi, G. Zhang, B. Ghanem, and J. Zhang, “A unified continual learning framework with general parameter-efficient tuning,” in Proceedings of the IEEE/CVF International Conference on Computer Vision, 2023, p. 11 483–11 493. [58] D.-W. Zhou, H.-L. Sun, H.-J. Ye, and D.-C. Zhan, “Expandable subspace ensemble for pre-trained model-based class-incremental learning,” in Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, 2024, p. 23 554–23 564. [59] S.-A. Rebuffi, H. Bilen, and A. Vedaldi, “Learning multiple visual domains with residual adapters,” Advances in neural information processing systems, vol. 30, 2017. [60] E. J. Hu, Y. Shen, P. Wallis, Z. Allen-Zhu, Y. Li, S. Wang, L. Wang, W. Chen et al., “Lora: Low-rank adaptation of large language models.” ICLR, vol. 1, no. 2, p. 3, 2022. [61] N. Houlsby, A. Giurgiu, S. Jastrzebski, B. Morrone, Q. De Laroussilhe, A. Gesmundo, M. Attariyan, and S. Gelly, “Parameter-efficient transfer learning for nlp,” in International conference on machine learning. PMLR, 2019, p. 2790–2799. [62] Q. Zhang, M. Chen, A. Bukharin, N. Karampatziakis, P. He, Y. Cheng, W. Chen, and T. Zhao, “Adalora: Adaptive budget allocation for parameter-efficient fine-tuning,” arXiv preprint arXiv:2303.10512, 2023. [63] M. Valipour, M. Rezagholizadeh, I. Kobyzev, and A. Ghodsi, “Dylora: Parameter efficient tuning of pre-trained models using dynamic search-free low-rank adaptation,” arXiv preprint arXiv:2210.07558, 2022. [64] A. Ed-dib, Z. Datbayev, and A. M. Aboussalah, “Gelora: Geometric adaptive ranks for efficient lora fine-tuning,” arXiv preprint arXiv:2412.09250, vol. 3, 2024. [65] H. U. K. Shinwari and M. Usama, “Ard-lora: Dynamic rank allocation for parameter-efficient fine-tuning of foundation models with heterogeneous adaptation needs,” IEEE Transactions on Artificial Intelligence, 2025. [66] J. Guo, Z. Zhang, L. Xu, B. Chen, and E. Chen, “Adaptive adapters: An efficient way to incorporate bert into neural machine translation,” IEEE/ACM Transactions on Audio, Speech, and Language Processing, vol. 29, p. 1740–1751, 2021. [67] X. Zhou, D. Liang, W. Xu, X. Zhu, Y. Xu, Z. Zou, and X. Bai, “Dynamic adapter meets prompt tuning: Parameter-efficient transfer learning for point cloud analysis,” in Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, 2024, p. 14 707–14 717. [68] Z.-H. Qi, D.-W. Zhou, Y. Yao, H.-J. Ye, and D.-C. Zhan, “Adaptive adapter routing for long-tailed class-incremental learning,” Machine Learning, vol. 114, no. 3, p. 1–20, 2025. [69] Y. Wang, Z. Ma, Z. Huang, Y. Wang, Z. Su, and X. Hong, “Isolation and impartial aggregation: A paradigm of incremental learning without interference,” in Proceedings of the AAAI Conference on Artificial Intelligence, vol. 37, no. 8, 2023, p. 10 209–10 217. [70] W. Chen, Y. Zhou, N. Du, Y. Huang, J. Laudon, Z. Chen, and C. Cui, “Lifelong language pretraining with distribution-specialized experts,” in International Conference on Machine Learning. PMLR, 2023, p. 5383–5395. [71] J. Yu, Y. Zhuge, L. Zhang, P. Hu, D. Wang, H. Lu, and Y. He, “Boosting continual learning of vision-language models via mixture-of-experts adapters,” in Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, 2024, p. 23 219–23 230. [72] J. Yu, Z. Huang, Y. Zhuge, L. Zhang, P. Hu, D. Wang, H. Lu, and Y. He, “Moe-adapters++: Towards more efficient continual learning of vision-language models via dynamic mixture-of-experts adapters,” IEEE Transactions on Pattern Analysis and Machine Intelligence, 2025. [73] J. Deng, W. Dong, R. Socher, L.-J. Li, K. Li, and L. Fei-Fei, “Imagenet: A large-scale hierarchical image database,” in 2009 IEEE conference on computer vision and pattern recognition. Ieee, 2009, p. 248–255. [74] S. Shalev-Shwartz and S. Ben-David, Understanding machine learning: From theory to algorithms. Cambridge university press, 2014. [75] M. Mohri, A. Rostamizadeh, and A. Talwalkar, Foundations of machine learning. MIT press, 2018. [76] X. Peng, Q. Bai, X. Xia, Z. Huang, K. Saenko, and B. Wang, “Moment matching for multi-source domain adaptation,” in Proceedings of the IEEE/CVF international conference on computer vision, 2019, p. 1406–1415. [77] C. Li, Z. Huang, D. P. Paudel, Y. Wang, M. Shahbazi, X. Hong, and L. Van Gool, “A continual deepfake detection benchmark: Dataset, methods, and essentials,” in Proceedings of the IEEE/CVF Winter Conference on Applications of Computer Vision, 2023, p. 1339–1349. [78] V. Lomonaco and D. Maltoni, “Core50: a new dataset and benchmark for continuous object recognition,” in Conference on robot learning. PMLR, 2017, p. 17–26. [79] A. Dosovitskiy, L. Beyer, A. Kolesnikov, D. Weissenborn, X. Zhai, T. Unterthiner, M. Dehghani, M. Minderer, G. Heigold, S. Gelly et al., “An image is worth 16x16 words: Transformers for image recognition at scale,” arXiv preprint arXiv:2010.11929, 2020. [80] A. Radford, J. W. Kim, C. Hallacy, A. Ramesh, G. Goh, S. Agarwal, G. Sastry, A. Askell, P. Mishkin, J. Clark et al., “Learning transferable visual models from natural language supervision,” in International conference on machine learning. PMLR, 2021, p. 8748–8763. [81] A. Douillard, A. Ramé, G. Couairon, and M. Cord, “Dytox: Transformers for continual learning with dynamic token expansion,” in Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, 2022, p. 9285–9295. [82] Z. Li and D. Hoiem, “Learning without forgetting,” IEEE transactions on pattern analysis and machine intelligence, vol. 40, no. 12, p. 2935–2947, 2017. [83] Z. Wang, Z. Zhang, C.-Y. Lee, H. Zhang, R. Sun, X. Ren, G. Su, V. Perot, J. Dy, and T. Pfister, “Learning to prompt for continual learning,” in Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, 2022, p. 139–149. [84] Z. Wang, Z. Zhang, S. Ebrahimi, R. Sun, H. Zhang, C.-Y. Lee, X. Ren, G. Su, V. Perot, J. Dy et al., “Dualprompt: Complementary prompting for rehearsal-free continual learning,” in European Conference on Computer Vision. Springer, 2022, p. 631–648. [85] J. S. Smith, L. Karlinsky, V. Gutta, P. Cascante-Bonilla, D. Kim, A. Arbelle, R. Panda, R. Feris, and Z. Kira, “Coda-prompt: Continual decomposed attention-based prompting for rehearsal-free continual learning,” in Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, 2023, p. 11 909–11 919. [86] D.-W. Zhou, Z.-W. Cai, H.-J. Ye, L. Zhang, and D.-C. Zhan, “Dual consolidation for pre-trained model-based domain-incremental learning,” in Proceedings of the Computer Vision and Pattern Recognition Conference, 2025, p. 20 547–20 557. [87] Q. Wang, Y. He, S. Dong, X. Song, J. Han, H. Luo, and Y. Gong, “Dualcp: Rehearsal-free domain-incremental learning via dual-level concept prototype,” in Proceedings of the AAAI Conference on Artificial Intelligence, vol. 39, no. 20, 2025, p. 21 198–21 206. [88] Q. Wang, X. Song, Y. He, J. Han, C. Ding, X. Gao, and Y. Gong, “Boosting domain incremental learning: Selecting the optimal parameters is all you need,” in Proceedings of the Computer Vision and Pattern Recognition Conference, 2025, p. 4839–4849. [89] N. Paeedeh, M. Pratama, W. Ding, J. Cao, W. Mayer, and R. Kowalczyk, “Continual knowledge consolidation lora for domain incremental learning,” arXiv preprint arXiv:2510.16077, 2025. [90] L. Li, D.-W. Zhou, H.-J. Ye, and D.-C. Zhan, “Addressing imbalanced domain-incremental learning through dual-balance collaborative experts,” in International Conference on Machine Learning. PMLR, 2025, p. 36 974–36 992. [91] Y. Dai, X. Hong, Y. Wang, Z. Ma, D. Jiang, and Y. Wang, “Prompt customization for continual learning,” IEEE Transactions on Artificial Intelligence, 2025. [92] M.-Y. Park, J.-H. Lee, and G.-M. Park, “Versatile incremental learning: Towards class and domain-agnostic incremental learning,” in European Conference on Computer Vision. Springer, 2024, p. 271–288. [93] L. Wang, J. Xie, X. Zhang, M. Huang, H. Su, and J. Zhu, “Hierarchical decomposition of prompt-based continual learning: Rethinking obscured sub-optimality,” Advances in Neural Information Processing Systems, vol. 36, p. 69 054–69 076, 2023. [94] Y. Feng, Z. Tian, Y. Zhu, Z. Han, H. Luo, G. Zhang, and M. Song, “Cp-prompt: Composition-based cross-modal prompting for domain-incremental continual learning,” in Proceedings of the 32nd ACM International Conference on Multimedia, 2024, p. 2729–2738. [95] L. Pellegrini, G. Graffieti, V. Lomonaco, and D. Maltoni, “Latent replay for real-time continual learning,” in 2020 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS). IEEE, 2020, p. 10 203–10 209. [96] F. Marra, C. Saltori, G. Boato, and L. Verdoliva, “Incremental learning for the detection and classification of gan-generated images,” in 2019 IEEE international workshop on information forensics and security (WIFS). IEEE, 2019, p. 1–6. [97] S. Hou, X. Pan, C. C. Loy, Z. Wang, and D. Lin, “Learning a unified classifier incrementally via rebalancing,” in Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, 2019, p. 831–839. [98] A. Chaudhry, M. Rohrbach, M. Elhoseiny, T. Ajanthan, P. K. Dokania, P. H. Torr, and M. Ranzato, “On tiny episodic memories in continual learning,” arXiv preprint arXiv:1902.10486, 2019. [99] A. Prabhu, P. H. Torr, and P. K. Dokania, “Gdumb: A simple approach that questions our progress in continual learning,” in Computer Vision–ECCV 2020: 16th European Conference, Glasgow, UK, August 23–28, 2020, Proceedings, Part I 16. Springer, 2020, p. 524–540. [100] Y. Wu, Y. Chen, L. Wang, Y. Ye, Z. Liu, Y. Guo, and Y. Fu, “Large scale incremental learning,” in Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, 2019, p. 374–382. [101] P. Buzzega, M. Boschini, A. Porrello, D. Abati, and S. Calderara, “Dark experience for general continual learning: a strong, simple baseline,” Advances in neural information processing systems, vol. 33, p. 15 920–15 930, 2020. [102] H. Cha, J. Lee, and J. Shin, “Co2l: Contrastive continual learning,” in Proceedings of the IEEE/CVF International conference on computer vision, 2021, p. 9516–9525.