Learning Yourself: Class-Incremental Semantic Segmentation with Language-Inspired Bootstrapped Disentanglement

TL;DR

This paper introduces a novel framework called LBD that leverages pre-trained visual-language models to improve class-incremental semantic segmentation by disentangling features guided by language semantics, achieving state-of-the-art results.

Contribution

The paper proposes a language-inspired bootstrapped disentanglement framework that uses CLIP's semantic prior to address catastrophic semantic entanglement in incremental segmentation tasks.

Findings

Achieves state-of-the-art performance on Pascal VOC and ADE20k datasets.

Effectively disentangles features using language-guided prototypes.

Improves multi-step incremental segmentation accuracy.

Abstract

Class-Incremental Semantic Segmentation (CISS) requires continuous learning of newly introduced classes while retaining knowledge of past classes. By abstracting mainstream methods into two stages (visual feature extraction and prototype-feature matching), we identify a more fundamental challenge termed catastrophic semantic entanglement. This phenomenon involves Prototype-Feature Entanglement caused by semantic misalignment during the incremental process, and Background-Increment Entanglement due to dynamic data evolution. Existing techniques, which rely on visual feature learning without sufficient cues to distinguish targets, introduce significant noise and errors. To address these issues, we introduce a Language-inspired Bootstrapped Disentanglement framework (LBD). We leverage the prior class semantics of pre-trained visual-language models (e.g., CLIP) to guide the model in autonomously disentangling features through Language-guided Prototypical Disentanglement and Manifold Mutual Background Disentanglement. The former guides the disentangling of new prototypes by treating hand-crafted text features as topological templates, while the latter employs multiple learnable prototypes and mask-pooling-based supervision for background-incremental class disentanglement. By incorporating soft prompt tuning and encoder adaptation modifications, we further bridge the capability gap of CLIP between dense and sparse tasks, achieving state-of-the-art performance on both Pascal VOC and ADE20k, particularly in multi-step scenarios.

Tables

Table 1. Table 1 : Performance comparison on ADE20k across various scenarios in overlapped setting. CNN and Transformer indicates the type of the backbone. * denotes results from [ 42 ] , † indicates the results reproduced using the same version of ViT as the other methods. Har. denotes the harmonic mean of the MIoU between the initial class set C 1 C^{1} and the incremented sets C 2 : T C^{2:T} .

Method	100-50 (2 steps)				50-50 (3 steps)				100-10 (6 steps)				100-5 (11 steps)
	1-100	101-150	All	Har.	1-50	51-150	All	Har.	1-100	101-150	All	Har.	1-100	101-150	All	Har.
CNN-based Methods
MiB [3]	40.5	17.2	32.8	24.1	45.5	21.0	29.3	28.7	38.2	11.1	29.2	17.2	36.0	5.7	26.0	9.8
SDR [32]	37.4	24.8	33.2	29.8	40.9	23.8	29.5	30.1	28.9	7.4	21.7	11.8	-	-	-	-
PLOP [11]	41.7	15.4	33.0	22.5	47.8	21.6	30.4	29.8	39.4	13.6	30.9	20.2	39.1	7.8	28.8	13.0
REMIND [35]	41.6	19.2	34.1	26.3	47.1	20.4	29.4	28.5	39.0	21.3	33.1	27.6	-	-	-	-
RCIL [59]	42.3	18.8	34.5	26.0	48.3	25.0	32.5	32.9	39.3	17.6	32.0	24.3	38.5	11.5	29.6	17.7
SPPA [24]	42.9	19.9	35.2	27.2	49.8	23.9	32.5	32.3	41.0	12.5	31.5	19.2	-	-	-	-
RBC [61]	42.9	21.5	35.8	28.6	49.6	26.3	34.2	34.4	39.0	21.7	33.3	27.9	-	-	-	-
Joint (upper bound)	43.9	27.2	38.3	33.6	50.9	32.1	38.3	39.4	43.9	27.2	38.3	33.6	43.9	27.2	38.3	33.6
Transformer-based Methods
MiB* [3]	46.6	35.0	42.6	40.0	52.2	35.6	41.1	42.3	43.0	30.8	38.9	35.9	40.2	26.6	35.7	32.0
INC* [42]	49.4	35.6	44.8	41.4	56.2	37.8	43.9	45.2	48.5	34.6	43.9	40.4	46.9	31.3	41.7	37.5
MBS† [33]	49.3	37.5	45.3	42.6	56.2	39.7	45.4	46.5	48.1	34.0	43.7	39.8	45.9	30.0	40.6	36.3
Ours	51.3	38.7	47.1	44.1	56.2	40.6	45.8	47.1	48.7	34.9	44.1	40.7	46.9	31.9	41.8	38.0
Joint (upper bound)	52.9	42.6	49.5	47.2	58.9	44.7	49.5	50.8	52.9	42.6	49.5	47.2	52.9	42.6	49.5	47.2

Table 2. Table 2 : Comparison of the methods combined with CLIP in the Pascal VOC 15-1 overlapped setting.

Method	1-15	16-20	All
INC	79.6	59.6	75.6
INC+CLIP	80.7 (+1.1)	58.6 (-1.0)	76.1 (+0.5)
MBS	80.9	64.9	77.6
MBS+CLIP	81.0 (+0.1)	64.3 (-0.6)	76.8 (-0.8)
Ours (Fix)	78.9	49.0	72.1
Ours	81.9	66.6	78.1

Table 3. Table 3 : Performance comparison on Pascal VOC under various scenarios. * denotes results from [ 42 ] , † indicates the results reproduced using the same version of ViT as the other methods. Har. denotes the harmonic mean of the MIoU between the initial class set C 1 C^{1} and the incremented sets C 2 : T C^{2:T} .

Method	19-1 (2 steps)								15-5 (2 steps)								15-1 (6 steps)
	Disjoint				Overlapped				Disjoint				Overlapped				Disjoint				Overlapped
	1-19	20	All	Har.	1-19	20	All	Har.	1-15	16-20	All	Har.	1-15	16-20	All	Har.	1-15	16-20	All	Har.	1-15	16-20	All	Har.
