Paper deep dive
Compensating Visual Insufficiency with Stratified Language Guidance for Long-Tail Class Incremental Learning
Xi Wang, Xu Yang, Donghao Sun, Cheng Deng
Intelligence
Status: succeeded | Model: google/gemini-3.1-flash-lite-preview | Prompt: intel-v1 | Confidence: 95%
Last extracted: 3/26/2026, 2:33:10 AM
Summary
The paper introduces a novel approach for Long-Tail Class Incremental Learning (LT-CIL) by leveraging Large Language Models (LLMs) to generate a 'Stratified Language Tree' (SL-Tree). This tree organizes semantic information hierarchically from coarse to fine-grained. The method employs two primary mechanisms: 'stratified adaptive language guidance' to dynamically adjust supervisory signals for tail classes using learnable weights, and 'stratified alignment language guidance' to maintain semantic-visual consistency, thereby mitigating catastrophic forgetting and data imbalance.
Entities (5)
Relation Signals (3)
Stratified Adaptive Language Guidance → mitigates → Data Imbalance
confidence 95% · enabling dynamic supervisory adjustment for tail classes and alleviating the impact of data imbalance.
Stratified Alignment Language Guidance → reduces → Catastrophic Forgetting
confidence 95% · exploits the structural stability of the language tree to constrain optimization... thereby alleviating catastrophic forgetting.
SL-Tree → guides → LT-CIL
confidence 90% · we introduce a stratified language tree... to guide model training in the visual space, thereby alleviating catastrophic forgetting
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Long-tail class incremental learning (LT CIL) remains highly challenging because the scarcity of samples in tail classes not only hampers their learning but also exacerbates catastrophic forgetting under continuously evolving and imbalanced data distributions. To tackle these issues, we exploit the informativeness and scalability of language knowledge. Specifically, we analyze the LT CIL data distribution to guide large language models (LLMs) in generating a stratified language tree that hierarchically organizes semantic information from coarse to fine grained granularity. Building upon this structure, we introduce stratified adaptive language guidance, which leverages learnable weights to merge multi-scale semantic representations, thereby enabling dynamic supervisory adjustment for tail classes and alleviating the impact of data imbalance. Furthermore, we introduce stratified alignment language guidance, which exploits the structural stability of the language tree to constrain optimization and reinforce semantic visual alignment, thereby alleviating catastrophic forgetting. Extensive experiments on multiple benchmarks demonstrate that our method achieves state of the art performance.
Tags
Links
- Source: https://arxiv.org/abs/2603.21708v1
- Canonical: https://arxiv.org/abs/2603.21708v1
Trouble viewing inline? Open PDF directly →
Full Text
62,493 characters extracted from source content.
Expand or collapse full text
Compensating Visual Insufficiency with Stratified Language Guidance for Long-Tail Class Incremental Learning Xi Wang, Xu Yang, Member, IEEE, Donghao Sun, Cheng Deng, Senior Member, IEEE Corresponding author: Cheng Deng. Xi Wang, Xu Yang, Donghao Sun, and Cheng Deng are with the School of Electronic Engineering, Xidian University, Xi’ an 710071, China (e-mail: wangxi6317, xuyang.xd, donghaosun508, chdeng.xd@gmail.com). Abstract Long-tail class incremental learning (LT-CIL) remains highly challenging because the scarcity of samples in tail classes not only hampers their learning but also exacerbates catastrophic forgetting under continuously evolving and imbalanced data distributions. To tackle these issues, we exploit the informativeness and scalability of language knowledge. Specifically, we analyze the LT-CIL data distribution to guide large language models (LLMs) in generating a stratified language tree that hierarchically organizes semantic information from coarse- to fine-grained granularity. Building upon this structure, we introduce stratified adaptive language guidance, which leverages learnable weights to merge multi-scale semantic representations, thereby enabling dynamic supervisory adjustment for tail classes and alleviating the impact of data imbalance. Furthermore, we introduce stratified alignment language guidance, which exploits the structural stability of the language tree to constrain optimization and reinforce semantic–visual alignment, thereby alleviating catastrophic forgetting. Extensive experiments on multiple benchmarks demonstrate that our method achieves state-of-the-art performance. I Introduction Real world data is inherently dynamic and imbalanced, leading to increased interest in long-tail class incremental learning (LT-CIL) [37]. In LT-CIL, training tends to be dominated by head classes with many samples, leading to poor performance for tail classes with insufficient visual information. This disparity intensifies along dynamically evolving data streams, ultimately exerting a substantial negative impact on overall model performance. Figure 1: Experiments were conducted on CIFAR100, imbalance rate ρ=0.01ρ=0.01 and 10 tasks. We evaluated accuracy across head classes, tail classes, and the complete dataset to assess the influence of semantic information on LT-CIL. Most existing LT-CIL methods are adapted from class incremental learning (CIL) methods [45], including data re-balancing strategies [24, 14], or parameter-efficient fine-tuning (PEFT) of pre-trained models (PTMs) [9, 28]. Recently, language-guided methods has received much attention in CIL [34, 15, 27, 47], which typically utilizes fixed templates, such as ’a photo of [class]’, to compute semantic–visual relevance between text and image embeddings. We therefore explore the potential of language knowledge in addressing LT-CIL. We conducted a preliminary validation on CIFAR100 under severe imbalance. Using the same backbone, we compared L2P [40], DualPrompt [39], and DAP [9] (visual-only), as well as RAPF [12], (visual + semantic). L2P, DualPrompt, and RAPF are designed for CIL, whereas DAP specifically targets LT-CIL, we also included a zero-shot experiment using CLIP (Continual-CLIP) [34] and a clustering experiment employing only the visual encoder (Clustering). We measured accuracy for head classes, tail classes, and all classes. The experimental results in Fig.1 show that 1) overall performance after fine-tuning may be even lower than that of the PTMs itself, owing to the degradation performance deficiency in tail classes; and 2) among existing CIL methods, those incorporating semantic information are less susceptible to imbalanced, continuous data; These findings suggest that semantic information provides a promising direction for mitigating the challenges of LT-CIL. However, fixed templates are limited and hinder the full exploitation of semantic cues. Therefore, this paper aims to explore how semantic information can be effectively leveraged to overcome the key limitations of LT-CIL. In this work, we first analyze the distributional characteristics of LT-CIL and design a recursive algorithm with four customized prompt templates to guide large language models (LLMs) in generating task-specific text descriptions. Following a hierarchical order from coarse to fine granularity, these texts are organized into a task-specific stratified language tree (SL-Tree). Based on the tree, stratified adaptive language guidance leverages learnable weights to integrate multi-scale semantic information, thereby enabling dynamic adjustment of the supervisory signal for tail classes with limited visual information and mitigating the impact of data imbalance. In addition, by exploiting the structural stability of the SL-Tree during training, stratified alignment language guidance constrains model optimization through the relative similarity distributions between the semantic and visual modalities, thereby further alleviating catastrophic forgetting. With two parallel stratified language guidances, we significantly enhance the PTM performance on LT-CIL. Our main contributions can be summarized as follows: • We introduce a stratified language tree, generated by LLMs, to organize multi-scale semantic information and provide structured supervision. • We propose leveraging the rich semantic information and stability of the stratified language tree to guide model training in the visual space, thereby alleviating catastrophic forgetting exacerbated by imbalanced data. • We perform extensive experiments to demonstrate the effectiveness of our method, all achieving state-of-the-art results. I Related Works Figure 2: The overall framework of our method. A is the stratified language tree generation, B is the stratified adaptive language guidance, and C is the stratified alignment language guidance. I-A Class Incremental Learning with Pre-trained Models Class incremental learning (CIL) aims to continually acquire new knowledge from a non-stationary data stream continuously [2, 19, 31, 44, 26, 21, 49, 48, 7, 23, 17, 5, 38]. The primary challenge is learning without catastrophic forgetting: as new data arrives, the model’s performance on previously learned tasks should not significantly degrade [22, 43, 10, 41, 29]. Recent advances in CIL that leverage pre-trained models have provided promising avenues for balancing generalization and adaptability [18], thus mitigating catastrophic forgetting. Prompt-based methods [40, 39, 33] have demonstrated the effectiveness of adapting pre-trained models into continuous data streams. A two-stage method [42], utilizing feature augmentation and classifier fusion, has shown improvements for CIL. Some methods [15, 4, 12] incorporate knowledge from the language modality to assist model learning, and these methods have been successful. Collectively, these strategies underscore the potential of integrating pre-trained models within CIL, enhancing model performance. I-B Long-tail Class Incremental Learning Long-tail class incremental learning (LT-CIL) addresses the challenge of data imbalance [46, 20] and catastrophic forgetting in a continuously evolving data stream. Methods such as LUCIR [24] and GVAlign [14] focus on balancing class distributions through regularization and distance constraints to enhance tail class learning. ISPC [37] introduces the independent sub-prototype space and reminiscence space to tackle data imbalance and catastrophic forgetting simultaneously. Recently, several methods have been proposed based on parameter-efficient fine-tuning (PEFT) using pre-trained models [9, 28]. However, most existing methods still struggle to fully exploit the semantic structure of the data, particularly for underrepresented tail classes, leaving room for improvement in knowledge transfer and generalization. I Method Our objective is to enable the network to sequentially learn multiple tasks from imbalanced data streams. In this section, we present the problem definition of LT-CIL, followed by a detailed description of the proposed method. I-A Preliminary I-A1 Problem definition Typically, we consider a supervised LT-CIL setting, where a model needs to consecutively learn T different tasks. Each task t contains different classes CtC^t and there is no overlap between any two different tasks: Ci∩Cj=∅C^i∩C^j= , for i≠ji≠ j, and (x,y)∈t(x,y) ^t denotes a training sample in task t. We characterize the degree of data imbalance by the imbalance rate ρ, defined as the ratio between the largest and smallest sample sizes. After processing the dataset according to ρ, we partition it into different sub-tasks, with head and tail classes randomly assigned to each task, thus creating an imbalanced and continuous data flow. I-A2 Pre-trained model We adopt CLIP [30] as the pre-trained model for our method due to its capability to jointly process visual and textual modalities. An efficient method for adapting a pre-trained model to downstream tasks involves integrating a lightweight network as an adapter. We denote the visual encoder as EvE_v, the text encoder as EtE_t, and the linear adapter as f. Given input (x,y)(x,y), y denotes the text form of the label in all subsequent descriptions (e.g., cat). The working process of the model can be represented as: pred=argmaxi(f(Ev(x))⋅Et(yi)). pred=arg _i (f (E_v(x) )· E_t(y_i) ). (1) We argue that the fine-tuning strategy of the adapter is inherently influenced by continuous, imbalanced data. As discussed before, tail classes suffer from insufficient visual samples, which makes it difficult for the model to learn robust representations. To address this, we expect semantic information to provide a stronger supervisory signal for tail classes. Accordingly, we first generate task-specific text descriptions. I-B Stratified Language Tree Specifically, we design four distinct prompt templates and a recursive algorithm to guide and constrain the LLM in generating the SL-Tree G containing rich, structured text information. For each task t arriving in chronological order, we collect labels y of all classes within the task and generate initial text description according to a Fixed Template, ‘a photo of [yiy_i]’, which forms the base layer of the SL-Tree, G1G^1. Building upon this, to simulate the coarse categorization of objects, we design Prompt Template 1, ‘Please summarize the task in one sentence from the point of view of category which includes both [y1y_1 + y2y_2 + …]’, where [ y1y_1 + y2y_2 + …] is the concatenation of all class labels within the task. With prompt 1, the LLM generates a task-level text description, primarily capturing common attributes shared by all classes within the task. This coarse-grained description constitutes the first level of the SL-Tree, G0G^0. Figure 3: Illustration of Prompt Template 2 and SL-Tree. Furthermore, fine-grained text descriptions that provide more granular details are required. To achieve this, we designed Prompt Template 2, ‘Please tell me the most distinctive visual feature of [yiy_i]’, where [yiy_i] is sequentially replaced with the class labels. Guided by prompt 2, the LLM generates detailed descriptions for each class, highlighting distinctive features, such as color, pattern, or shape. These form the second level of the SL-Tree 2nd2^nd, G2G^2. However, this text generation process remains generic and does not reflect the imbalanced data distribution, resulting in uniform descriptions across all classes without sufficient differentiation for tail classes. Input: Dataset (x,y)(x,y), LLM, 4 prompt templates, fix template. Output: SL-Tree G G0←G^0← LLM(y + Prompt 1); G1←G^1← LLM(y + Fixed Template); G2←G^2← LLM(y + Prompt 2); ←A← Eq2-Eq4 on G0:2G^0:2; for each jA_j do index = 0; while len|j|>2len|A_j|>2 and index <8<8 do Gindex+3←G^index+3← LLM(yjy_j + G0G^0 + Prompt 3); index += 1; j←A_j← Eq2-Eq4 on G0:indexG^0:index; end while if len|j|==2len|A_j|==2 then Gindex←G^index← LLM(yjy_j + Prompt 4); end if end for return G Algorithm 1 SL-Tree Generation. To address this, we use text encoder EtE_t to process the current SL-Tree. It should be noted that if the generated text exceeds a certain length, CLIP cannot process it. Therefore, we constrain the form of the generated texts. The responses are expressed as multiple phrases, and several short phrases are retained within the same layer. The prompt format and the generated SL-Tree structure are illustrated in Fig.3. The obtained text representations gig_i corresponding to each class can be represented as: gi=1L∑l=1L1Nil∑j=1NilEt(Gil[j]),g_i= 1L _l=1^L 1N_i^l _j=1^N_i^lE_t(G_i^l[j]), (2) where l denotes the total number of layers of the SL-Tree and NilN_i^l denotes the number of text descriptions in the corresponding layer. Next, we calculate the similarity between each tail classes and all other classes in the same task to construct the similarity matrix QjQ_j for a tail classes j: Qj=cos(gj,gk)=[qjk]j∈|Cmin|,k∈|Ct|,Q_j=cos(g_j,g_k)=[q_jk]_j∈ |C^min |,k∈ |C^t |, (3) and identify all classes similar to tail class j, defining them as a confusion cluster jA_j, j=(j,k)|1−qjk<0.5.A_j= \ (j,k )|1-q_jk<0.5 \. (4) If more than two classes are found to be similar to the central tail class j in the cluster jA_j, i.e, len(j)≥3len(A_j)≥ 3, we introduce Prompt Template 3, ‘Please tell me the most distinctive visual features of [yiy_i] from the datasets which include [task description]’. Here, [yiy_i] is iteratively replaced with the labels of all classes in confusion cluster, while [task description] is substituted with G0G^0. Using prompt 3, LLM generates text descriptions emphasizing distinctive inter-class differences at the task level. Then we recalculated equation (2)-(4) for classes in the confusion cluster jA_j, until only one similar class remains, i.e, len(j)=2len(A_j)=2. At this stage, we introduce Prompt Template 4, ‘Please tell me the most distinctive visual features of [yiy_i] compared to [yjy_j]’. Prompt 4 guides the LLM to perform one-to-one comparisons between tail class and the most similar class, generating highly discriminative comparative descriptions. The text generated with Prompt 4 constitutes the final layer, GLG^L, while those generated by Prompt 3 are inserted into the intermediate layers. However, real-world comparisons can be more complex than anticipated, and the number of classes in the confusion cluster may remain greater than 2 even after multiple iterations. Therefore, we set a maximum iteration limit of nine to prevent infinite looping. The overall generation process of the SL-Tree is detailed in Algorithm 1. Throughout this recursive process, we obtain an SL-Tree specific to each sub-task, which follows the expected progression from coarse- to fine-grained text representation, and we merge the newly generated SL-Tree and existing one. Then, we utilized its rich knowledge and stability to guide visual space learning and mitigate the challenges of LT-CIL. I-C Stratified Adaptive Language Guidance In the SL-Tree, tail classes are assigned more text descriptions to compensate for their limited visual samples. During training, we aim to fully exploit these texts to provide more refined supervisory signals for tail classes while avoiding interference with the learning of other classes. Motivated by this, we propose stratified adaptive language guidance. Specifically, we process the SL-Tree using text encoder EtE_t, and the corresponding text features of each layer l can be represented as follows: gl=[g1l,g2l,…,gil,…]i∈|C1:t|,l∈L, g^l= [g^l_1,g^l_2,…,g^l_i,… ]_i∈ |C^1:t |,l∈ L, (5) gil=1Nil∑j=1NilEt(Gil[j])iflen(Gil)>0.0else g^l_i= \ matrix& 1N_i^l _j=1^N_i^lE_t(G_i^l[j])&if (G_i^l)>0.\\ &0&else matrix . Equation (5) indicates that for the ithi^th class in the lthl^th layer, if text descriptions are available, the mean of their text features are calculated. otherwise, the value is set to 0, implying that the class is not included in that round of comparison. For any input x, the visual features are sequentially passed through the SL-Tree. The final prediction, aggregated across all layers, is formulated as p(x)=∑l=0Lal(f(Ev(x))⋅gl),p(x)= _l=0^La_l (f(E_v(x))· g^l ), (6) where αl _l denotes the importance weight of each layer. Different layers in the SL-Tree contribute unequally to the final prediction; thus, the weights αl _l should be adaptively adjusted. We treat them as learnable parameters and embed them into the optimization objective ℒ(θ,α)L(θ,α), where ℒL is the cross entropy loss, i.e., ℒ=ℒce(p(x),y)L=L_ce(p(x),y). During training, updates of α and θ are performed alternately. The network parameters θ are optimized via standard stochastic gradient descent. However, α acts as a set of weights to integrate multi-scale semantic information, which requires a more delicate optimization objective. To prevent weight collapse into a single layer, we introduce the negative entropy of the weights as a regularization constraint, Rcon(α)=∑l=0Lαllog(αl+ε),R_con(α)= _l=0^L _l\, ( _l+ ), (7) where ε=1×10−8 =1× 10^-8 prevents numerical instability. RconR_con serves as a smoothness prior on the layer-wise importance weights. By maximizing the entropy of α, the model avoids degenerating into a single-layer reliance, encouraging distributed semantic aggregation. Moreover, the update of α is also affected by the imbalanced distribution. Accordingly, each class is associated with its own set of weights, α=α0,c,α1,c,⋯αL,cc=0C1:Tα= \ _0,c, _1,c,·s _L,c \_c=0^C^1:T, and all sets of weights updated simultaneously. For tail classes that are more difficult to distinguish, theoretically more comparisons and queries will be performed, and more fine-grained text descriptions will be assigned in SL-Tree. When integrating predictions across layers, we expect tail classes to rely more on high-level semantic decisions. Therefore, we propose a frequency prior constraint for tail classes to enhance their discriminability. We first define the prior distribution, πl,c=exp(κc⋅ϕl),κc=(n¯nc), _l,c= ( _c· _l ), _c= ( nn_c ), (8) where n¯ n, ncn_c denote the average number of all samples and the number of samples for class c in the current task and ϕl=(l−1)/(L−1) _l=(l-1)/(L-1). To enforce high-level priority, we apply KL divergence as a regularization term: Rfreq(α)=∑kKL(α:,k||π:,k).R_freq(α)= _kKL ( _:,k\; | |\; _:,k ). (9) RfreqR_freq introduces a data-dependent prior that rebalances the influence of coarse- and fine-grained layers according to class frequency. Intuitively, it forces tail classes to rely more on higher-level semantic abstractions, mitigating the insufficient visual cues. In summary, the complete optimization objective for both parameters during training are minα[ℒce(θ,α)+Rcon(α)+Rfreq(α)]minθℒce(θ,α) \ aligned & _α [L_ce(θ,α)+R_con(α)+R_freq(α) ]\\[2.0pt] & _θL_ce(θ,α) aligned . (10) It should be noted that α represents the weights of different layers, which must be satisfied ∑lαl,c=1 _l _l,c=1 and their values lie on the probability simplex [36]. Therefore, the update of α must be constrained to the (L−1)(L-1)-dimensional simplex: αl,c(m+1)=ΠΔ(αl,c(m)−ηα∇αℒ(θ,αl,c(m))), α^(m+1)_l,c= _ (α^(m)_l,c- _α\, _αL(θ,α^(m)_l,c) )\,, (11) ΠΔ=αl,c≥0,∑lαl,c=1. _ = \ _l,c\!≥\!0, _l _l,c\!=\!1 \. Where m denotes training steps, and ηα _α is learning rate. ΠΔ _ denotes to the closed-form simplex projection [6]. Specifically, vi=αi,c(m)−ηα∇αℒ(θ,αi,c(m))v_i=α^(m)_i,c- _α\, _αL(θ,α^(m)_i,c). After sorting the elements of vector v in descending order, v(0)≥v(1)≥⋯≥v(L)v(0)≥ v_(1)≥…≥ v_(L), we determine the cutoff point: i⋆=maxi∈0,…,L:v(i)−1i(∑j=0iv(j)−1)>0.i = *max \i∈\0,…,L\:v_(i)- 1i ( _j=0^iv_(j)-1 )>0 \. (12) Then, the threshold τ can be calculated as τ=1i⋆(∑i=0i⋆v(i)−1),τ= 1i ( _i=0^i v_(i)-1 ), (13) and the final closed-form solution is ΠΔ(vi)=max(vi−τ,0). _ (v_i)= *max(v_i-τ,0). (14) Through the proposed stratified adaptive language guidance, tail classes receive stronger semantic supervision. However, during training, the model is still affected by catastrophic forgetting. Since the SL-Tree and the text encoder EtE_t remain frozen and do not undergo parameter updates. Therefore, we assume that, in the absence of catastrophic forgetting, the relative distance between the semantic space and the visual space should remain stable. Building on this observation, we further propose stratified alignment language guidance. I-D Stratified Alignment Language Guidance After each task, we store the prototype μc _c, μc=1nc∑i=1ncEv(xi) _c= 1n_c _i=1^n_cE_v(x_i) and covariance matrix Σc _c of each class c, Σc=1nc−1(Xc−Xc¯)(Xc−Xc¯)T, _c= 1n_c-1(X_c- X_c)(X_c- X_c)^T, (15) where ncn_c denotes the number of class c within the batch, XcX_c is the the matrix consisting of all features and Xc¯ X_c represents the mean of each feature dimension of classes c. Specifically, for any task t,t>0t,t>0, we first compute the frequency of occurrence for all classes within the mini-batch ℬB, and identify the highest frequency r. The value r is then used as the sampling number to sample the features of each old class k from the normal distribution (μk,Σk)N( _k, _k). The sampled feature batch ℬsamB_sam is subsequently mixed with the original one to form a new approximate balanced batch ℬbal=cat(ℬ,ℬsam)B_bal=cat(B,B_sam), where catcat denotes concatenation. We then compute pairwise similarities between the sample points within the batch to obtain a visual batch similarity matrix, v=Ψ(f(ℬbal))⋅(Ψ(f(ℬbal)))T,S_v= (f(B_bal))·( (f(B_bal)))^T, (16) where Ψ denotes normalization. The resulting matrix vS_v is treated as the visual-space distribution. Then, we compute the text features for class c in ℬbalB_bal, gc=∑l=0Lαl,c⋅gclg_c= _l=0^L _l,c· g_c^l. Similar to the visual space above, we can compute the similarity in the semantic space to obtain the semantic batch similarity matrix tS_t. Because the SL-Tree and text encoder remain frozen during training, we infer that the semantic space exhibits strong stability. Thus, we can use the distribution within the semantic space to constrain the optimize. Therefore, we compute the similarity between the distributions of the visual and the semantic space as follows, ℒalg=12|ℬbal|∑|ℬbal|(vlog(vt)+tlog(tv)).L_alg= 12|B_bal| _|B_bal| (S_v ( S_vS_t )+S_t ( S_tS_v ) ). (17) To further maximize the performance of our method, we compute the distillation loss between the old and new models, ℒkd=‖fold(Ev(x))−fnew(Ev(x))‖2L_kd= \|f_old(E_v(x))-f_new(E_v(x)) \|_2. Thus, the overall training objective in equation (10) becomes minα[ℒce(θ,α)+λ1ℒalg(θ,α)+λ2ℒkd(θ,α)+λ3Rcon(α)+λ4Rfreq(α:,t)]minθ[ℒce(θ,α)+λ1ℒalg(θ,α)+λ2ℒkd(θ,α)] \ aligned _α\ & [L_ce(θ,α)+ _1L_alg(θ,α)+ _2L_kd(θ,α)\\[3.0pt] & + _3R_con(α)+ _4R_freq( _:,t) ]\\[4.0pt] _θ\ & [L_ce(θ,α)+ _1L_alg(θ,α)+ _2L_kd(θ,α) ] aligned . (18) In the inference phase, for any input x, we calculate the prediction results pα:,c(x)p_ _:,c(x) under different parameters. We then define the difference between the maximum and the second maximum of the predicted results as the decision margin mα(x)m_α(x), mα:,c(x)=argmaxipα:,c(x)[i]−argmaxi′≠ipα:,c(x)[i′].m_ _:,c(x)=arg _ip_ _:,c(x)[i]-arg _i ≠ ip_ _:,c(x)[i ]. (19) Finally, we select the prediction with the larger decision margin as the final prediction. I-E Parameters Independence Analysis Equation (18) integrates complementary constraints: ℒceL_ce enforces discriminability, ℒkdL_kd ensures knowledge retention, ℒalgL_alg maintains inter-modal consistency, and the two regularizers RconR_con and RfreqR_freq stabilize the adaptive weight distribution. In our experiments, the updates of θ and α are performed alternately. During the derivation of θ, α is treated as a constant, and vice versa. Therefore, the optimization of the two parameter sets does not interfere with each other. Moreover, since α consists of differnet sets of parameters, we also explain the independence between different components of α. As a first step, we reorganize equation (18) with respect to each class. ℒ(θ,α) (θ,α) =∑k=0C1:Tk(θ,α:,k), = _k=0^C^1:TJ_k(θ, _:,k), (20) k(θ,α:,k) _k(θ, _:,k) =∑(x,y)∈k(ℒce+λ1ℒalg+λ2ℒkd)(θ,α:,k) = _(x,y) _k (L_ce+ _1L_alg+ _2L_kd )(θ, _:,k) +λ3Rent(α:,k)+λ4Rfreq(α:,k). + _3\,R_ent( _:,k)+ _4\,R_freq( _:,k). We then obtain the derivatives for different subsets of α, ∇α:,kℒ=∇α:,k,∂2ℒ∂α:,k∂α:,k′=0,k≠k′. cases _ _:,kL= _ _:,kJ_k,\\[3.0pt] ∂^2L∂ _:,k\,∂ _:,k =0, k≠ k . cases (21) This result indicates that the first-order derivative of the optimization objective with respect to each α depends only on its own parameters, while all cross-partial derivatives vanish. Thus, the different sets of adaptive weights are completely independent and can be optimized separately without mutual influence. IV Experiments TABLE I: Comparison experiments on ImageNet-R, bolded indicates optimal, underlined indicates sub-optimal. Method ρ=0.1ρ=0.1 ρ=0.01ρ=0.01 10 tasks 20 tasks 10 tasks 20 tasks Alast(↑)A_last\,( ) Favg(↓)F_avg\,( ) Alast(↑)A_last\,( ) Favg(↓)F_avg\,( ) Alast(↑)A_last\,( ) Favg(↓)F_avg\,( ) Alast(↑)A_last\,( ) Favg(↓)F_avg\,( ) LFM+MMS [8] 24.7 26.7 22.7 29.1 16.8 27.1 15.7 28.9 PODNET + LWS [24] 49.7 6.3 49.5 6.0 48.3 6.5 47.6 6.1 PODNET + GVAlign [14] 53.6 6.1 52.9 5.8 51.3 6.2 50.8 5.9 ISPC [37] 57.0 5.6 55.9 5.9 52.1 5.5 51.8 5.3 PriViLege [27] 62.7 3.6 57.8 3.1 50.4 3.3 45.9 3.0 L2P [40] 67.6 4.8 60.1 3.3 50.9 5.4 47.6 5.9 DualPrompt [39] 68.9 3.1 61.2 3.1 51.1 5.0 47.2 5.6 CODAPrompt [33] 71.1 3.0 66.5 2.6 56.8 4.5 52.2 4.6 GMM [4] 71.2 2.1 65.7 2.1 62.3 2.3 60.7 2.2 RAPF [12] 72.0 1.9 65.8 2.0 63.5 2.1 61.3 2.4 MG-CLIP [13] 72.2 1.7 68.2 1.6 64.9 2.0 62.9 2.5 DAP [9] 71.4 1.9 70.0 2.0 64.8 2.1 61.9 2.4 APART [28] 71.8 1.5 70.3 1.7 65.2 1.9 63.0 2.5 !20 Ours 76.1 1.6 73.7 1.2 72.1 1.9 70.0 1.8 TABLE I: Comparison experiments on CIFAR100, bolded indicates optimal, underlined indicates sub-optimal. Method ρ=0.1ρ=0.1 ρ=0.01ρ=0.01 5 tasks 10 tasks 5 tasks 10 tasks Alast(↑)A_last\,( ) Favg(↓)F_avg\,( ) Alast(↑)A_last\,( ) Favg(↓)F_avg\,( ) Alast(↑)A_last\,( ) Favg(↓)F_avg\,( ) Alast(↑)A_last\,( ) Favg(↓)F_avg\,( ) LFM+MMS [8] 39.7 22.6 27.4 25.7 30.6 25.1 19.8 21.0 PODNET + LWS [24] 51.9 5.1 51.0 4.3 35.9 6.1 35.2 6.0 PODNET + GVAlign [14] 53.0 4.7 51.9 4.0 39.2 5.7 38.6 5.8 ISPC [37] 53.4 4.1 52.4 3.8 39.7 5.9 39.0 5.6 PriViLege [27] 66.6 2.3 60.4 2.1 48.3 2.3 39.1 2.5 L2P [40] 67.5 2.0 61.3 2.5 48.9 2.2 40.3 2.7 DualPrompt [39] 68.2 1.8 61.3 2.0 49.5 2.4 39.9 2.3 CODAPrompt [33] 74.4 1.6 69.2 1.9 61.7 1.8 51.9 2.4 GMM [4] 74.5 2.1 70.2 2.1 60.4 1.7 53.4 1.6 RAPF [12] 75.4 1.9 70.9 1.9 62.5 2.0 53.8 1.6 MG-CLIP [13] 75.6 1.7 71.3 1.8 62.9 1.9 54.5 1.6 DAP [9] 74.0 2.1 70.8 2.1 63.0 1.8 60.2 1.5 APART [28] 74.3 1.5 71.0 1.4 63.3 1.7 60.9 1.4 !20 Ours 77.3 1.3 72.0 1.2 64.3 1.8 64.0 1.5 IV-A Experiments Setttings Datasets. We conduct our experiments using different benchmarks: CIFAR100 [16], ImageNet-R [11] and CUB200 [35]. We divided the ImageNet-R and CUB200 into 1010 or 2020 consecutive tasks of equal size, and CIFAR100 into 55 or 1010 tasks. For CIFAR100, we applied imbalance rates ρ=0.1ρ=0.1 and ρ=0.01ρ=0.01 to simulate distribution imbalances. ImageNet-R is inherently imbalanced, with an approximate imbalance rate of 0.10.1; we additionally construct a version with ρ=0.01ρ=0.01 for comparison. For CIFAR100 and ImageNet-R, we consider classes with fewer than 100 samples as tail classes, and the remaining ones as head classes. For CUB200, due to its smaller per-class sample size, we only consider ρ=0.1ρ=0.1, and treat classes with fewer than 10 samples as tail classes. Metrics. We use the standard metrics in continual learning to measure performance: Last Accuracy: AlastA_last, which calculates all seen classes’ accuracy after training for all tasks and Forgetting Rate: FavgF_avg, which calculates the average forgetting of prior task knowledge. Comparison methods. We compare our method with state-of-the-art algorithms for LT-CIL, including LWS[24], GVAlign [14], ISPC [37], DAP [9] and APART [28]. And we also select pre-trained model-based methods for CIL, L2P [40], DualPrompt [39], CODAPrompt [33], GMM [4], RAPF [12] and MG-CLIP [13]. Additionally, we select few-shot CIL method PriViLege [27] and long-tail learning method LFM [8]. It is worth noting that, RAPF, GMM, PriViLege, LFM, and MG-CLIP also incorporate semantic information based on a pre-trained model. Implementation details. For both datasets, our pre-trained model is ViT-B/16 of CLIP from OpenAI, and we train the model with the Adam optimizer for 30 epochs, while α updated once every 5 epochs. Both sets of parameters use a learning rate of 1×10−31× 10^-3. And the LLM we used is gpt-3.5-turbo. All experiments are obtained by re-running on Python 3.8, PyTorch 2.0.1, and a single NVIDIA A6000 GPU. All comparison methods that require the pre-trained model use ViT-B/16 of CLIP from OpenAI, and others use ViT-B/16 without pre-training. In our experiments, λ1=0.025 _1=0.025, λ2=1 _2=1, λ3=0.3 _3=0.3 and λ4=0.6 _4=0.6. TABLE I: Comparison experiments on CUB200, bolded indicates optimal, underlined indicates sub-optimal. Method 10 tasks 20 tasks Alast(↑)A_last\,( ) Favg(↓)F_avg\,( ) Alast(↑)A_last\,( ) Favg(↓)F_avg\,( ) ISPC [37] 30.2 6.7 26.1 6.1 PriViLege [27] 30.7 5.9 20.1 2.7 L2P++ [40] 32.1 3.8 20.7 3.4 DualPrompt [39] 32.0 3.1 20.3 3.0 CODAPrompt [33] 34.4 3.5 21.3 3.1 RAPF [12] 40.9 2.8 38.1 2.6 MG-CLIP [13] 41.2 2.7 40.5 2.6 DAP [9] 42.4 3.5 40.9 3.1 APART [28] 43.5 2.6 42.3 2.4 !20 Ours 51.5 2.5 51.0 2.1 IV-B Experimental Results We conducted experiments on various datasets under different settings, and the results of ImageNet-R, CIFAR100 and CUB200 are shown in TABLE I, I and I separately. When using ImageNet-R as the benchmark, with ρ=0.1ρ=0.1 (i.e., no additional processing) and dividing the dataset into 10 tasks, our method achieves 76.1%76.1\% accuracy, representing a 3.9%3.9\% improvement over MG-CLIP. When the number of tasks is increased to 2020, our method continues to perform robustly, achieving an accuracy of 73.7%73.7\%, which is a 3.4%3.4\% improvement over the previous SOTA method. Furthermore, when ρ=0.01ρ=0.01, our method achieves 72.1%72.1\% accuracy after learning 1010 consecutive tasks, and 70.0%70.0\% accuracy after 20 tasks. Our method maintains higher accuracy when the benchmark is changed to CIFAR100 and fine-grained CUB200 under different imbalanced ratios and tasks. Similarly, our method consistently remained optimal in comparisons of forgetting rates in all experiments, except on CIFAR100, ρ=0.01ρ=0.01, 1010 tasks, which was 0.1%0.1\% higher than the APART. IV-C Ablation Study In this section, we examine the effectiveness of each module within our proposed method. The experiments were conducted on different dataset with 10 tasks, and the results are shown in Table IV. Take Imagenet-R with ρ=0.01ρ=0.01 as an example, Baseline denotes zero-shot and it achieves a notable accuracy of 68.2%68.2\%. When SL-Tree is introduced, taking the mean of all layers, an improvement of 0.8%0.8\% is observed. Next, we explored the impact of training an adapter. Without additional constraints, severe catastrophic forgetting occurs, resulting in only 22.4%22.4\% accuracy. TABLE IV: Ablation study on different dataset with 10 tasks. + SL-Tree denotes taking the mean of all text features, while + updated α denotes using adaptive weights. Method CIFAR100 ImageNet-R CUB200 ρ=0.1ρ=0.1 ρ=0.01ρ=0.01 ρ=0.1ρ=0.1 ρ=0.01ρ=0.01 ρ=0.1ρ=0.1 Baseline 62.1 62.1 68.2 68.2 45.6 + SL-Tree 62.5 62.5 69.0 69.0 47.9 + ℒclsL_cls 19.8 17.4 23.8 22.4 20.1 + ℒkdL_kd 64.7 60.9 69.5 65.8 46.4 + ℒalgL_alg 67.4 62.4 72.9 69.4 48.7 + updated α 69.2 63.2 74.4 71.1 50.1 + ℛentR_ent 71.3 63.7 75.6 71.5 50.9 + ℛfreqR_freq 72.0 64.0 76.1 72.1 51.5 Introducing traditional knowledge distillation (KD) improves performance to 65.8%65.8\%, yet it still struggles to balance stability and plasticity during training. To address this, we propose stratified alignment language guidance that leverages the stability of the semantic space to regulate the optimization, resulting in 69.4%69.4\%. Further enhancement is achieved by introducing learnable weights and the adjustment raises performance to 71.1%71.1\%, confirming that different layers contribute differently to predictions.When uniform distribution constraints and prior constraints on tail classes were further incorporated into the weight update, the accuracy improved to 71.5%71.5\% and 72.1%72.1\%, respectively. Consistent performance across other experiments with different datasets further validates the effectiveness of our method. Figure 4: Tail classes accuracy of different tasks on ImageNet-R, ρ=0.01ρ=0.01 after 10 tasks. IV-D Further Analysis IV-D1 Tail Classes Accuracy Our primary objective is incremental learning on imbalanced data, making it essential to focus on the results of tail classes. We conducted experiments on ImageNet-R with ρ=0.01ρ=0.01 across 1010 tasks, specifically evaluating the accuracy of tail classes at each incremental stage. The results are shown in Fig.4. As the number of tasks increases, catastrophic forgetting is exacerbated as the imbalanced data distribution. However, our method consistently maintains high performance, achieving 7.2%7.2\% improvement over the previous SOTA after 10 tasks, demonstrating that our method effectively mitigates the challenges of LT-CIL. Figure 5: a) shows robustness of different LLMs and b) shows robustness of different prompt templates. All experiments were conducted on ImageNet-R with ρ=0.01ρ=0.01 after 10 tasks. IV-D2 Robustness of Different LLMs Our method relies on an LLM to generate task-specific text. To verify its robustness, we evaluate several different LLMs, including GPT-4o (4o), GPT-4-turbo (4-turbo), Claude-3.5-Haiku (haiku), all of which are commercial models, as well as Chat-Base-7B (7B), which is open-source and free. We conducted experiments on Imagenet-R, ρ=0.01ρ=0.01, and 1010 tasks, and the experimental results are shown in Fig.5 a). It is evident that our method is robust to different LLMs; even when economic constraints are considered, an open-source free model can still generate sufficiently effective text to support our method. IV-D3 Robustness of Different Prompt Templates To construct the SL-Tree, we designed four different prompt templates to guide the LLM in generating the desired text. To evaluate robustness with respect to prompt design, we conducted experiments on ImageNet-R with ρ=0.01ρ=0.01 and 1010 tasks, removing the text generated by the ithi^th prompt while keeping all other conditions unchanged. The results are shown in Fig.5 b). The performance is affected when the corresponding text is deleted. When the coarse-grained text generated by prompt 1 has been removed, the accuracy drops to 71.7%71.7\%, a decreased of 0.6%0.6\%. Similarly, when the fine-grained descriptions from Prompt 2 or Prompt 3 are removed, the accuracy decreases to 71.2%71.2\% and 70.%70.\%, respectively. After removing Prompt 4, the final accuracy decreased to 71.5%71.5\%, since prompt 4 cannot be applied to all classes and contributes selectively. TABLE V: Experiments on ImageNet-LT. Tasks Method Upper Bound CLIP Zero-Shot Adapter Fine-tuning Ours 20 75.6 63.1 19.6 68.2 50 75.6 63.1 17.4 66.7 IV-D4 Experiments on Large Scale Dataset We conducted experiments on a large-scal dataset, ImageNet-LT [25], which was obtained by resampling from ImageNet-1K [32] and contains 1000 different classes. We evenly divided ImageNet-LT into 20 and 50 independent tasks, requiring each task to learn 50 and 20 new classes, respectively. Classes with fewer than 400 samples were considered tail classes. Since most CIL and LT-CIL methods have not been evaluated on ImageNet-LT, we tested only the CLIP-based zero-shot, finetuning adapter, upper bound (joint learning) and our proposed method. The experimental results on VIT-B/16 are presented in the TABLE V. It can be observed that our method remains effective on large-scale datasets and is not constrained by dataset size, demonstrating strong scalability and robustness in the long-tail class incremental learning setting. Figure 6: Density map of weights center. Experiments conducted on Imagenet-R, ρ=0.01ρ=0.01, and 1010 tasks. IV-D5 Statistics of Weight Centers In the stratified adaptive language guidance, we introduced two additional constraints to regularize weight training, as formulated in Equations (7) and (9). Beyond the ablation studies presented in TABLE IV, we further visualized the learned weights to validate the effectiveness of these constraints. Specifically, experiments were conducted on ImageNet-R, 10 tasks with ρ=0.01ρ=0.01, comparing models trained without the proposed constraints and models trained with them. After training, we computed the weight center of each class and plotted the centers of all 200 classes as a density map, as shown in Fig. 6. The results demonstrate that, after training, the weight centers are no longer concentrated in the middle layers but are instead adaptively redistributed across layers according to the class distribution. Moreover, the centers exhibit an overall tendency to shift toward higher layers. This observation aligns with the motivation behind the design of our constraints, which aim to prevent the weights from collapsing into a limited subset of layers and encourage tail classes to rely more heavily on higher-level semantic layers, thereby enhancing discriminability under long-tail incremental learning. IV-D6 Layer-wise Prediction Improvements We calculate the difference in prediction probabilities for the correct label between two adjacent layers. The experiments were conducted on ImageNet-R with ρ=0.01ρ=0.01 and 1010 tasks. We present results on some tail classes in a bar chart format in Fig.7, where the vertical axis represents the accuracy improvement and the horizontal axis corresponds to the layers being compared. Here, index i means layer i compares to layer i+1i+1. As shown in the figure, because the G0G^0 of the SL-Tree provides a coarse-grained description of the entire task, performance improves when transitioning to G1G^1, which is generated by a fixed template. Figure 7: Performance difference between two adjacent layers. Experiments conducted on Imagenet-R, ρ=0.01ρ=0.01, and 1010 tasks. Furthermore, as the number of layers increases, the accuracy of most classes is positively correlated with depth, demonstrating why the SL-Tree—progressing from coarse-grained to fine-grained descriptions—outperforms fixed-template text features. However, there remain cases, such as candles, where the performance at a given layer is lower than that of the previous layer. This occurs because, as the depth of the SL-Tree increases, the generated text may randomly include content that is difficult for CLIP to interpret, such as “candle, which is characterized by various colors and scents.” This observation motivated the design of adaptive weights, rather than directly averaging across the SL-Tree. IV-D7 Effects on Tail Classes To verify the effect of stratified adaptive language guidance on tail classes, in addition to the overall tail classes’ accuracy shown in Fig.4, we further measured the per-class performance difference with and without stratified adaptive language guidance. The experiments were conducted on ImageNet-R, 10 tasks with ρ=0.01ρ=0.01. The results, presented using box plots in Fig.8, distinguish between head classes and tail classes. We observe that tail classes with fewer than 100 samples achieve substantially larger gains (mean ΔA=+16.6% A=+16.6\%) compared to head classes (mean ΔA=+4.1% A=+4.1\%), where ΔA A denotes the accuracy improvement. This indicates that our method specifically enhances classification for data-scarce tail classes, cconsistent with its motivation to mitigate class imbalance in LT-CIL. Figure 8: Effects on Tail Classes. Experiments conducted on Imagenet-R, ρ=0.01ρ=0.01, and 1010 tasks. TABLE VI: Results on different pre-trained models. Experiments conducted on Imagenet-R, ρ=0.01ρ=0.01, and 1010 tasks. Method Base model ViT-B/16 ViT-L/14 ViT-G/14 DAP 64.8 74.8 77.9 APART 65.2 75.9 78.3 !20 Ours 72.1 85.0 86.1 IV-D8 Experiments on Different Pre-trained Model We conducted experiments on ImageNet-R with ρ = 0.01 across 10 tasks using CLIP models of different sizes, VIT-B/16, VIT-L/14, and VIT-G/14. We evaluated different model structures against DAP and APART, two of the latest methods for LT-CIL. The experimental results are presented in Table VI. Our method consistently achieves the best performance across different CLIP model sizes, demonstrating strong scalability and robustness with respect to model capacity. TABLE VII: Long-Tail Experiments on ImageNet-R (ρ=0.01ρ=0.01). Bold indicates the best result. Method All Tail Baseline (CLIP) 68.2 66.7 Baseline⋆ (Adapter) 65.2 62.4 + LDAM 68.5 66.7 + BalPoE 68.5 66.3 LFM+MMS 70.1 69.5 Baseline + SL-Tree 71.4 69.4 Baseline⋆ + LTGC 73.0 70.2 !20 Baseline⋆ + SL-Tree (Ours) 73.5 71.5 IV-D9 Long-tail Experiments We conducted experiments on a long-tail (LT) dataset to evaluate the effectiveness of our method in addressing data imbalance. The experimental setup involved training and testing on the full ImageNet-R dataset with ρ=0.01ρ=0.01. We selected LFM+MMS [24], LDAM [3], BalPoE [1], and LTGC [47] for comparison. The results are reported in Table VII. Baseline denotes direct CLIP zero-shot, while Baseline⋆ refers to training the adapter; LDAM and BalPoE are both implemented with Baseline⋆ . We evaluate performance on all classes (All) and tail classes (Tail). The results show that fine-tuning the adapter is highly sensitive to data imbalance, leading to performance degradation and failing to achieve the expected improvement after transfer. By contrast, incorporating constraints from classic LT methods can mitigate the negative effects of imbalanced class distributions. Finally, SL-Tree leverages rich semantic information to compensate for data deficiencies and reduce the impact of task imbalances caused by long-tail data during model training. TABLE VIII: Conventional class incremental learning experiments on CIFAR100, 10 tasks. Method All Accuracy (%) CODAPrompt 76.7 GMM 78.0 RAPF 78.5 MG-CLIP 79.4 !20 Ours (SL-Tree, ρ=0.1ρ=0.1) 81.2 !20 Ours (SL-Tree, ρ=0.01ρ=0.01) 81.0 !20 Ours (SL-Tree, ρ=1ρ=1) 80.4 IV-D10 Conventional Class Incremental Learning Experiments Since most of the comparison methods in TABLE I-I are originally designed for conventional class incremental learning (CIL), we further conducted experiments under the standard CIL setting. For our method, we considered two scenarios: 1) using the SL-Tree generated under imbalanced conditions (with ρ=0.1ρ=0.1 and ρ=0.01ρ=0.01), while keeping the rest of the method unchanged; and 2) removing prompt template 4 and adopting the remaining templates to uniformly guide the LLM in generating text descriptions (corresponding to SL-Tree with ρ=1ρ=1). The results on CIFAR100 with 10 tasks are reported in Table VIII. It can be seen that when the data is balanced, better performance can be obtained by directly using our previously generated SL-Tree. However, due to the inconsistency between the balanced training distribution and the imbalanced semantic structure used to generate the SL-Tree, the improvement is still smaller than in the imbalanced case. And when we migrate the strategy of generating text easily to balanced data, it only gives slight improvement compared to the previous SOTA method due to the missing cycling generation. Therefore, adapting our method more effectively to the balanced data distribution remains a worthwhile research direction. (a) (b) (c) (d) Figure 9: t-SNE visualization of different classes. Experiments conducted on ImageNet-R, ρ=0.01ρ=0.01, and 1010 tasks. a) zero-shot; b) fine-tuned adapter; c) fine-tuned adapter with knowledge distillation (KD); d) fine-tuned adapter with KD and the proposed stratified alignment language guidance. IV-D11 t-SNE Visualization of Different Classes To further validate our proposed method, we conducted experiments using stratified alignment language guidance under four configurations: (1) zero-shot; (2) fine-tuned adapter; (3) fine-tuned adapter with knowledge distillation (KD); and (4) fine-tuned adapter with KD and the proposed adaptive language guidance. The experiments were conducted on ImageNet-R, ρ=0.01ρ=0.01 with 10 tasks. We selected head classes 2, 118, and 198, and tail classes 20, 141, and 199 from the test set. The t-SNE visualization results are shown in Fig.9. As observed, direct fine-tuning leads to a pronounced forgetting phenomenon on tail classes, resulting in highly entangled and poorly separated class distributions in the feature space. Incorporating knowledge distillation slightly mitigates this issue; however, compared with the zero-shot, the classification performance on tail classes remains suboptimal. When our proposed stratified alignment language guidance is introduced, the classification performance—particularly for tail classes—improves substantially, leading to clearer class boundaries and more compact feature clusters. (a) (b) (c) (d) Figure 10: Similarity heatmap of text featuress. Experiments conducted on ImageNet-R, ρ=0.01ρ=0.01, and 1010 tasks, a) is the fixed text; b) duplicating the fixed text; c) is the mean of text from different layers of SL-Tree; d) is the linearly weighted text from different layers of SL-Tree. IV-D12 Similarity Heatmap of Text Features To further validate our proposed stratified adaptive language guidance, we conducted similarity experiments on text features. Specifically, the experiments were conducted on ImageNet-R with 10 tasks under ρ=0.01ρ=0.01. Four methods of using text were evaluated: 1) texts generated with a fixed template ‘a photo of’; 2) duplicating the texts in 1) to match the number of texts in SL-Tree and averaging the corresponding text features; 3) averaging the text features extracted from different layers of the SL-Tree; and 4) linearly weighting the trained parameters associated with text features from different SL-Tree layers. We visualize cosine similarities between text features of different classes in a heatmap. As shown in Fig.10. The similarities among text features generated by the proposed SL-Tree are substantially lower than those produced using the fixed template, indicating a richer and more discriminative semantic representation. In addition, employing trainable weights yields better performance than directly averaging features from multiple layers. Furthermore, simply expanding the number of texts to the same scale as SL-Tree does not improve performance, highlighting that quantity alone cannot replace semantic diversity. Figure 11: Experimental consumption. Experiments conducted on Imagenet-R, ρ=0.01ρ=0.01, and 1010 tasks. (a) λ1 _1. (b) λ2 _2. (c) λ3 _3. (d) λ4 _4. Figure 12: Sensitivity analysis of hyperparameters. Experiments conducted on ImageNet-R, ρ=0.01ρ=0.01, and 1010 tasks. IV-D13 Experimental Consumption We analyzed the number of trained parameters and training time required by different methods on ImageNet-R with ρ=0.01ρ=0.01 across 10 tasks to compare their computational cost. The results are presented in Fig.11. In the bubble chart, the horizontal axis represents the number of parameters trained by each method, while the vertical axis represents accuracy. The accompanying histogram illustrates the training time of each method. As shown, our method achieves the highest accuracy while requiring a small number of parameters (0.41M) and the least training time (0.5 hours). This demonstrates that our method is not only effective but also highly efficient, offering strong performance with minimal computational overhead. IV-D14 Sensitivity Analysis of Hyperparameters In Equation (18), both losses and constraints are multiplied by different weights. We provide a comprehensive analysis of the hyperparameters, and all experiments were conducted on ImageNet-R with an imbalance ratio ρ=0.01ρ=0.01 and 10 tasks. The results of hyperparameters λ1 _1 - λ4 _4 are shown in Fig.12 a) - d), and the final value of λ1=0.025 _1=0.025, λ2=1 _2=1, λ3=0.3 _3=0.3 and λ4=0.6 _4=0.6. Our method is stable to different hyperparameters. V Conclusion In this paper, we propose a stratified language tree and two parallel language guidances, stratified adaptive language guidance and stratified alignment language guidance. Specifically, we first guide a large language model to generate a stratified language tree containing multi-scale semantic information. Then, adaptive language guidance introduces an adaptive trainable weights to leverages text descriptions to compensate for the lack of visual information in tail classes. Meanwhile, alignment language guidance exploits the stability of semantic information to constrain the model’s optimization, thereby reducing the influence of insufficient visual data on previously learned classes and mitigating catastrophic forgetting. By jointly leveraging these two complementary guidance mechanisms, our method effectively addresses the key challenges of long-tail class incremental learning (LT-CIL) and achieves superior performance across various benchmarks. References [1] E. S. Aimar, A. Jonnarth, M. Felsberg, and M. Kuhlmann (2023) Balanced product of calibrated experts for long-tailed recognition. In CVPR, p. 19967–19977. Cited by: §IV-D9. [2] R. Aljundi, F. Babiloni, M. Elhoseiny, M. Rohrbach, and T. Tuytelaars (2018) Memory aware synapses: learning what (not) to forget. In ECCV, p. 139–154. Cited by: §I-A. [3] K. Cao, C. Wei, A. Gaidon, N. Aréchiga, and T. Ma (2019) Learning imbalanced datasets with label-distribution-aware margin loss. In NeurIPS, p. 1565–1576. Cited by: §IV-D9. [4] X. Cao, H. Lu, L. Huang, X. Liu, and M. Cheng (2024) Generative multi-modal models are good class incremental learners. In CVPR, p. 28706–28717. Cited by: §I-A, §IV-A, TABLE I, TABLE I. [5] J. Chen, T. Nguyen, D. Görür, and A. Chaudhry (2023) Is forgetting less a good inductive bias for forward transfer?. In ICLR, Cited by: §I-A. [6] J. C. Duchi, S. Shalev-Shwartz, Y. Singer, and T. Chandra (2008) Efficient projections onto the l1_ 1-ball for learning in high dimensions. In ICML, p. 272–279. Cited by: §I-C. [7] E. Fini, V. G. T. da Costa, X. Alameda-Pineda, E. Ricci, K. Alahari, and J. Mairal (2022) Self-supervised models are continual learners. In CVPR, p. 9611–9620. Cited by: §I-A. [8] R. Franklin, J. Yao, D. Zhong, Q. Qian, and J. Hu (2024) Text-guided mixup towards long-tailed image categorization. In BMVC, Cited by: §IV-A, TABLE I, TABLE I. [9] Y. Gu, M. Yang, X. Yang, K. Wei, H. Zhu, G. J. Goenawan, and C. Deng (2025) Dynamic adapter tuning for long-tailed class-incremental learning. In WACV, p. 8176–8185. Cited by: §I, §I, §I-B, §IV-A, TABLE I, TABLE I, TABLE I. [10] Y. Gu, X. Yang, K. Wei, and C. Deng (2022) Not just selection, but exploration: online class-incremental continual learning via dual view consistency. In CVPR, p. 7432–7441. Cited by: §I-A. [11] D. Hendrycks, S. Basart, N. Mu, S. Kadavath, F. Wang, E. Dorundo, R. Desai, T. Zhu, S. Parajuli, M. Guo, D. Song, J. Steinhardt, and J. Gilmer (2021) The many faces of robustness: A critical analysis of out-of-distribution generalization. In ICCV, p. 8320–8329. Cited by: §IV-A. [12] L. Huang, X. Cao, H. Lu, and X. Liu (2025) Class-incremental learning with clip: adaptive representation adjustment and parameter fusion. In ECCV, p. 214–231. Cited by: §I, §I-A, §IV-A, TABLE I, TABLE I, TABLE I. [13] L. Huang, X. Cao, H. Lu, Y. Meng, F. Yang, and X. Liu (2025) Mind the gap: preserving and compensating for the modality gap in clip-based continual learning. In ICCV, p. 3777–3786. Cited by: §IV-A, TABLE I, TABLE I, TABLE I. [14] J. Kalla and S. Biswas (2024) Robust feature learning and global variance-driven classifier alignment for long-tail class incremental learning. In WACV, p. 32–41. Cited by: §I, §I-B, §IV-A, TABLE I, TABLE I. [15] M. G. Z. A. Khan, M. F. Naeem, L. Van Gool, D. Stricker, F. Tombari, and M. Z. Afzal (2023) Introducing language guidance in prompt-based continual learning. In ICCV, p. 11463–11473. Cited by: §I, §I-A. [16] A. Krizhevsky, G. Hinton, et al. (2009) Learning multiple layers of features from tiny images. Cited by: §IV-A. [17] M. D. Lange, G. M. van de Ven, and T. Tuytelaars (2023) Continual evaluation for lifelong learning: identifying the stability gap. In ICLR, Cited by: §I-A. [18] K. Lee, Y. Zhong, and Y. Wang (2023) Do pre-trained models benefit equally in continual learning?. In WACV, p. 6474–6482. Cited by: §I-A. [19] S. Lee, J. Kim, J. Jun, J. Ha, and B. Zhang (2017) Overcoming catastrophic forgetting by incremental moment matching. In NeurIPS, p. 4652–4662. Cited by: §I-A. [20] B. Li, Z. Han, H. Li, H. Fu, and C. Zhang (2022) Trustworthy long-tailed classification. In CVPR, p. 6970–6979. Cited by: §I-B. [21] Y. Li, H. Wang, Y. Qi, W. Liu, and R. Li (2025) Re-fed+: A better replay strategy for federated incremental learning. IEEE Trans. Pattern Anal. Mach. Intell. 47 (7), p. 5489–5500. Cited by: §I-A. [22] Z. Li and D. Hoiem (2017) Learning without forgetting. IEEE Trans. Pattern Anal. Mach. Intell. 40 (12), p. 2935–2947. Cited by: §I-A. [23] G. Lin, H. Chu, and H. Lai (2022) Towards better plasticity-stability trade-off in incremental learning: A simple linear connector. In CVPR, p. 89–98. Cited by: §I-A. [24] X. Liu, Y. Hu, X. Cao, A. D. Bagdanov, K. Li, and M. Cheng (2022) Long-tailed class incremental learning. In ECCV, p. 495–512. Cited by: §I, §I-B, §IV-A, §IV-D9, TABLE I, TABLE I. [25] Z. Liu, Z. Miao, X. Zhan, J. Wang, B. Gong, and S. X. Yu (2019) Large-scale long-tailed recognition in an open world. In CVPR, p. 2537–2546. Cited by: §IV-D4. [26] P. Mazumder, P. Singh, P. Rai, and V. P. Namboodiri (2024) Rectification-based knowledge retention for task incremental learning. IEEE Trans. Pattern Anal. Mach. Intell. 46 (3), p. 1561–1575. Cited by: §I-A. [27] K. Park, K. Song, and G. Park (2024) Pre-trained vision and language transformers are few-shot incremental learners. In CVPR, p. 23881–23890. Cited by: §I, §IV-A, TABLE I, TABLE I, TABLE I. [28] Z. Qi, D. Zhou, Y. Yao, H. Ye, and D. Zhan (2025) Adaptive adapter routing for long-tailed class-incremental learning. Mach. Learn. 114 (3), p. 68. Cited by: §I, §I-B, §IV-A, TABLE I, TABLE I, TABLE I. [29] J. Qiao, Z. Zhang, X. Tan, C. Chen, Y. Qu, Y. Peng, and Y. Xie (2024) Prompt gradient projection for continual learning. In ICLR, Cited by: §I-A. [30] A. Radford, J. W. Kim, C. Hallacy, A. Ramesh, G. Goh, S. Agarwal, G. Sastry, A. Askell, P. Mishkin, J. Clark, et al. (2021) Learning transferable visual models from natural language supervision. In ICML, p. 8748–8763. Cited by: §I-A2. [31] H. Ritter, A. Botev, and D. Barber (2018) Online structured laplace approximations for overcoming catastrophic forgetting. In NeurIPS, p. 3742–3752. Cited by: §I-A. [32] O. Russakovsky, J. Deng, H. Su, J. Krause, S. Satheesh, S. Ma, Z. Huang, A. Karpathy, A. Khosla, M. S. Bernstein, A. C. Berg, and L. Fei-Fei (2015) ImageNet large scale visual recognition challenge. Int. J. Comput. Vis. 115 (3), p. 211–252. Cited by: §IV-D4. [33] J. S. Smith, L. Karlinsky, V. Gutta, P. Cascante-Bonilla, D. Kim, A. Arbelle, R. Panda, R. Feris, and Z. Kira (2023) Coda-prompt: continual decomposed attention-based prompting for rehearsal-free continual learning. In CVPR, p. 11909–11919. Cited by: §I-A, §IV-A, TABLE I, TABLE I, TABLE I. [34] V. Thengane, S. Khan, M. Hayat, and F. S. Khan (2022) CLIP model is an efficient continual learner. CoRR abs/2210.03114. Cited by: §I, §I. [35] C. Wah, S. Branson, P. Welinder, P. Perona, and S. Belongie (2011) The caltech-ucsd birds-200-2011 dataset. Cited by: §IV-A. [36] W. Wang and M. Á. Carreira-Perpiñán (2013) Projection onto the probability simplex: an efficient algorithm with a simple proof, and an application. CoRR abs/1309.1541. Cited by: §I-C. [37] X. Wang, X. Yang, J. Yin, K. Wei, and C. Deng (2024) Long-tail class incremental learning via independent sub-prototype construction. In CVPR, p. 28598–28607. Cited by: §I, §I-B, §IV-A, TABLE I, TABLE I, TABLE I. [38] Z. Wang, Y. Li, L. Shen, and H. Huang (2024) A unified and general framework for continual learning. In ICLR, Cited by: §I-A. [39] Z. Wang, Z. Zhang, S. Ebrahimi, R. Sun, H. Zhang, C. Lee, X. Ren, G. Su, V. Perot, J. Dy, et al. (2022) Dualprompt: complementary prompting for rehearsal-free continual learning. In ECCV, p. 631–648. Cited by: §I, §I-A, §IV-A, TABLE I, TABLE I, TABLE I. [40] Z. Wang, Z. Zhang, C. Lee, H. Zhang, R. Sun, X. Ren, G. Su, V. Perot, J. Dy, and T. Pfister (2022) Learning to prompt for continual learning. In CVPR, p. 139–149. Cited by: §I, §I-A, §IV-A, TABLE I, TABLE I, TABLE I. [41] K. Wei, C. Deng, and X. Yang (2020) Lifelong zero-shot learning. In IJCAI, p. 551–557. Cited by: §I-A. [42] T. Wu, G. Swaminathan, Z. Li, A. Ravichandran, N. Vasconcelos, R. Bhotika, and S. Soatto (2022) Class-incremental learning with strong pre-trained models. In CVPR, p. 9601–9610. Cited by: §I-A. [43] Y. Wu, Y. Chen, L. Wang, Y. Ye, Z. Liu, Y. Guo, and Y. Fu (2019) Large scale incremental learning. In CVPR, p. 374–382. Cited by: §I-A. [44] F. Zenke, B. Poole, and S. Ganguli (2017) Continual learning through synaptic intelligence. In ICML, p. 3987–3995. Cited by: §I-A. [45] J. Zhai, X. Liu, L. Yu, and M. Cheng (2024) Fine-grained knowledge selection and restoration for non-exemplar class incremental learning. In AAAI, p. 6971–6978. Cited by: §I. [46] Y. Zhang, B. Kang, B. Hooi, S. Yan, and J. Feng (2023) Deep long-tailed learning: a survey. IEEE Trans. Pattern Anal. Mach. Intell. 45 (9), p. 10795–10816. Cited by: §I-B. [47] Q. Zhao, Y. Dai, H. Li, W. Hu, F. Zhang, and J. Liu (2024) LTGC: long-tail recognition via leveraging llms-driven generated content. In CVPR, p. 19510–19520. Cited by: §I, §IV-D9. [48] Y. Zhao, J. Li, Z. Song, and Y. Tian (2025) Language-inspired relation transfer for few-shot class-incremental learning. IEEE Trans. Pattern Anal. Mach. Intell. 47 (2), p. 1089–1102. Cited by: §I-A. [49] F. Zhu, X. Zhang, Z. Cheng, and C. Liu (2025) PASS++: A dual bias reduction framework for non-exemplar class-incremental learning. IEEE Trans. Pattern Anal. Mach. Intell. 47 (8), p. 7123–7139. Cited by: §I-A.