1 Introduction↩︎

In dynamic environments of the real world, artificial intelligence systems should, analogous to biological organisms, continuously acquire new knowledge and adapt to novel tasks while reliably preserving previously learned experiences. This capability, known as continual learning, is crucial for advancing models beyond static, controlled experimental settings toward practical real-world deployment. However, conventional incremental learning paradigms typically assume the availability of sufficient labeled data for each newly introduced task, an assumption that is frequently violated in practical scenarios such as medical image analysis or rare species identification, where data scarcity and annotation costs are expensive. As a result, the more challenging problem of Few-Shot Class-Incremental Learning (FSCIL) has gained increasing attention. FSCIL requires models to learn new classes sequentially from only a few labeled examples while simultaneously mitigating catastrophic forgetting of previously acquired knowledge.

In the early stage, some deep learning methods [4], [5] based on prototype representation have been proposed to characterize different categories. A typical approach is to freeze the feature extractor pre-trained on base classes and directly use the prototypes of both old and new classes as classifier weights. The rationale behind this strategy is that freezing the feature extractor helps retain the representational capacity for old-class samples, thereby mitigating the forgetting issue, while using prototypes for incremental few-shot classes can prevent overfitting due to limited data. However, as noted in prior studies [6], the feature extractor itself tends to be biased toward representing old-class samples, resulting in limited generalization ability on new classes. This leads to significant bias in prototypes constructed from only a few new samples, which in turn restricts the model’s recognition performance on new categories. Although subsequent work [1] has attempted to enhance the representational capacity of prototypes in new tasks through strategies such as adaptive weighting, the inherent bias of the feature extractor still limits the improvement in model performance. As shown in Fig. 1, compared to the base model of TEEN, the full model after incremental learning exhibits a performance degradation across all incremental stages. This degradation can be attributed to overfitting on incremental classes with limited samples, which undermines the model’s overall discriminative capability.