CNN-based Methods
EWC [18]	23.2	16.0	22.9	23.2	26.9	14.0	26.3	18.4	26.7	37.7	29.4	31.3	24.3	35.5	27.1	28.9	0.3	4.3	1.3	0.6	0.3	4.3	1.3	0.6
ILT [30]	69.1	16.4	66.4	26.5	67.8	10.9	65.1	18.8	63.2	39.5	57.3	48.6	67.1	39.2	60.5	49.5	3.7	5.7	4.2	4.5	8.8	8.0	8.6	8.4
MiB [3]	69.6	25.6	67.4	37.4	71.4	23.6	69.2	35.5	71.8	43.3	64.7	54.0	76.4	50.0	70.1	60.4	46.2	12.9	37.9	20.2	34.2	13.5	29.3	19.4
SDR [32]	69.9	37.3	68.4	48.6	69.1	32.6	67.4	44.3	73.5	47.3	67.2	57.6	75.4	52.6	69.9	62.0	59.2	12.9	48.1	21.2	44.7	21.8	39.2	29.3
PLOP [11]	75.4	38.9	73.6	51.3	75.4	37.4	73.5	50.0	71.0	42.8	64.3	53.4	75.7	51.7	70.1	61.4	57.9	13.7	46.5	22.2	65.1	47.8	62.7	55.1
RECALL [29]	65.2	50.1	65.8	56.7	67.9	53.5	68.4	59.8	66.3	49.8	63.5	56.9	66.6	50.9	64.0	57.7	66.6	44.9	62.1	53.6	65.7	47.8	62.7	55.3
REMIND [35]	-	-	-	-	76.5	32.3	74.4	45.4	-	-	-	-	76.1	50.7	70.1	60.9	-	-	-	-	68.3	27.2	58.5	38.9
RCIL [59]	-	-	-	-	-	-	-	-	75.0	42.8	67.3	54.5	78.8	52.0	72.4	62.7	66.1	18.2	54.7	28.5	70.6	23.7	59.4	35.5
SPPA [24]	75.5	38.0	73.7	50.6	76.5	36.2	74.6	49.1	75.3	48.7	69.0	59.1	78.1	52.9	72.1	63.1	59.6	15.6	49.1	24.7	66.2	23.3	56.0	34.5
RBC [61]	76.4	45.8	75.0	57.3	77.3	55.6	76.2	64.7	75.1	49.7	69.9	59.8	76.6	52.8	70.9	62.5	61.7	19.5	51.6	29.6	69.5	38.4	62.1	49.5
Joint (upper bound)	77.4	78.0	77.4	77.7	77.4	78.0	77.4	77.7	79.1	72.6	77.4	75.7	79.1	72.6	77.4	75.7	79.1	72.6	77.4	75.7	79.1	72.6	77.4	75.7
Transformer-based Methods
MiB* [3]	80.6	45.2	79.6	57.9	79.9	47.7	79.1	59.7	75.0	59.9	72.3	66.6	78.6	63.1	75.6	70.0	66.7	26.3	58.3	37.7	72.6	23.1	61.7	35.0
RBC* [61]	80.9	42.1	79.7	55.4	80.2	38.8	79.0	52.3	77.7	59.1	74.0	67.1	78.9	62.0	75.5	69.4	69.0	28.4	60.5	40.2	75.9	40.2	68.2	52.6
INC* [42]	82.4	64.2	82.2	72.2	82.5	61.0	82.1	70.1	81.6	62.2	77.6	70.6	82.5	69.3	79.9	75.3	81.4	57.1	76.3	67.1	79.6	59.6	75.6	68.2
MBS† [33]	81.4	69.3	81.4	74.9	81.9	66.1	81.7	73.2	80.8	66.9	78.2	73.2	83.1	72.4	80.4	77.4	78.5	60.9	74.9	68.6	80.9	64.9	77.6	72.0
Ours	81.7	70.1	81.1	75.5	82.2	70.0	81.6	75.6	81.2	67.7	78.0	73.8	83.2	73.6	80.8	78.1	81.0	62.3	76.3	70.4	81.9	66.6	78.1	73.5
Joint (upper bound)	83.0	83.2	83.0	83.1	83.0	83.2	83.0	83.1	83.6	81.3	83.0	82.4	83.6	81.3	83.0	82.4	83.6	81.3	83.0	82.4	83.6	81.3	83.0	82.4

Table 4. Table 4 : Ablation study for each component on Pascal VOC 15-1 overlapped setting. Prompt, Manifold denote learnable prompts, and manifold background representation, respectively.

Prompt	LPD	Manifold	MBD	1-15	16-20	All
				75.9	48.1	68.9
$✓$				78.8	62.8	74.8
$✓$	$✓$			81.4	65.5	77.4
$✓$	$✓$	$✓$		81.6	66.1	77.7
$✓$	$✓$	$✓$	$✓$	81.9	66.6	78.1

Table 5. Table 5 : Computational and performance comparison. Our LBD method significantly outperforms DenseCLIP with only a minor increase in computational cost. Notably, key components of LBD are training-only and do not affect inference speed.

Method	DenseCLIP (Zero-shot)	DenseCLIP (Continual-train)	LBD (Ours)	Joint
VOC 15-1 All	61.2	68.7	78.1	83.0
Params (M)	105.3	105.3	121.1	-
GFLOPs	143.8	143.8	148.2	-

Table 6. Table 6 : Ablation study on integrating PEFT methods within our framework on Pascal VOC 15-1 All . We evaluate training different combinations of: ➊ Prompts, ➋ Adapter, and ➌ the full Image Encoder. Full fine-tuning of the encoder remains essential for achieving top performance.

Reference	➊ Prompts (Sec.3.2) ➋ Adapter (after encoder) ➌ Image Encoder (CLIP-ViT)
Trainable	➊	➋	➊➋	➊➌	➊➋➌
VOC 15-1 All	64.8	66.9	72.1	77.4	78.1

Equations

$${\mathbf{t}}_i^{pre}=[{\mathbf{p}}_i,[CL{S}_i]],$$

$${\mathbf{S}}_i={\mathbf{t}}_i^{\prime }{\mathbf{v}}^{\prime }.$$

$${\mathcal{L}}_{stability}$$

$$+\sum _{i,j,k}{l}_{\delta }({\psi }_A({\mathbf{t}}_i,{\mathbf{t}}_j,{\mathbf{t}}_k),{\psi }_A({\mathbf{t}}_i^{\ast },{\mathbf{t}}_j^{\ast },{\mathbf{t}}_k^{\ast })),$$

$${\mathcal{L}}_{plasticity}=\sum _{(i,j)\in E}(1-\cos ({\mathbf{t}}_i,{\mathbf{t}}_j))\cdot \text{mathbbm}{1}_{\{i\in C^t\}},$$

$${\mathcal{L}}_{dense}={\mathcal{D}}_{KL}(\text{softmax}(\mathbf{S}/T)\Vert \text{softmax}({\mathbf{S}}^{\ast }/T))\cdot T^2,$$

$${\mathcal{L}}_{lpd}={\mathcal{L}}_{stability}+\alpha {\mathcal{L}}_{plasticity}+\beta {\mathcal{L}}_{dense}.$$

$${\mathbf{M}}_{bkg}^{\prime }(h,w)=\underset{1\le i\le n}{\max }{\mathbf{M}}_{bkg}^i(h,w),$$

$${\mathbf{p}}_c={\mathbf{p}}_{bkg}^k,k=\underset{i}{\max }\cos ({\mathbf{t}}_{bkg}^i,{\mathbf{t}}_c^{\ast }),$$

$$\widehat{{\mathbf{S}}_{bkg}^i}=\neg \left(\left(\sum {\mathbf{S}}_{old}\right)\bigvee {\mathbf{S}}_{new}^i\right).$$

$${\mathcal{L}}_{bkg}=\frac{1}{n}\sum _{i=1}^n\frac{1}{N_{new}}$$

$$\displaystyle\left(1-\cos(\boldsymbol{S}_{bkg}^{i}\mathbf{V},\widehat{\boldsymbol{S}_{bkg}^{j}}\mathbf{V})\right)\Big{]}.$$

Full text

1 Introduction

Semantic segmentation [6, 43, 7, 62] is a crucial computer vision task that assigns meaningful labels to each pixel in an image. While conventional networks perform well on datasets with all class labels available upfront, real-world applications require models that can adapt and incrementally learn new classes after deployment. Class-Incremental Semantic Segmentation (CISS) [30, 57] is dedicated to solving this problem by enabling models to incorporate new classes through supervision while retaining the knowledge of previously learned classes.

A considerable amount of effort has been devoted to addressing the core issue of catastrophic forgetting in CISS from different perspectives. Data replay-based methods [29, 32, 27, 56] store or generate old instances or features to review prior knowledge. Dynamic architecture-based methods [1, 49, 26, 53, 50] benefit from flexible and scalable model frameworks. Recently, knowledge distillation-based strategies [31, 37, 36, 40] have gained more attention due to their efficiency and simplicity, yet stabilizing the representation of new knowledge while preventing forgetting remains challenging.

To investigate the essence of this crux, we abstract mainstream methods into two key processes: visual feature extraction (e.g., pixel-level, mask-level) and matching predefined class prototypes (e.g., linear layers, query prompts). As new classes are added, this pipeline inevitably faces what we term catastrophic semantic entanglement, which manifests in two aspects: (i) Prototype-Feature Entanglement (Orange box in Fig. 1(a)). The inaccessibility of old data limits prototype differentiation to sparse training data, unable to address distribution overlap between similar classes and relationships between prototypes. This leads to semantic misalignment during the incremental process, exemplified by prototype confusion and feature overlap (e.g., prototype $\mathbf{t}_{4}$ entangling with $\mathbf{v}_{3}^{\prime}$). Further training of the image encoder causes detrimental shifts in visual features. Since the model has not been fully learned, subsequent knowledge distillation exacerbates cumulative errors. (ii) Background-Increment Entanglement (Orange box in Fig. 1(b)). The expansion of foreground classes continuously alters background semantics, removing new classes and incorporating background information from new datasets, which misaligns the background prototype with other classes (e.g., prototype $\mathbf{t}_{4}$ entangling with the background $\mathbf{t}_{0}$).

The commonality of these two issues lies in the reliance on visual representations alone to decouple entangled features. Although the visual module can self-discover beneficial feature distributions during training, it still lacks the necessary supervisory cues, leading to substantial noise and errors. Based on these observations, we propose the language-inspired bootstrapped disentanglement framework, aiming to guide the model in learning to bootstrap the decoupling of entangled features through prior class semantics from pre-trained visual-language models.

Specifically, for Prototype-Feature Entanglement, we design language-guided prototypical disentanglement (Green box in Fig. 1(a)). We treat manually constructed prompts with explicit class names as templates containing generalized knowledge. By simultaneously minimizing the KL divergence between the patch-prototype and patch-template matching logits, as well as the KL divergence between the prototype-template distributions (represented by $\sigma$), we ensure topological stability at the macroscopic level. At the microscopic level, local plasticity is achieved through an orthogonal constraint (represented by $\Delta$) based on sorted scores.

For background entanglement, we design manifold mutual background disentanglement (Green box in Fig. 1(b)). The key to resolving background entanglement lies in eliminating the semantic information of the current class embedded in the background from the previous step. We use CLIP score maps and ground truth to disentangle background reference features (operation represented by $\psi$) and apply supervised contrastive learning (loss function denoted by $\mathcal{L}$) to disentangle new class features from the background. Since background classes are composites of multiple semantics, we employ multiple learnable prototypes to represent the background, selecting the maximum activation value during class mask computation. Building on existing background weight transfer methods, we replicate weights based on the similarity between background embeddings and new class templates.