More recently, fine-tuning pre-trained models has emerged as an effective paradigm for data-scarce incremental learning tasks [2], [7], benefiting from their strong representation learning and transfer capabilities. A straightforward approach is to fine-tune all model parameters; however, as observed in prior studies, the limited number of incremental samples is often insufficient to reliably optimize the large parameter space, thereby restricting performance gains. To mitigate these challenges, prompt-based tuning methods [3], [8], [9] have gained significant traction. These approaches integrate learnable prompts into specific Transformer layers, facilitating task adaptation by optimizing only a minimal parameter subset. Consequently, they effectively preserve the generalization capabilities of the pre-trained backbone while enabling efficient downstream adaptation, yielding competitive results in few-shot scenarios. However, such performance gains during incremental stages may primarily be attributed to the inherent generalization capability of the pre-trained backbone. As illustrated in Fig. 1, the full models of neither ASP [2] nor SEC [3] demonstrate a substantial improvement in accuracy over their respective base models on incremental tasks (i.e., Average(F.M.) VS Average(B.M). This suggests that while the pre-trained model retains robust generalization on unseen categories, it struggles to extract additional discriminative power from the incremental stages. Ultimately, under conditions of extreme data scarcity, the model’s capacity to assimilate novel knowledge and substantively enhance its global discriminative power remains fundamentally constrained.

To address these challenges, we pivot from traditional backbone adaptation to a strategy of freezing the feature extractor while fine-tuning prototypes. This approach is grounded in the observation that modern pre-trained backbones already provide a highly expressive and generalizable feature space. Consequently, the primary hurdle in incremental learning shifts from feature acquisition to the optimization of decision regions within a static space. The objective becomes defining accurate, well-separated class boundaries for novel categories under low-data regimes while rigorously maintaining the integrity of previously established representations.

Guided by this insight, we focus optimization exclusively on the calibration of class prototypes. We introduce an efficient fine-tuning framework that refines class representations through two complementary learnable components: class-specific offsets, which enhance the discriminability of individual class centroids, and task-aware offsets, which model global inter-class relationships to facilitate robust task-level separation. By synergistically leveraging these offsets, our method preserves the intrinsic representational fidelity of the frozen backbone while injecting task-relevant discriminative context. The main contributions of this work are threefold:

• To the best of our knowledge, we are the first to introduce an efficient prototype fine-tuning framework for FSCIL. Unlike conventional paradigms that prioritize backbone optimization, our framework evolves static prototypes into dynamic learnable components, shifting the focus toward refinement within the decision space.

• We introduce a dual-calibration method that augments existing prototypes through class-level and task-level offsets. It enables static prototypes to evolve into dynamic representations that characterize the feature distribution of the current task, facilitating robust adaptation in incremental settings.

• Extensive experiments demonstrate that our method achieves SOTA performance with minimal parameter overhead.

2 Related Work↩︎

2.1 Class-Incremental Learning↩︎

Non-prompt-based methods. In the context of class-incremental learning, conventional non-prompt-based methods employ diverse mechanisms to mitigate catastrophic forgetting. Replay-based approaches (e.g., iCaRL [10], GR [11]) preserve historical knowledge by retaining a subset of previous samples or generating pseudo-samples for joint optimization with novel data. Regularization-based methods (e.g., GEM [12], A-GEM [13]) impose constraints on parameter updates to ensure that optimization for new tasks does not compromise performance on established ones. Meanwhile, knowledge distillation frameworks (e.g., LwF [14], PODNet [15]) utilize the preceding model as a teacher to transfer semantic knowledge embedded in either prediction distributions or latent feature representations to the student model. While effective to a degree, these strategies are often hindered by practical constraints, such as the requirement for historical data buffers, the overhead of maintaining legacy model checkpoints, or computationally intensive optimization strategies.

Prompt-based methods. To mitigate catastrophic forgetting in class-incremental learning, L2P [16] introduced a framework based on prompt pool retrieval, selecting the most relevant prompts for each input to facilitate task adaptation. DualPrompt [17] extended this architecture by decoupling prompts into task-shared and task-specific components to balance knowledge transfer and task specialization. CODA-Prompt [18] further refined this selection process by employing an attention mechanism to dynamically weight and aggregate prompts. Exploiting multimodal synergies, S-Prompt [19] utilized CLIP to jointly optimize visual and textual prompts for enhanced semantic alignment, while CAPrompt [20] guided inference through the dynamic aggregation of prompts from historical tasks. Despite their success, these methods remain data-dependent, requiring a sufficient volume of novel samples to effectively optimize prompt parameters. Under the constraints of extreme data scarcity, these learnable prompts struggle to converge on stable, generalizable representations, frequently resulting in overfitting.

2.2 Few-Shot Class-Incremental Learning↩︎

Prototype-based methods. To counter the overfitting risks prevalent in data-scarce scenarios, many few-shot methods adopt prototype-based representations [21]. These approaches characterize each class by its feature centroid and utilize metric learning for sample classification. Nevertheless, given the extreme sparsity of novel-category samples, direct point estimation of prototypes is highly susceptible to significant statistical bias, failing to represent the true underlying class distribution [22]. To address this issue, FACT [5] allocated virtual class prototypes during pretraining to reserve embedding space for novel class prototypes. TEEN [1] proposed a training free prototype calibration strategy that corrected the distributional bias of novel class prototypes by fusing them with semantically related base class prototypes. While these methods mitigate prototype bias to some extent, they often rely on backbone adaptation, which remains highly susceptible to overfitting under extreme data scarcity. This instability may trigger a representation drift that compromises previously acquired knowledge, thereby exacerbating the stability-plasticity dilemma.

Prompt-based methods. Recently, pre-trained models have garnered significant attention in FSCIL due to their robust generalization capabilities [2], [23]. To facilitate task adaptation while preserving the integrity of the pre-trained feature space, several approaches freeze the backbone network and introduce a minimal set of learnable parameters. Notably, prompt-based methods integrate learnable tokens into Transformer layers, enabling the model to incrementally capture evolving concepts through targeted fine-tuning of these prompts. For example, SEC-Prompt [3] achieved semantic complementarity through discriminative and non-discriminative prompts, and DSS-P [8] enabled training-free incremental learning by combining static domain prompts with dynamic instance-aware prompts. To address representation saturation caused by excessive token-level prompt concatenation, LGSP [9] abandoned conventional token-based prompts and instead generated spatial prompt maps by coupling local spatial features with global frequency-domain representations, thereby alleviating feature competition. Despite significant advancements in few-shot incremental learning, the challenge of efficiently optimizing pre-trained models with extremely limited incremental data remains an open research question.

3 Method↩︎

Overview. In this paper, we propose an efficient prototype calibration framework, as shown in Fig. 2. Instead of the computationally intensive fine-tuning of the entire feature extractor, our approach directly optimizes class prototypes. This strategy preserves the rich generalization of the pre-trained backbone while facilitating rapid adaptation to novel classes. The process begins by extracting initial class prototypes using a frozen pre-trained backbone. To bolster discriminative power, we introduce class-specific and task-aware offsets that calibrate these prototypes within the feature space, ensuring a more robust and separable representation of individual categories. Finally, we employ a negative error projection metric to map query features into the calibrated prototype space, enabling efficient and robust class matching. As incremental tasks progress, these offsets are gradually accumulated to construct a calibration pool. This calibration pool is further divided into two sub-pools: a task pool (Pool-T) and a class pool (Pool-C). The core components of this architecture are detailed below.

Problem Definition In the setting of FSCIL, the training dataset is defined as \(\mathcal{D} = \{\mathcal{D}^0, \mathcal{D}^1, \ldots, \mathcal{D}^T\}\), where \(\mathcal{D}^0\) denotes the dataset of the base task and \(\mathcal{D}^t (t > 0)\) denotes the dataset of the \(t\)-th incremental task. For each task, the dataset is defined as \(\mathcal{D}^t = \{(x_i^t, y_i^t)\}_{i=0}^{n_t}\), where \(x_i^t \in \mathbb{R}^d\) represents the feature of the \(i\)-th training sample and \(y_i^t \in \mathcal{Y}_t\) denotes its corresponding class label. The label spaces of different tasks are disjoint \(\mathcal{Y}_i \cap \mathcal{Y}_j = \varnothing\) for \(i \neq j\). In the base task, the model is trained on the dataset \(\mathcal{D}^0\), which contains sufficient samples per class to learn effective representations for the base class set \(\mathcal{Y}_0\). During each incremental task, the model can only access the data from the current task \(\mathcal{D}^t\) for training, and historical data are not available for replay. Therefore, the model is required not only to learn newly introduced classes but also to maintain performance on previously learned classes, thereby mitigating catastrophic forgetting. After each incremental task, the model is evaluated on a test set that includes all classes encountered up to that point. Specifically, after the \(t\)-th incremental task, the evaluation label space is defined as \(\mathcal{Y}_0 \cup \mathcal{Y}_1 \cup \cdots \cup \mathcal{Y}_t\), and the model is expected to correctly classify samples from all these classes.

3.1 Prototype Representation↩︎

Due to the limited number of training samples, models are highly susceptible to overfitting, which in turn exacerbates catastrophic forgetting in incremental learning settings. To mitigate this issue, we adopt class prototypes as category representations [21]. In the embedding space, each category is characterized by a prototype that acts as a representative anchor, encouraging samples from the same category to cluster tightly around it. Given a frozen pretrained feature extractor \(f(\cdot)\), an input sample is mapped to a feature vector in the embedding space. For a class \(c\), its prototype is defined as the mean feature of all support samples belonging to that class: \[{p}_c^{\text{raw}} = \frac{1}{|\mathcal{S}_c|} \sum_{x \in \mathcal{S}_c} f(x), \label{eq:1}\tag{1}\] where \(\mathcal{S}_c\) denotes the support set of class \(c\).

In the base task, the availability of sufficient training data enables reliable estimation of class prototypes. Conversely, during incremental tasks, prototypes can only be inferred from only a few samples, which inevitably introduces statistical bias. As the learning process unfolds, this bias accumulates over successive tasks, substantially impairing the quality of class representations across tasks. To alleviate this issue, we propose an efficient fine-tuning strategy that calibrates prototype representations through class-level and task-level offsets, to improve their discriminability as elaborated in the subsequent sections.

3.2 Class-Specific Offset↩︎

Although pre-trained models exhibit strong generalization to unseen categories, their performance is often limited when directly transferred to downstream tasks. To alleviate this issue, we introduce a learnable class-specific offset for each class prototype. Acting as a lightweight and independent regulator, the offset vector enables fine-grained adaptation of class representations while preserving the stability of the core features learned from pre-trained task.

Specifically, for each incremental task, we first compute the original class prototypes \({p}_c^{\text{raw}} \in \mathbb{R}^{d_f}\) using a frozen feature extractor. Conditioned on these prototypes, we initialize a learnable offset vector \({p}_c^{\text{class}}\) for each category by sampling from a scaled Gaussian distribution, i.e., \({p}_c^{\text{class}} \sim \alpha \cdot \mathcal{N}(\mathbf{0}, \mathbf{I})\), where \(\alpha\) controls the magnitude of initialization values. This design ensures that, in the early stages of training, the effective category representation is dominated by the original prototype, with only a minimal contribution from the offset vector. As a result, optimization starts from a stable initialization, reducing training oscillations and facilitating smooth and reliable convergence. Upon the arrival of a new incremental task, we apply a consistent procedure to the novel classes: initializing their original class prototypes alongside their corresponding offset vectors.

3.3 Task-Aware Offset↩︎

Class-specific offsets primarily refine individual category representations but overlook class relationships across tasks. To this end, we introduce a task-aware offset that models task-specific data distribution biases and enables targeted calibration. This offset explicitly characterizes the deviation between the data distribution of the current task and the general pre-trained distribution. Consequently, the model can consistently adjust the prototypes of all categories in a task-aware manner, guided by the global characteristics of the task. This design facilitates more accurate adaptation to task-specific data properties and leads to more well-defined classification boundaries.

To be more specific, for each task \(t\), we introduce a learnable task offset vector \({p}_t^{\text{task}} \in \mathbb{R}^{d_t}\), where \(d_t\) denotes the dimensionality of the task offset. The offset is initialized to zero and shared among all classes within the same task. For each class \(c \in \mathcal{C}_t\), the task offset is fed into a dependent class projector to generate an offset vector \({o}^{\text{task}}_c\). Such a design allows the shared task offset to generate distinct offset representations for different classes. Each projector is implemented as a two-layer multilayer perceptron (MLP) with a hidden dimension \(d_h\). Formally, it is formulated as: \[{o}^{\text{task}}_c = \mathrm{MLP}_c({p}_t^{\text{task}}). \label{eq:task95offset}\tag{2}\]

To further enhance class separability, we introduce an inter-class discrimination loss \(L_{\text{inter}}\) to regularize the calibrated prototypes, which is described in the next section. The final calibrated prototypes for class \(c\) are defined as: \[{p}_c = {p}_c^{\text{raw}} + {p}_c^{\text{class}} + {o}^{\text{task}}_c. \label{eq:final95prototype}\tag{3}\]

After completing each task, we freeze these calibrated prototypes \({p}_c\).

3.4 Negative Error Projector↩︎

Given prototypes, existing methods [2], [21] typically employ distance metrics such as Euclidean distance [24] or cosine similarity [25] to assign a query feature to the category corresponding to its most similar prototype. These methods treat each prototype as an isolated point in the feature space, overlooking the potential inter‑relationships among prototypes. Especially in the few‑shot incremental learning scenario, prototypes derived from a very limited number of samples are often unstable and may not reliably represent the entire category. This further complicates the accurate discrimination of query features.

To address this issue, we adopt a negative error projector for classification. Specifically, the query feature is formulated as a linear combination of all class prototypes, where the optimal combination coefficients are obtained by minimizing the reconstruction error [26]. The category of the query is then determined based on the residual discrepancy between the reconstructed feature and the original query feature. This formulation explicitly captures fine-grained linear relationships between the query feature and all prototypes, thereby modeling continuous semantic information that reflects the degree to which a sample belongs to each category. Consequently, it enables more refined and principled classification decisions.

Let \(K \in \mathbb{R}^{C \times d_f}\) denote the matrix of enhanced prototypes after task \(t\), where \(C\) is the number of observed classes, and let \(\mathbf{f} \in \mathbb{R}^{d_f}\) denote an input feature. We obtain the reconstruction coefficient vector \(\boldsymbol{\rho} \in \mathbb{R}^{C}\) by solving the following regularized least-squares problem:

\[\min_{\boldsymbol{\rho}} \; \left\lVert f(x) - K^\top \boldsymbol{\rho} \right\rVert_2^2 + \lambda_{\text{reg}} \left\lVert \boldsymbol{\rho} \right\rVert_2^2, \label{eq:lsq}\tag{4}\] where \(\lambda_{\text{reg}}\) is a regularization parameter. The closed-form solution is \(\boldsymbol{\rho}^{*} =(KK^\top + \lambda_{\text{reg}} \mathbf{I})^{-1}Kf(x)\). The normalized reconstruction residual is then computed for each class \(i\) as follows: \[R_i(\mathbf{f}) = \frac{\left\lVert f(x) - \boldsymbol{\rho}^{*}_i K_i \right\rVert_2}{\left\lVert \boldsymbol{\rho}^{*}_i \right\rVert_2 + \epsilon}, \label{eq:residual}\tag{5}\] where \(\epsilon\) is a small constant.

Optimization. Prior prototype-based networks typically treat a class prototype as a rigid statistical anchor, namely, the mean vector of support features within a latent space. In these frameworks, prototypes are updated only indirectly through global parameter optimization, requiring a full recomputation whenever the feature extractor changes.

Our proposed method decouples the prototype into a dual-component architecture: a base statistical prototype and a learnable offset vector. By directly optimizing this offset, we transition the class representation from a static, one-time calculation into a dynamic, task-adaptive embedding. This mechanism allows for accurate calibration through a joint objective of the cross-entropy classification loss \(L_{\text{CE}}\) and inter-class discrimination loss \(L_{\text{inter}}\). Specifically, for a given sample \(x_i\) with the label \(y_i\), we define \(\mathcal{P}_{\text{neg}}\) as the set of calibrated prototypes excluding the prototype corresponding to \(y_i\). This set encompasses all class representations from both the current stage and previously encountered classes, effectively serving as the set of negative class anchors for the current sample. The inter-class loss for sample \(x_i\) is defined as: \[L_{\text{inter}}(x_i) = \frac{1}{|\mathcal{P} _{\mathrm{neg}}|}\frac{1}{\sum_{p_j\in \mathcal{P} _{\mathrm{neg}}}{\left\| f(x_i)-p_j \right\|}+\epsilon}, \label{eq:inter95loss}\tag{6}\] where \(\epsilon\) is a small constant.

The overall training objective is formulated as: \[L = L_{\text{CE}} + \lambda_{\text{inter}} L_{\text{inter}}, \label{eq:total95loss}\tag{7}\] where \(\lambda_{\text{inter}}\) is a hyper-parameter.

2.2pt

4 Experiments↩︎

4.1 Experiment Setup↩︎

Datasets. We evaluate our method across four benchmark datasets: CUB-200, ImageNet-R, ImageNet-A, and VTAB. For the first three, each comprising 200 classes, we reserve 100 classes for the base stage and distribute the remaining 100 classes across ten 10-way 5-shot incremental tasks, totaling 11 stages. For VTAB, which contains 50 classes, the base stage covers 14 classes, followed by nine 4-way 5-shot incremental tasks for a total of 10 stages.

Training Details. Across all datasets, the model is trained for 100 epochs during the base stage and 60 epochs per incremental stage, using a batch size of 64. Hyper-parameters are configured with \(\lambda_{\text{reg}}=0.3\) for the negative error projector, \(\lambda_{\text{inter}}=0.1\) for the inter-class discrimination loss, and a scaling factor of \(\alpha=0.001\). The hidden dimension of MLPs is set to \(d_h=4\) for CUB-200, ImageNet-A, and VTAB, while a higher dimension of \(d_h=8\) is utilized for ImageNet-R. Unless otherwise specified, all other hyperparameters remain consistent across all experimental settings. We will publicly release our code upon the acceptance of our paper.

Evaluation Protocol. Following established benchmarks, we adopt the widely used Top-1 accuracy, which is denoted as \(A_i\) for the \(i\)-th stage. The overall performance is evaluated using the average accuracy (Avg), defined as the arithmetic mean of accuracies across all stages.

4.2 Comparison With State-of-the-Art Methods↩︎

To validate the effectiveness of the proposed method, we conduct a comprehensive comparison against SOTA approaches across multiple datasets. For simplicity, we term our method EPT, short for Efficient Prototype Tuning. Before presenting the results, we introduce two variants of our method: EPT and EPT\(^*\), which utilize DINOv2 and DINOv3 as their respective backbone networks. The experimental results on CUB-200 are provided in Table 1. As illustrated, both of our proposed solutions consistently outperform the second-best method, DSS-P [8], across all incremental stages. Specifically, EPT achieves a final-stage accuracy of 85.10%. Furthermore, EPT\(^*\) significantly surpasses EPT throughout the incremental process, yielding a 1.0% improvement in final average incremental accuracy. Notably, our methods maintain high parameter efficiency, requiring only 0.22M and 0.28M learnable parameters, respectively. We notice that the recent method LGSP [9] optimizes fewer learnable parameters than our method, with only 0.21M, but its accuracy in the final stage is 6.2% lower than ours, and its average accuracy is 5.3% lower. In addition, we provide comprehensive performance comparisons across ImageNet-R, VTAB, and ImageNet-A, as illustrated in Fig. 3. Our proposed method consistently achieves superior results. Notably, EPT\(^*\), leveraging the DINOv3 backbone, demonstrates substantial performance gains, with particularly marked improvements observed on the challenging ImageNet-R and ImageNet-A datasets. These results underscore the robustness and scalability of our model in data-constrained incremental scenarios.

4pt

4.3 Ablation Study↩︎

In this subsection, we conduct ablation studies to evaluate the effectiveness of each proposed strategy on CUB-200. Unless otherwise specified, all experiments utilize DINOv2 as feature extractor.

Analysis of key components. Table 2 summarizes the ablation studies for our model’s key components, detailing the accuracy at each stage from S0 to S10. Each module is shown to contribute positively to the overall performance. Specifically, the individual integration of Class-Specific (CS) and Task-Aware (TA) offsets yields measurable gains in model performance. While the CS offset facilitates fine-grained, independent parameter adjustments for each class prototype, the TA offset explicitly models the inter-task relationships. Our experimental results demonstrate that the simultaneous application of both offsets further enhances performance, confirming that these modules are functionally complementary. These results validate the effectiveness of the proposed approach.

Analysis of backbones. In our framework, we freeze the pre-trained backbone and facilitate incremental learning solely by fine-tuning prototypes. This strategy relies on the assumption that the backbone possesses robust generalization capabilities. To evaluate the influence of various pre-training paradigms on incremental performance, we conduct a comparative analysis using four representative models: iBOT, ImageNet-1K, DINOv2, and DINOv3. Notably, ImageNet-1K represents a supervised baseline, whereas the others are derived from self-supervised pre-training.

As illustrated in Fig. 4, compared to our baseline, our method can significantly improve its performance across different pre-training backbones. Here, the baseline refers to our method excluding both CS Offset and TA Offset. Furthermore, the results indicate that DINOv2 and DINOv3 achieve superior results, while iBOT yields the lowest performance. This performance gap is likely attributable to the massive datasets used to train the DINO series, which significantly bolster their representational capacity and cross-domain generalization. While the supervised ImageNet-1K model provides a competent baseline, its ability to generalize to novel incremental tasks remains markedly inferior to that of the large-scale self-supervised models. Ultimately, these findings confirm that backbones pre-trained on extensive, diverse data provide the most stable and reliable feature foundations, which are critical for effective prototype-based incremental learning.

Analysis of distance metrics. Unlike traditional classification paradigms, prototype-based methods fundamentally rely on distance metrics to determine class membership. To evaluate the robustness of our approach, we conduct a comparative analysis across several standard metrics, including Euclidean distance [24], squared Euclidean distance [21], and cosine distance [1], [2], [25]. The results are presented in Fig. 5. As illustrated, our method consistently achieves superior performance across all metrics. Traditional approaches typically treat prototypes as isolated points within the feature space, thereby neglecting the intrinsic structural correlations between classes. In contrast, the negative error projector explicitly models these linear correlations to refine the model’s offset vectors. By leveraging this relational information, we significantly enhance the discriminative power of the prototypes.

5 Conclusion↩︎

This work studies the core challenges of FSCIL, namely, catastrophic forgetting and overfitting, by rethinking the conventional fine-tuning paradigm. Given the high risk of updating a pre-trained backbone with scarce incremental data, we freeze the feature extractor to fully exploit its well-structured latent space and instead concentrate optimization on class prototypes. To this end, we introduce dynamic, learnable prototypes refined through a dual-calibration method that incorporates both class-specific and task-aware offsets. The former offsets improve the discriminability of individual class centroids, whereas the latter offsets capture global inter-class relationships, enabling robust separation at the task level. Moreover, we employ a negative error projector to establish and optimize the relationship between the features of the query sample and the calibrated prototypes, thereby achieving the final classification decision. Extensive experiments demonstrate that the proposed method achieves SOTA performance on multiple benchmarks with negligible parameter overhead.

Impact Statement↩︎

This paper presents work whose goal is to advance the field of machine learning. There are many potential societal consequences of our work, none of which we feel must be specifically highlighted here.

langley00?

6 Appendix↩︎

Analysis of different prototype-based methods. To verify that the proposed fine-tuning strategy can efficiently learn prototypes, we employ the same backbone network and compare it with different previous prototype learning methods. The experimental results are shown in Fig. 6. It can be observed that although our method performs slightly worse on the initial base classes compared to certain baseline models, it demonstrates superior and stable performance in each subsequent incremental learning stage. This indicates that our method has stronger feature retention capabilities for learned categories, effectively mitigating catastrophic forgetting. Furthermore, compared to the other methods, our strategy requires fine-tuning only a small number of parameters related to the prototypes, without updating backbones. This approach significantly reduces the risk of overfitting and enhances the representational robustness of the prototypes. These results further demonstrate that the effectiveness of our proposed strategy, rather than relying solely on a powerful pre-trained backbone.

References↩︎