These two aspects enhance the model’s continuous learning from different perspectives. However, the substantial modality gap in the original CLIP embedding space creates a large distance between image and text embeddings, limiting segmentation performance. Drawing inspiration from  [39], we create CoOp-style [66] text prompts for each class to derive corresponding text features. Additionally, we incorporate improvements from existing methods to further optimize CLIP’s performance in dense scenarios.

In summary, the contributions of this paper are as follows:

• •

We propose an efficient framework for integrating CLIP into the CISS task with language-inspired bootstrapped disentanglement, which outperforms existing state-of-the-art methods on the Pascal VOC and ADE20k datasets.

• •

To tackle the entanglement between class prototypes and visual features, we introduce language-guided prototypical disentanglement, which treats the vanilla text features as topological templates to guide the disentanglement of new prototypes.

• •

To tackle the entanglement between background semantics and incremental classes, we introduce manifold mutual background disentanglement, which achieves the mutual disentanglement of the background and new classes through multiple learnable prompts and mask-pooling-based contrastive supervision.

2 Related Work

**Class Incremental Learning. ** In class-incremental learning tasks, models are required to continually learn to recognize new classes from a sequential data stream while retaining previously learned knowledge. Data replay-based methods [2, 20, 60, 45, 68] achieve this by storing data from previous tasks or generating images of previously learned classes, allowing the model to revisit past data distributions. Network expansion-based methods [54, 47, 22, 48, 44, 65] dynamically adjust the model’s architecture or capacity during training to enhance its ability to learn new knowledge. Parameter regularization-based methods [51, 52, 21] focus on how the model parameters should dynamically adapt when the network structure remains fixed.

**Class Incremental Semantic Segmentation. ** ILT [30] first introduced the CISS task. Subsequent works [4, 25, 41] investigated CISS under weak supervision. MiB [3] addressed the core issue of background shift using a novel classifier initialization and a distillation loss. PLOP [11] employed multi-scale pooling distillation and pseudo-labeling to retain old knowledge. SDR [32] reduced forgetting by shaping the latent space to maintain feature consistency and sparsity. RCIL [59] utilized structural reparameterization to decouple representations of new and old knowledge. CoMFormer [5] introduced the continual panoramic segmentation task, proposing an adaptive distillation loss and a mask-based pseudo-label technique. Incrementer [42], building on ViT architectures, added new class tokens to the decoder for incremental learning. ECLIPSE [17] applied visual prompt tuning to Mask2Former [7], significantly reducing trainable parameters. MBS [33] mitigated background shift through a selective pseudo-labeling strategy and adaptive feature distillation. Unlike prior visual-only methods, our approach leverages CLIP’s multimodal information to address key challenges in continual segmentation.

**CLIP-based Semantic Segmentation. ** DenseCLIP [39] proposed context-aware prompting and converted CLIP’s original image-text matching problem into pixel-text matching for dense prediction. MaskCLIP [64] directly modified CLIP’s image encoder, producing reasonable segmentation results without fine-tuning. ZegCLIP [67] extended CLIP’s zero-shot prediction ability from image-level to pixel-level. WeCLIP [58] explored weakly-supervised semantic segmentation, freezing CLIP’s feature extractor and retaining only the trainable segmentation decoder. ClearCLIP [19] highlighted the negative impact of residual connections on segmentation performance and improved segmentation by modifying the last layer of the feature extractor. MTA-CLIP [9] emphasized the challenge of aligning global scene representations in CLIP text embeddings with local pixel-level features, introducing a framework for mask-level visual-language alignment. FMWISS [55] utilized the score maps from CLIP as additional signals to optimize noisy labels in weakly-supervised learning. kNN-CLIP [13] continuously embedded the visual embeddings of new classes into a database to enhance model performance in incremental open-vocabulary segmentation tasks. Although CLIP-based segmentation models are plentiful, few have been applied to CISS tasks. Even when used, CLIP is often treated merely as an additional source of supervisory signals. Our method further integrates CLIP’s generalized multimodal topological knowledge structure into the continual learning.

3 Method

3.1 Problem Definition

CISS aims to simulate real-world scenarios where a model continuously learns to recognize new classes as independent tasks arrive. Typically, the training process consists of multiple timesteps, denoted as $t=1,2,\dots,T$. For timestep $t$, the training set can be represented as $D^{t}=\{(x_{i}^{t}\in\mathbb{R}^{H\times W\times 3},y_{i}^{t}\in\mathbb{R}^{H\times W})\}_{i=1}^{N_{t}}$, where $N_{t}$ denotes the number of training images at timestep $t$, $x_{i}^{t}$ and $y_{i}^{t}$ correspond to the $i$-th image and its label map, respectively. It is important to emphasize that the classes in the label set $C^{t}$ (also referred to as novel classes) for timestep $t$ are disjoint from the classes in all previous timesteps $C^{1:t-1}$ (also known as old classes), i.e., $C^{1:t-1}\cap C^{t}=\varnothing$. If a class from $C^{t}$ appears in the training data of a future timestep $t^{\prime}$, the corresponding regions in $D^{t^{\prime}}$ are labeled as background $c_{0}$. After completing training at timestep $t$, the model is evaluated on test data that includes all previously seen classes, i.e., $C_{test}^{t}=C^{1}\cup\cdots\cup C^{t}$. This requires the model to learn new classes effectively under the supervision of only the new classes while retaining the knowledge of previously learned classes.

3.2 From Sparse to Dense: CLIP-based CISS

CLIP consists of an image encoder $\mathcal{E}_{v}$ and a text encoder $\mathcal{E}_{t}$. As shown in Fig. 2(a), the most basic pipeline to apply CLIP to segmentation tasks [39] involves passing an image and the corresponding class text (e.g.,“A photo of [CLS]”, where the background label can be an empty word) through their respective encoders. By removing the attention pooling layer at the end of the original image encoder [64], patch features for the image are obtained. The score map for each class is derived by computing the cosine similarity between the class embeddings and the visual embeddings.

However, the original design of CLIP is tailored for image-level classification, limiting its ability to capture local details in pixel-level dense predictions [23]. We follow the approach proposed by ClearCLIP [19], removing the residual connections and the FFN in the final layer of the ViT, which effectively reduces segmentation noise. Regarding the generation of class embeddings, instruction tuning [16, 46, 15] has been shown to be highly effective. Specifically, the input to the text encoder for the $i$-th class $\mathbf{t}_{i}^{pre}$ is

[TABLE]

where $\boldsymbol{p}_{i}\in\mathbb{R}^{N_{p}\times C}$ is a learnable context of length $N_{p}$, and $CLS_{i}\in\mathbb{R}^{N_{CLS}\times C}$ represents the tokenized embedding of the class name. The class embedding for each class is then obtained by passing $\mathbf{t}_{i}^{pre}$ through the text encoder $\mathbf{t}_{i}=\mathcal{E}_{t}(\mathbf{t}_{i}^{pre})$

Inspired by works like [42], to better facilitate the fusion of cross-modal features, we combine the class embeddings of $N+1$ classes (including the background) $\mathbf{t}=\{\mathbf{t}_{bkg},\mathbf{t}_{1},\dots,\mathbf{t}_{N}\},\mathbf{t}_{i}\in\mathbb{R}^{C}$ with the visual embeddings of $M=H^{\prime}\times W^{\prime}$ patches outputted by the visual encoder $\mathbf{v}=\{\mathbf{v}_{1},\dots,\mathbf{v}_{M}\},\mathbf{v}_{i}\in\mathbb{R}^{C}$. The concatenated sequence $\{\mathbf{t},\mathbf{v}\}$ is then passed through a transformer decoder $\mathcal{D}$ to generate the refined embeddings $\{\mathbf{t}^{\prime},\mathbf{v}^{\prime}\}=\mathcal{D}(\{\mathbf{t},\mathbf{v}\})$, which are used to compute the segmentation mask for the $i$-th class:

[TABLE]

By applying operations like reshaping and upsampling, we obtain the final mask $\boldsymbol{S}\in\mathbb{R}^{(N+1)\times H\times W}$. Benefiting from the scalability of the baseline architecture, when a new class is learned, the corresponding text input is added to obtain the new class embedding. To mitigate catastrophic forgetting, we adopt the mainstream approach of using additional supervision based on pseudo-labeling [11]. Specifically, we first generate masks $\boldsymbol{S}^{prev}$ for the current image using the model from the previous phase, and from these, compute the labels for old classes $\hat{Y}$. The new label set $Y^{\prime}$ is then formed by combining $\hat{Y}$ with the new class labels $Y$, which is used to compute the cross-entropy loss.

3.3 Language-Guided Protoypical Disentangle

Context learning and continuous training of the visual encoder in the CLIP-based model enhance plasticity but cause the Prototype-Feature Entanglement dilemma. More learnable parameters expand the feature space, treating each incremental stage as a separate segmentation task. The prompts focus on distinguishable features within the current dataset, neglecting semantic associations between stages, which entangle prototypes and visual features. A similar issue occurs in pixel-level image-text similarity, where the absence of old class data leads to visual feature mismatches, disrupting the topological structural knowledge from CLIP.

To address this, knowledge distillation methods are widely adopted to retain the previously learned knowledge. However, existing distillation methods [42, 33] use the model from earlier stages as a teacher to constrain the current training, mainly preserving the consistency of feature maps and class embeddings. This approach can only transfer the output of the old model to a limited extent, without effectively decoupling it. If the structural knowledge of CLIP is treated as a graph (Fig. 3), where class prototypes are nodes and inter-class similarity represents edges, then if the position of newly acquired nodes is poorly generalized, even if the current structure can be preserved later, the increase in class numbers will lead to misclassifications.

Therefore, the key lies in macroscopically preserving the topological structure, and microscopically maintaining local semantic plasticity. For the continuously updated $\mathbf{t}_{i}$, we use a static generalized embedding consisting of a series of manually constructed descriptions (See Appendix for details) containing explicit class names (excluding background) as templates $\mathbf{t}^{*}=\{\mathbf{t}^{*}_{1},\cdots,\mathbf{t}^{*}_{N}\}$ to be aligned. Based on this, we employ stability constraints [34] of class embeddings to maintain the knowledge structure learned by CLIP:

[TABLE]

where $l_{\delta}$ represents the Huber Loss, $\psi_{D}$ represents the Euclidean distance, and $\psi_{A}(\mathbf{t}_{i},\mathbf{t}_{j},\mathbf{t}_{k})$ denotes the $\cos\angle\mathbf{t}_{i}\mathbf{t}_{j}\mathbf{t}_{k}$.

While inter-class relationships are preserved, not all aspects are beneficial at the local level. The naming conventions of datasets hinder their effectiveness (e.g.,“stairs” and “stairway” in the ADE20k dataset). These classes, which may appear similar in text, actually have different visual meanings. If we enforce orthogonality among all $\mathbf{t}_{i}$, the macroscopic topology will still be disrupted. Therefore, we propose a orthogonality constraint based on ranking scores to ensure local-plasticity, which only calculates the most similar $k$ pairs of embeddings, corresponding to the shortest $k$ edges $E=\text{Top-k}(\{\cos(\mathbf{t}_{i},\mathbf{t}_{j})\})$ in the graph:

[TABLE]

where $\mathbbm{1}_{{i\in C^{t}}}$ indicates that the starting point of the edge must be a class from the current training step.

The two losses described above primarily target the language modality. To prevent the visual encoder from overfitting to the current training set, we similarly employ cross-modal dense learning based on temperature distillation, which constrains the similarity of logits between each visual patch and the class embeddings, ensuring alignment with the template embeddings:

[TABLE]

where $\boldsymbol{S},\boldsymbol{S}^{*}\in\mathbb{R}^{N\times M}$ represent the score maps obtained by multiplying the text and visual features, and $T$ is the temperature coefficient. The complete language-guided prototypical disentanglement loss is the weighted combination of these three losses:

[TABLE]

3.4 Manifold Mutual Background Disentangle

The background semantics gradually change over time, leading to Background-Increment Entanglement. Mainstream methods [42, 33] typically rely on a single prototype to model the background, which results in the difficulty of effectively capturing and adapting to new background when a shift occurs. In fact, the background can be viewed as a collection of multiple unseen classes. Therefore, we propose the dynamic manifold background representation.

We initialize multiple mutually orthogonal learnable prompts for the background, denoted as $\boldsymbol{p}_{bkg}=\{\boldsymbol{p}_{bkg}^{1},\cdots,\boldsymbol{p}_{bkg}^{n}\},\boldsymbol{p}_{bkg}^{i}\in\mathbb{R}^{N_{p}\times C}$, and obtain $n$ background embeddings $\{\mathbf{t}_{bkg}^{1},\cdots,\mathbf{t}_{bkg}^{n}\}$ via the encoder $\mathcal{E}_{t}$. These embeddings are then concatenated with the remaining embeddings $\{\mathbf{t}_{1},\cdots,\mathbf{t}_{N},\mathbf{v}_{1},\cdots,\mathbf{v}_{M}\}$ and fed into the decoder. Based on the algorithm described in Sec. 3.2, we obtain $n$ background masks: $\boldsymbol{M}_{bkg}^{i}\in\mathbb{R}^{H^{\prime}\times W^{\prime}},1\leqslant i\leqslant n$. We then derive the final background mask by taking the maximum logits at each pixel:

[TABLE]

where $h$ and $w$ represent the row and column coordinates of the pixel, and $\boldsymbol{M}_{bkg}^{i}(h,w)$ is the value of the $i$-th background mask at pixel $(h,w)$.

The dynamic manifold representation overcomes the limitations of a single prototype by introducing multiple prototypes. These prototypes represent the semantic features of different potential classes within the background, which may include newly added classes in the current step. When initializing the prompt for a new class $c$, we select the background embedding that is most similar to the new class’s template $\mathbf{t}_{c}^{*}$ from the $n$ background embeddings to transfer the background weights:

[TABLE]

which ensures that $\boldsymbol{p}_{c}$ contains the semantics of the new class while minimizing the background shift towards the new class (Fig. 2(c)). To further strengthen the separation between the background and the new classes, we introduce mutual background disentanglement (Fig. 2(b)). The core idea is to use contrastive learning to generate a reference background feature from mask pooling, then disentangle the new class from the background, thereby ensuring that the representation of the background and the new target class are as distinct as possible.

Specifically, let $N_{old}$ be the number of old classes learned at the current step, and $N_{new}$ be the number of newly added classes. For an input image, we first multiply the visual patch embeddings with the class embeddings of background and old class, followed by argmax operations to obtain the corresponding masks $\boldsymbol{S}_{bkg}=\{\boldsymbol{S}_{bkg}^{1},\cdots,\boldsymbol{S}_{bkg}^{n}\}$ and $\boldsymbol{S}_{old}=\{\boldsymbol{S}_{old}^{1},\cdots,\boldsymbol{S}_{old}^{N_{old}}\}$. By downsampling the ground-truth labels, we obtain the masks for the new classes, $\boldsymbol{S}_{new}=\{\boldsymbol{S}_{new}^{1},\cdots,\boldsymbol{S}_{new}^{N_{new}}\}$. The total mask for the old classes is obtained by summing all the masks in $\boldsymbol{S}_{old}$, and the reference background mask after removing the $i$-th new class $\widehat{\boldsymbol{S}_{bkg}^{i}}$ is obtained by taking the union of each $\boldsymbol{S}_{new}^{i}$ with the summed old class mask and performing a inversion operation:

[TABLE]

By multiplying any mask $\boldsymbol{S}^{i}\in\mathbb{R}^{H^{\prime}\times W^{\prime}}=\mathbb{R}^{M}$ with the patch embedding $\mathbf{V}=[\mathbf{v}_{1},\cdots,\mathbf{v}_{M}]\in\mathbb{R}^{M\times C}$, we obtain the corresponding visual features for the region. Our core goal is to make the visual features of the background region, calculated using $\mathbf{t}_{bkg}$, as dissimilar as possible to those of the new class, while making them as similar as possible to the features of the region from which the new class has been excluded. Thus, each $\boldsymbol{S}_{new}^{i}\mathbf{V}\in\mathbb{R}^{C}$ can be treated as a negative sample, and each $\widehat{\boldsymbol{S}_{bkg}^{i}}\mathbf{V}$ as another positive sample. All $\boldsymbol{S}_{bkg}^{i}\mathbf{V}$ can be treated as anchor points, from which we compute the contrastive loss:

[TABLE]

Through manifold representation and mutual disentanglement, the model can better handle background shift in complex environments.

4 Experiment

4.1 Experimental Details

**Datasets. ** In line with the setup in [42, 33], we evaluate our method using two widely recognized datasets: Pascal VOC [12] and ADE20k [63]. The Pascal VOC dataset comprises 10,582 annotated training images and 1,449 testing images, spanning over 20 object classes. ADE20k consists of 20,210 images for training and 2,000 images for testing, distributed across 150 distinct classes.

**Experimental Protocols. ** To evaluate the performance of our method, we utilize a two-fold experimental setup with distinct CISS configurations: Disjoint and Overlapped. In both configurations, labels are assigned solely to the new classes $C_{t}$ introduced at each step t. At the same time, the data $D_{t}$ includes samples from previously learned and current step classes. Precisely, in the Disjoint configuration, $D_{t}$ consists of data from the union of the old classes $C_{1:t-1}$ and the new classes $C_{t}$. In contrast, the Overlapped configuration incorporates not only the current and previous classes but also data from future class sets $C_{1:t-1}\cup C_{t}\cup C_{t+1:T}$, representing a more challenging and realistic scenario for continuous learning. The performance under a Joint scenario, where all classes are trained simultaneously, is also used as a best-case baseline.

To assess the incremental learning capacity, we follow a class partition strategy similar to prior works, which organizes classes based on the number of steps in the continual learning process. For example, the benchmark labeled as 15-1 (6 steps) refers to a scenario where the model is initially trained on 15 classes, then adding one new class at each subsequent step. To ensure comparative fairness, we replace the backbone with ViT-B/16-224 (instead of 384) in the code provided by MBS [33] and reproduce it.

For evaluation metrics, we follow previous work by providing the average MIoU for both the basic and incremental stages, as well as the average MIoU for all classes. We additionally provide the harmonic mean of the stage-basic and stage-new MIoU as a supplement to better reflect the trade-off between the learning performances of different stages.

**Implementation Details. ** Our method is built upon the transformer-based CLIP [38], which includes the openCLIP [8] pre-trained ViT-B/16 [10] visual encoder. For the decoder, we employ a simple module consisting of two transformer decode layers, consistent with the approach used in [42, 33]. The input image is resized to $512\times 512$. We use the AdamW [28] optimizer with an initial learning rate of 3e-6 and a batch size of 8 for both datasets. Each training step runs for 64 epochs. For incremental sessions, the learning rate is set to 0.5 times the base rate for ADE20k and 0.1 times for Pascal VOC. To balance learning across modules, the CLIP encoder’s learning rate is further reduced to 30% of the current rate. The learnable prompts’ length is set to $N_{p}=8$, with the number of background prompts $n=4$. Before the $t$-th step in incremental learning, we freeze all prompts $C_{1:t-1}$ and perform the background weight transfer. For Eq. 6, we set $\alpha=1$, $\beta=0.2$. See the Appendix for further details.

4.2 Comparisons with the State-of-the-Arts

**ADE20k. ** Experimental results for the overlapped setting on the ADE20k dataset are shown in Tab. 1. For short-step settings, our method exceeds the previous SOTA model by 1.2 (100-50) and 0.9 (50-50) on new classes, demonstrating the stronger baseline brought by the inclusion of additional textual information. In the two other long-step settings, our method shows an even greater margin. One major characteristic of the ADE20k dataset is its large number of classes, complex inter-class relationships, and significant background shift, making it prone to confusion during continual learning. Thanks to bootstrapped disentanglement on class embeddings, our method performs consistently across all settings, effectively controlling the phenomenon of forgetting.

Pascal VOC. Comprehensive experimental results on Pascal VOC are presented in Tab. 3. While improving accuracy for new classes, we exhibit less forgetting on old classes. Notably, in multi-step scenarios (15-1), where the data distribution and background semantics continually shift, our proposed method surpasses the previous SOTA by 1.4 (disjoint) and 1.7 (overlapped) on new classes. When compared with the joint results, we are closer to the theoretical upper bound. It further emphasizes the importance of retaining original CLIP topological knowledge and dynamically constraining the background to balance model stability and plasticity.

Is All the Credit Owed to CLIP? Since we use the CLIP backbone, which leverages more training data than the ImageNet-pretrained ViT used by other methods, we conducted supplementary experiments to eliminate the potential interference of this factor on the experimental results. We replaced the backbones of MBS [33] and INC [42] with CLIP, keeping the class embedding initialization consistent with ours (considering the background as a regular class). All other settings remained the same. From the results in Tab. 2, it is evident that the inclusion of CLIP does slightly improve the baseline performance (indicated by green values), but the forgetting phenomenon still exists and is even more severe than in the original method (indicated by orange values). The cause of this phenomenon lies in our retention of the CLIP visual encoder’s training. Without the use of additional regularization methods, its visual and language features misalign as learning progresses, reducing accuracy. Furthermore, if the issue is attempted to be circumvented by freezing the visual encoder, the model’s learning performance significantly deteriorates (second-to-last row).

4.3 Ablation Studies

**Component Analysis. ** To assess the effectiveness of each module, we conduct ablation experiments on the 15-1 overlapped setting of Pascal VOC. As shown in Tab. 4, the first analysis focuses on the baseline that relies solely on the knowledge distillation from the output of prev model without any learnable prompts. Although the zero-shot generalization ability of CLIP is impressive, it does not adapt well to pixel-level segmentation tasks. After adding prompt tuning, the model’s plasticity is significantly improved (with a 5.9-point increase on all). However, it still faces more severe forgetting than the single-modal ViT (2.1 points lower than MBS on 15-5), which is mainly due to the entanglement of CLIP’s original topological structure caused by the continuous training of the model, as discussed in Sec. 3.3. Therefore, when language-guided protoypical disentangle is further applied, the forgetting of old classes is mitigated (with a 2.6-point improvement on all). To better represent the background, we set up multiple learnable prototypes. We use text-supervised class templates to selectively initialize the prompts for new classes, further enhancing the model’s performance (with a 0.3-point increase on all). Building on this, to promote the separation of background and new classes, we designed mutual background disentanglement, which effectively improved the accuracy of new classes (by 0.5 points).

Analysis of Language-guided Protoypical Disentanglement. Fig. 4 shows the t-SNE visualization results of the class template features constructed on the ADE20k 100-50 dataset, along with the CLIP class embeddings during training on new classes. The blue and red points represent the old and new classes, respectively. Due to the initialization of the prompts for the new classes with background weights, a noticeable gap in data distribution exists at the beginning between the new and old classes. As training progresses, the distillation loss drives the embeddings to align with the templates gradually, ensuring their generalizability in the feature space.

Analysis of Manifold Mutual Background Disentanglement. Fig. 5 presents the visualization results of the confusion matrices for two datasets. On the left, the baseline exhibits an apparent phenomenon of new classes shifting towards the background (with the leftmost column becoming darker). After applying the series of background representation optimization methods proposed in Sec. 3.4, the result on the right shows significant improvement.

5 Conclusion

This paper abstracts the CISS method into visual feature extraction and prototype-feature matching, addressing the core issue of catastrophic semantic entanglement. We propose the language-inspired bootstrapped disentanglement framework, which guides the model to learn disentangled features using pre-trained CLIP’s prior class semantics. Language-guided prototypical disentanglement uses hand-crafted textual features as class templates to disentangle new prototypes, while manifold mutual background disentanglement leverages multiple learnable prompts and mask-pooling-based contrast to disentangle backgrounds and new classes. Our method outperforms the state-of-the-art on two datasets.

Acknowledgments

This work is partially supported by grants from the National Natural Science Foundation of China (No. 62132002 and No. 62202010), Beijing Nova Program (No.20250484786), and the Fundamental Research Funds for the Central Universities.

1 Model Details

1.1 Visual Encoder

Since the original version of CLIP [38, 8] was trained on classification tasks at the image level, it cannot be directly applied to segmentation tasks. To address this, we synthesized insights from existing methods and implemented the following improvements (all encoders are based on the transformer architecture):

1. Following MaskCLIP [64], we removed the average pooling in the last layer of the CLIP visual encoder ViT, which allows us to obtain dense features.

2. Following ClearCLIP [19], we directly removed the feedforward neural network and residual connections from the last layer of ViT. Additionally, we replaced the attention mechanism in the final layer with v-v attention.

3. Inspired by the concept of multi-scale feature extraction [14], we first extracted features from different layers of the CLIP visual encoder (specifically, the 4th, 6th, 8th, and 12th layers), concatenated them along the feature dimension, and then used convolution operations to restore the previous dimensions. This feature was then used as input to the decoder.

1.2 Text Encoder

To obtain class templates, we first extracted the corresponding language features from multiple text descriptions containing the class information and then computed the average of the multiple features for each class. The descriptions we used include:

• •

A photo of a {}.

• •

A snapshot of a {}.

• •

A bad photo of the {}.

• •

A clean origami {}.

• •

A photo of the large {}.

• •

A {} in a video game.

• •

Art of the {}.

• •

A photo of the small {}.

• •

A {} in the scene.

2 Analysis of Computational Cost

In the domain of Continual Learning (CL), model efficiency is as crucial as performance. To provide a clear perspective on the computational overhead of our proposed Language-inspired Bootstrapped Disentanglement (LBD) method, we conduct a comparative analysis against DenseCLIP [39], a strong baseline that adapts the CLIP model for dense prediction tasks. This analysis is crucial for contextualizing the performance gains documented in the main paper.

Our evaluation, summarized in Table 5, focuses on three key metrics: performance (mIoU on VOC 15-1 All), model size (Parameters), and computational load (GFLOPs). We assess DenseCLIP in both its zero-shot capacity and after being continually trained on the same CISS task protocol as our LBD. The results reveal that LBD achieves a mIoU of 78.1, substantially outperforming the continually-trained DenseCLIP (68.7). Regarding the computational budget, LBD exhibits only a marginal increase in complexity. The GFLOPs increase from 143.8 to 148.2, a modest rise of approximately 3%. This slight overhead is primarily attributed to the learnable prompts and the lightweight adapter module. The increase in parameters from 105.3M to 121.1M similarly reflects the inclusion of these task-specific components.

Crucially, it is important to note that our core architectural innovations, such as the Language-guided Prototypical Disentanglement (LPD) module, are designed to operate exclusively during the training phase. These components guide the model’s feature space to form a disentangled semantic structure but are detached for inference. Consequently, they introduce no additional computational burden at deployment time. Given the substantial performance improvements, especially in challenging multi-step CISS scenarios, we conclude that the minor increase in training computation is a well-justified trade-off.

3 Exploration of PEFT

The advent of large-scale pre-trained models has spurred the development of Parameter-Efficient Fine-Tuning (PEFT) methods, which aim to adapt these models to downstream tasks by updating only a small fraction of their parameters. To assess the feasibility of this paradigm for Class-Incremental Semantic Segmentation (CISS), we conducted an ablation study investigating different PEFT strategies within our LBD framework.

While our primary experiments configure the visual encoder (CLIP-ViT) as fully trainable to maximize adaptation, integrating PEFT is indeed a feasible alternative. Our study, presented in Table 6, explores the impact of selectively training different components: ➊ the learnable prompts introduced in Section 3.2, ➋ a convolution-based adapter module placed after the encoder, and ➌ the full image encoder itself.

The results yield a clear insight: while PEFT approaches show promise, they currently do not match the performance of full fine-tuning for the demanding task of CISS. Training only the prompts (➊) or the adapter (➋) results in mIoU scores of 64.8 and 66.9, respectively. Combining these two PEFT techniques (➊+➋) improves the score to 72.1. However, this is still considerably lower than the 78.1 mIoU achieved when the visual encoder is fully trained (➊+➋+➌).

This performance gap suggests that adapting the vision-language model to a dense, pixel-level prediction task like semantic segmentation requires more than just peripheral modifications. The supervised signal from pixel-level annotations appears crucial for fundamentally reshaping the features within the visual backbone, an adaptation that cannot be fully achieved when the encoder is frozen. We conclude that while PEFT offers a promising avenue for reducing the training cost of CISS, future work is needed to develop more sophisticated methods that can bridge this performance gap.

4 Limitations

Our method relies on explicit class names, and when only images and numeric labels are available in the dataset, we are unable to leverage textual information. Moreover, due to the limitations of CLIP’s pretraining data, CLIP fails to capture the semantic relationships between rare concepts and other classes, thus restricting the effectiveness of our method. Future work could focus on text supervision methods more suitable for incremental learning and cross-modal feature interaction.