wikillm

Paper · 2026-09-30 · cs.LG

Dynamic LoRA-Experts and Prototype-Ensemble Matching for Class-Incremental Learning

Rehearsal-free class-incremental learning on a frozen ViT-B/16. Each task gets its own LoRA expert, and earlier experts are frozen. At inference the expert is chosen by nearest prototype key, where each key concatenates frozen-backbone and router features. Author-reported average accuracy is 93.39% on CIFAR100 (10 tasks) and 88.77% on the CUB200 few-shot protocol.

Continual learningParameter-efficient fine-tuningLow-rank adaptation (LoRA and variants)Prototype learningclass-incremental-learninglorarehearsal-freeprototype-matching

arXivPDFCodeMarkdown17 min read

AI-compiled by claude-haiku-5-5 on 2026-11-21, not yet reviewed by a human. Every claim cites its source; check it when a detail matters.

In plain words

A model that learns new categories one batch at a time tends to forget the old ones. This paper keeps a large pre-trained vision model frozen and adds a small add-on module for each new group of classes. Old add-ons are never changed again, so earlier knowledge cannot be overwritten. The module used for learning is a low-rank adapter, a pair of small matrices that nudge the frozen layers.

The hard part is choosing the right add-on at test time. The method keeps a short list of stored "fingerprints", one per class. Each fingerprint combines a description from the untouched pre-trained model with a description from a second, trained copy of the adapter. A new image is compared with these fingerprints, and the closest one decides which add-on to use. The method stores no old images, only the add-ons and the fingerprints.

The authors report that this beats several recent methods on standard class-incremental benchmarks and on a few-shot variant. Those numbers come from their own runs.

TL;DR

The paper proposes DLEPEM, a rehearsal-free method for class-incremental learning on a frozen ViT-B/16. Each task trains a new LoRA expert, and earlier experts are frozen. A prototype dictionary built from frozen-backbone features and router features picks the expert at inference. Author-reported average accuracy is 93.39% on CIFAR100 and 92.31% on CUB200 (the CUB figure uses the MLP variant). The official code runs the CIL protocols, but the few-shot protocol is not implemented in it, and the code has several differences from the paper (see Paper vs code). Relevant if you want a parameter-efficient CIL baseline that stores no exemplars.

Problem

Class-incremental learning (CIL) trains on classes that arrive over a sequence of tasks, with no access to earlier data §1 §3. Fine-tuning the whole pre-trained network risks losing its generalisation and amplifying forgetting §1. Parameter- efficient methods such as prompts, adapters and LoRA reduce the damage but have their own failure modes §1. The authors name two: cumulative interference when modules are updated or fused across tasks, and poor matching between a test sample and the module that should handle it §1 §2.2. Methods that route with a fixed or learned gate can suffer when the router is trained only on the current task §2.3.

Method

Setting §3. Tasks have disjoint label sets. During task t the model sees only the data of task t. After each task, the model is tested on every class it has seen up to that point. The training loss is cross-entropy on the current task's data §3.

Backbone §4.1 §5.1. The pre-trained ViT-B/16 (ImageNet-21K) is kept frozen. The authors insert low-rank adapters with rank r = 10 into every Transformer block. Two placements are studied. QV-Expert puts the adapters on the query and value paths of the attention layer. MLP-Expert adds a parallel adapter branch to the feed-forward layer §4.1 fig. 1 §5.1. Each adapter is a down-projection to r dimensions followed by an up-projection back to the model width, with no bias and no nonlinearity §3 §4.1. The adapter's initial up-projection is zero and its down-projection uses Kaiming initialisation §4.1.

Stage 1: one expert per task §4.1 §4.3 alg. 1. For task t, a new expert E_t is created. For t > 1 it starts from a copy of the previous expert. Only the current expert and the classifier head are trained, with cross-entropy §4.3 eq. ce_loss. After training the expert is frozen. The authors argue that old experts receive no gradient in later tasks and so stay fixed §4.1. Classes are then summarised by prototypes: for each new class, the mean feature of its training samples under the new expert §4.2 eq. prototype_computation.

Stage 2: router §4.2 §4.3 alg. 1. A second adapter set, the router, is trained from task 2 on. It is regularised by two KL-divergence terms with weight alpha. The plasticity term pulls the router's softmax features towards the current expert's class prototype for each sample. The stability term pulls them towards the router's output from the previous task on the same inputs §4.2 eq. pla_fd eq. sta_fd eq. router_loss. Alpha is 0.04 by default §5.1. The paper says the router is trained for 5 epochs per task §5.1.

Prototype-ensemble dictionary §4.2. After each task, for each class i in the new task, the method builds an ensemble key K_i by concatenating two vectors. The first is a general prototype P^F from the frozen pre-trained model. The second is a domain prototype P^R from the router eq. prototype_ensemble. Each key is stored with the index of its expert eq. key. The dictionary is append-only: keys of older classes are not recomputed §4.2. Apart from the adapters, the state kept is the dictionary and the current router. No images, feature buffers or exemplars are kept §4.2.

Inference §4.2 alg. 2. For a test image x, form the query by concatenating the frozen-model feature and the router feature. Find the key with the highest cosine similarity. Its stored index gives the expert t-hat. Compute the expert's feature and classify it with cosine similarity against the class prototypes P^L of the classes that belong to that expert §4.2 §4.3 eq. final_fx.

Variants §5.1. DLEPEM-QV and DLEPEM-MLP differ only in the adapter placement.

Pseudocode
# DLEPEM training, one task at a time  [alg. 1] [§4.3]
# Frozen backbone; experts, router and dictionary are built per task
def train_dlepem(backbone, tasks, rank, alpha):
    experts = []
    dictionary = []   # (key, expert index) pairs, append-only  [§4.2]
    router = None
    for t, task_data in enumerate(tasks, start=1):
        # Stage 1: train the current expert and head on this task only  [§4.1]
        expert = new_adapter_set(rank, copy_from=last_or_none(experts))
        for batch in task_data:
                # Cross-entropy over the current task's classes  [§4.3]
            logits = head(backbone(batch.x, expert))
            update(expert, head, cross_entropy(logits, batch.y))
        freeze(expert)   # old experts are never trained again  [§4.1]
        experts.append(expert)
        # Stage 2: router. The paper trains it at every task  [alg. 1]
        # The code copies the first expert instead  [code: models/dlepem.py#L206-L216]
        if router is None:
            router = copy(expert)
        if t > 1:
            old_router = copy(router)
            for batch in task_data:
                # Mix the plasticity and stability KL terms  [§4.2]
                # [eq. router_loss]
                loss = router_loss(batch, router, old_router, expert, alpha)
                update(router, loss)
        # Append ensemble keys for the new classes only  [§4.2]
        # [eq. prototype_ensemble]
        for c in classes_of(task_data):
            # Code normalises each frozen feature first  [code: models/dlepem.py#L358]
            general = mean_normalised(frozen_backbone(x) for x in class c)
            domain = mean(router(x) for x in class c)
            dictionary.append((concat(general, domain), t))
    return experts, router, dictionary
Pseudocode
# Router loss  [§4.2] [eq. router_loss] [eq. pla_fd] [eq. sta_fd]
# Softmax over the feature dimension; tau is not given in the paper
def router_loss(batch, router, old_router, expert, alpha):
    # Router features as a distribution over feature dimensions  [§4.2]
    p_router = softmax(router(batch.x))
    p_old = softmax(old_router(batch.x))
    # Target: class prototype of the current expert for each sample  [§4.2]
    p_proto = softmax(expert_prototype[batch.y])
    plasticity = kl(p_proto, p_router)    # KL(prototype || router)
    stability = kl(p_old, p_router)       # KL(old router || router)
    return alpha * plasticity + (1 - alpha) * stability
Pseudocode
# Inference  [alg. 2] [§4.2] [§4.3]
# Query: frozen-model feature concatenated with router feature  [§4.2]
def predict(x, backbone, router, dictionary, prototypes):
    query = concat(frozen_backbone(x), router(x))
    # Nearest key by cosine similarity over all stored keys  [§4.2]
    best = argmax_k cosine(query, dictionary[k].key)
    expert_index = dictionary[best].expert
    z = backbone_with_expert(x, expert_index)
    # Classify against the prototypes of the selected expert  [§4.3]
    # The paper restricts to that expert's classes; the code does not
    return argmax_c cosine(z, prototypes[c])

Hyperparameters

Values are as the paper states them unless marked as coming from code. The official repository's configs are in scripts/*.json.

NameValueWhereNotes
BackboneViT-B/16, ImageNet-21K pre-trained, frozen§5.1other backbones in fig. 5
Adapter rank r10§5.1 §4.1sensitivity in fig. 7; code default dlepem_cub_B0_Inc20.json
Adapter placementall Transformer blocks; QV or MLP§5.1code loops over all blocks vit_dlepem.py
Adapter initup-projection zero, down-projection Kaiming§4.1vit_dlepem.py
Expert optimiserSGD, initial lr 0.02, cosine annealing§5.1code adds momentum 0.9 dlepem.py; paper does not state momentum
Expert epochs per task20§5.1code tuned_epoch: 20
Head learning ratenot stated-code uses 0.1 x 0.02 = 0.002 dlepem.py
Weight decaynot stated-code 0.0005 dlepem_cub_B0_Inc20.json
Batch size48§5.1
Router epochs per task5§5.1code router_epochs: 5
Router learning ratenot stated-code 0.001 dlepem_cub_B0_Inc20.json
Router schedulernot stated-code uses the expert's cosine schedule with T_max = 20, so the 5-epoch router barely decays dlepem.py dlepem.py
Alpha (distillation weight)0.04§5.1 §5.6stable across (0, 0.1] §5.6 fig. 7
Temperature taunot stated-code uses 1.0 dlepem.py
Old-class logits in CEnot stated-code sets them to -inf during expert training dlepem.py
Data augmentation"follows original implementations" of baselines§5.1not stated for DLEPEM
Seedsdata-split seed 1993; results averaged over three runs§5.1configs list one seed dlepem_cub_B0_Inc20.json
Tasks per benchmarkCIFAR100 10x10; CUB200 10x20; ImageNet-R 5x40; OmniBenchmark 10x30; VTAB 5x10tab. 1
Few-shot tasksCUB200 100 base + 10 x (10-way 5-shot); CIFAR100 and mini-ImageNet 60 base + 8 x (5-way 5-shot)tab. 2not implemented in the repository
HardwareNVIDIA A800§5.1

Storage budget, computed by the authors for FP32 §5.4 eq. storage_scalability:

ItemFormulaValue (ViT-B, d = 768, L = 12, r = 10)
One MLP-ExpertL x 2dr0.18M parameters (about 0.70 MiB)
One QV-Expert2L x 2dr0.37M parameters (about 1.41 MiB)
Expert bank, 10 tasksper expert x T1.84M (MLP) and 3.69M (QV), about 2.1% and 4.3% of 86M
Expert bank, 100 tasksper expert x T18.43M (MLP) and 36.86M (QV)
Prototype dictionary2d x classes x 4 bytesabout 0.59 MiB at 100 classes, 1.76 MiB at 300

Results

Author-reported. All rows share one pre-trained backbone, and the authors reran the baselines themselves §5.1. Mean and standard deviation over three runs. The bold entries are the paper's marking tab. 3.

Class-incremental learning tab. 3

MethodCIFAR100 (T=10) A_LCIFAR100 ĀCUB200 (T=10) A_LCUB200 ĀImageNet-R (T=5) A_LImageNet-R ĀOmniBenchmark (T=10) A_LOmniBenchmark ĀVTAB (T=5) A_LVTAB Ā
Full fine-tuning66.26 ± 0.1876.94 ± 0.0255.29 ± 0.4670.30 ± 0.7459.90 ± 0.0572.19 ± 0.1247.75 ± 0.1465.86 ± 0.1262.95 ± 5.9480.80 ± 1.50
SimpleCIL81.27 ± 0.0187.13 ± 0.0182.28 ± 6.3591.85 ± 0.0065.14 ± 15.2959.72 ± 0.0366.98 ± 8.9379.35 ± 0.0180.74 ± 5.2690.80 ± 0.00
L2P84.82 ± 0.2289.78 ± 0.0171.98 ± 0.0781.80 ± 0.0372.08 ± 0.0176.76 ± 0.0664.45 ± 0.0774.14 ± 0.0364.27 ± 0.0281.84 ± 0.19
DualPrompt85.23 ± 0.0790.32 ± 0.0674.23 ± 0.1084.81 ± 0.0269.34 ± 0.0973.58 ± 0.0566.16 ± 0.0674.97 ± 0.0378.90 ± 0.1089.82 ± 0.06
CODA-Prompt86.69 ± 0.0091.31 ± 0.0175.45 ± 0.0084.65 ± 0.0075.16 ± 0.0880.46 ± 0.0468.67 ± 0.0077.79 ± 0.0075.08 ± 0.0087.24 ± 0.00
APER87.32 ± 0.0192.09 ± 0.0286.82 ± 0.0491.84 ± 0.0368.22 ± 0.0775.30 ± 0.0774.40 ± 0.0180.62 ± 0.0184.44 ± 0.0186.27 ± 0.02
LAE85.60 ± 0.1991.26 ± 0.1267.91 ± 0.0480.17 ± 0.0471.26 ± 0.1877.08 ± 0.0466.14 ± 0.0674.89 ± 0.0368.45 ± 2.5385.31 ± 0.44
InfLoRA86.43 ± 0.0291.80 ± 0.0270.07 ± 0.2681.71 ± 0.1777.66 ± 0.0882.90 ± 0.0568.38 ± 0.1278.06 ± 0.0374.66 ± 0.4386.03 ± 0.17
SD-LoRA87.62 ± 0.0092.10 ± 0.0072.69 ± 0.0083.17 ± 0.0078.52 ± 0.0082.74 ± 0.0069.32 ± 0.0077.78 ± 0.0067.73 ± 0.0084.44 ± 0.00
EASE88.13 ± 0.0492.59 ± 0.0584.18 ± 0.0690.20 ± 0.0476.95 ± 0.0581.48 ± 0.0667.75 ± 0.0474.85 ± 0.0582.34 ± 0.0690.45 ± 0.04
BiLoRA85.30 ± 0.0590.73 ± 0.0473.75 ± 0.0683.67 ± 0.0576.33 ± 0.0481.21 ± 0.0768.87 ± 0.0577.53 ± 0.0476.76 ± 0.0688.94 ± 0.05
DLEPEM-MLP85.99 ± 0.3492.40 ± 0.0387.70 ± 0.0592.31 ± 0.2976.25 ± 0.4482.37 ± 0.1474.32 ± 0.0081.60 ± 0.0084.96 ± 0.2291.84 ± 0.03
DLEPEM-QV88.84 ± 0.0993.39 ± 0.1087.56 ± 0.1692.09 ± 0.0878.77 ± 0.0783.43 ± 0.1275.53 ± 0.0882.16 ± 0.0685.18 ± 0.1491.11 ± 0.13

Headline numbers, as the paper states them: CIFAR100 93.39 (QV, +0.80 over EASE), CUB200 92.31 (MLP, +2.11 over EASE), ImageNet-R 83.43 (QV, +0.53 over InfLoRA), OmniBenchmark 82.16 (QV, +1.54 over APER), VTAB 91.84 (MLP, +1.39 over EASE). The variant differs by dataset, so no single configuration has all the best numbers.

Few-shot class-incremental learning tab. 4

MethodCUB200 (1+10) A_BaseCUB200 A_LCUB200 ĀCIFAR100 (1+8) A_BaseCIFAR100 A_LCIFAR100 Āmini-ImageNet (1+8) A_Basemini-ImageNet A_Lmini-ImageNet Ā
L2P91.50 ± 0.0050.04 ± 0.0066.70 ± 0.0093.43 ± 0.0055.75 ± 0.0071.81 ± 0.0096.53 ± 0.0060.91 ± 0.0076.28 ± 0.00
CODA-Prompt91.50 ± 0.0053.65 ± 0.0069.30 ± 0.0094.05 ± 0.0057.10 ± 0.0073.11 ± 0.0097.15 ± 0.0065.55 ± 0.0078.83 ± 0.00
InfLoRA92.45 ± 0.2045.18 ± 2.5066.27 ± 1.4394.92 ± 0.0657.41 ± 0.3174.28 ± 0.2897.42 ± 0.0651.52 ± 0.1071.55 ± 0.03
SD-LoRA91.92 ± 0.0056.28 ± 0.0070.87 ± 0.0094.60 ± 0.0073.51 ± 0.0078.42 ± 0.0097.72 ± 0.0079.07 ± 0.0084.36 ± 0.00
CPE-CLIP80.21 ± 0.8563.32 ± 0.1769.37 ± 0.3788.32 ± 0.0479.99 ± 0.1883.38 ± 0.1090.14 ± 0.0581.55 ± 0.0485.54 ± 0.04
ASP87.14 ± 0.1182.86 ± 0.2683.46 ± 0.2291.77 ± 0.0986.04 ± 0.0388.54 ± 0.0396.32 ± 0.1593.72 ± 0.2594.97 ± 0.21
PriViLege82.21 ± 0.3575.08 ± 0.5277.50 ± 0.3390.88 ± 0.2086.06 ± 0.3288.08 ± 0.2096.68 ± 0.0694.10 ± 0.1395.27 ± 0.11
DLEPEM-MLP92.51 ± 0.0085.37 ± 0.0088.53 ± 0.0094.28 ± 0.0084.67 ± 0.0089.00 ± 0.0096.37 ± 0.0089.96 ± 0.0093.11 ± 0.00
DLEPEM-QV92.68 ± 0.0086.22 ± 0.0088.77 ± 0.0094.00 ± 0.0087.29 ± 0.0090.50 ± 0.0096.77 ± 0.0093.62 ± 0.0094.80 ± 0.00

Paper-reported gains: CUB200 Ā 88.77 vs ASP 83.46 (+5.31); CIFAR100 Ā 90.50 vs ASP 88.54 (+1.96). The mini-ImageNet result is described as on par with the strongest baselines §5.2.

Ablations tab. 5. Each cell is MLP / QV.

VariantCIFAR100 (T=10) A_LCIFAR100 ĀImageNet-R (T=5) A_LImageNet-R ĀCIFAR100 (T=9) A_LCIFAR100 Āmini-ImageNet (T=9) A_Lmini-ImageNet Ā
w/o Dynamic LoRA-Expert (one shared expert)83.13 / 86.7288.85 / 90.8261.17 / 72.3774.31 / 80.1473.03 / 79.7380.39 / 86.5984.26 / 91.1189.90 / 93.31
w/o Prototype-Ensemble (frozen-prototype keys)85.79 / 87.5991.21 / 92.2969.53 / 73.1377.75 / 80.4281.13 / 84.0986.97 / 88.6785.54 / 92.2590.03 / 94.06
Full DLEPEM85.99 / 88.8492.40 / 93.3976.25 / 78.7782.37 / 83.4384.67 / 87.2989.00 / 90.5089.96 / 93.6293.11 / 94.80

Key-selection diagnostics tab. 6. Each cell is MLP / QV. The "CNN" row is the final average accuracy, and it matches the Ā values in tab. 3.

MetricCIFAR100 (T=10)CUB200 (T=10)ImageNet-R (T=5)OmniBenchmark (T=10)VTAB (T=5)
Final accuracy ("CNN")92.40 / 93.3992.31 / 92.0982.37 / 83.4381.60 / 82.1691.84 / 91.11
Router (expert-selection accuracy)91.88 / 93.6893.24 / 93.3188.43 / 88.8784.90 / 85.5593.45 / 93.56
Oracle expert (true task id used)98.04 / 97.8197.15 / 96.3189.17 / 88.8192.88 / 91.4897.66 / 95.88

Training and inference time tab. 7. Time per epoch of an incremental task and latency per image. The paper says DLEPEM is slower than SD-LoRA and InfLoRA at inference and calls the overhead "non-negligible but practical" §5.5.

MethodCIFAR100 train (s)CIFAR100 infer (ms)ImageNet-R train (s)ImageNet-R infer (ms)
L2P102.123.7750.123.84
DualPrompt93.213.4445.163.58
CODA-Prompt99.422.9947.533.08
LAE46.873.3524.263.52
InfLoRA72.362.0334.962.24
APER16.043.638.923.71
SD-LoRA79.081.9332.852.04
DLEPEM-MLP / QV69.46 / 71.378.39 / 9.2633.30 / 34.158.47 / 9.08

Hardware for timing is the same A800 setup §5.1 tab. 7.

Paper vs code

Repository: the one in the frontmatter, at commit 397847c779a7be28a571ec7ca88ef5ca5c0c3db7. The abstract and the data-availability statement both link this repository. It has no LICENSE file. Its README shows an MIT badge, which we do not treat as a license grant. No code is quoted here.

  • Inference restriction. The paper says the final classification is restricted to the classes of the selected expert §4.2 alg. 2. The evaluation code computes the selected expert's features and scores them against prototypes of all seen classes base.py. This is the path trainer.py calls trainer.py. The two differ whenever a class outside the selected expert scores higher on the selected expert's features.
  • Router at the first task. The paper trains the router from the first task, with the plasticity loss alone §4.2 alg. 1. The code copies the first expert into the router and does not train it. Router training starts at the second task dlepem.py.
  • Classifier used in training versus at test time. Cross-entropy is computed on the backbone's own linear head dlepem.py vit_dlepem.py. After training, replace_fc overwrites the rows of a separate cosine classifier with the expert's mean features, and that classifier is used at test time dlepem.py dlepem.py. The paper's cosine-prototype formula §4.3 eq. final_fx matches the test-time classifier. The paper does not mention the head used in training.
  • Adapter placement. The paper writes the expert's input as the block input e §4.1 eq. mlp_expert eq. qkv_expert. The MLP-Expert in the code is applied to the residual stream after the attention sub-layer vit_dlepem.py. The QV-Expert takes the layer-normalised input vit_dlepem.py.
  • Key and query normalisation. The frozen half of each key is the mean of per-sample unit-normalised features. The router half is a plain mean dlepem.py. The query is the raw concatenation base.py. The paper says only that the two parts are concatenated §4.2. Cosine similarity is scale-invariant as a whole, but the two halves of the query are not weighted the way the keys are.
  • Temperature. The paper uses tau without a value §4.2. The code uses 1.0 dlepem.py.
  • Router training schedule. The paper trains the router 5 epochs per task §5.1. The code builds the router's scheduler from the expert setting (20 epochs), so the cosine schedule does not reach its end within 5 epochs dlepem.py dlepem.py dlepem.py.
  • Learning rates not in the paper. The router learning rate (0.001) and the head learning rate (0.1 times the expert rate) are set only in code dlepem_cub_B0_Inc20.json dlepem.py.
  • Old-class masking. The code sets the logits of old classes to minus infinity during expert training dlepem.py. The paper's cross-entropy §4.3 eq. ce_loss does not mention this.
  • Expert initialisation. The paper says each new expert is copied from the previous one §4.1 alg. 1. The code keeps training the same current module and stores a frozen deep copy after each task vit_dlepem.py. The weights are the same, but the optimiser is rebuilt for every task.
  • Few-shot protocol. The paper reports few-shot results §5.2 tab. 4 with the 10-way 5-shot protocol §5.1 tab. 2. The repository has no few-shot data handling and no few-shot configs. The one CUB200 config with a 100-class base is a 20-way CIL setting dlepem_cub_B100_Inc20.json. The few-shot results cannot be reproduced from this repository.
  • Seeds. The paper averages three runs §5.1. The configs list one seed dlepem_cub_B0_Inc20.json. The few-shot rows of tab. 4 show standard deviations of 0.00.
  • Classifier naming. tab. 6 labels the final-accuracy row "CNN". The method has no CNN component, so the label is a naming leftover.
  • Ablation naming. The ablation table uses "CIFAR100 (T=9)" for the few-shot protocol, which is a different split from the main CIFAR100 table tab. 5 tab. 3.

Pitfalls

  • Expert choice versus classification. Implement the restriction the paper describes alg. 2 if you want to match the paper's method. Implement the code's behaviour if you want to match the published numbers. The two are not interchangeable in general, and the difference is not measured by the paper.
  • Inference cost. The evaluation code computes features for every expert seen so far and then keeps only the selected one base.py. Each test batch therefore runs one backbone pass per task seen so far. The paper's latency description §5.5 does not mention this, and we did not measure how much of the reported latency tab. 7 it accounts for.
  • Expert bank growth. Expert storage rises with the task count, while the dictionary rises with the class count §5.4 eq. storage_scalability. The authors note that long streams may need compression §5.5.
  • Unstated hyperparameters. The paper leaves the router learning rate, the head learning rate, the momentum, the weight decay, the temperature and the augmentation unstated. The code fixes all of them (see Paper vs code).
  • Router drift. Keys from earlier tasks were computed with earlier router states. The paper's argument is that the frozen-backbone half keeps the keys comparable and that the stability term limits router drift §4.2. The authors do not measure this directly. Their router comparison fig. 4 is a post-hoc check.
  • Variant choice. The headline numbers mix the QV and MLP variants by dataset tab. 3. Pick one variant when you reproduce.
  • Variance. The few-shot rows of tab. 4 for DLEPEM show zero variance. Treat them as single-run values until the authors say otherwise.
  • Figure numbers. Figures are numbered here in source order. We did not check these numbers against the compiled PDF.
  • Zero-initialised up-projection. The up-projection starts at zero, so each new expert outputs zero at initialisation vit_dlepem.py. The first gradient steps therefore move only the up-projection. The paper describes the same initialisation §4.1.

Lineage

  • Builds on: LoRA §3 for the adapter form; L2P and DualPrompt §2.2 for prompt keys matched to tasks; Mixture-of-Experts routing §2.3 for the expert idea, changed to a task-level, append-only design.
  • Compared against: SimpleCIL, L2P, DualPrompt, CODA-Prompt, APER, LAE, InfLoRA, SD-LoRA, BiLoRA and EASE for CIL tab. 3; PriViLege, ASP and CPE-CLIP for few-shot CIL tab. 4. Baseline numbers are the authors' own reruns §5.1.
  • Superseded by: not stated.

Source and license

Adapted from “Dynamic LoRA-Experts and Prototype-Ensemble Matching for Class-Incremental Learning” by Hongwei Zhao, Rui Liu, Yansong Liu (arXiv:2609.39839), used under CC BY 4.0. Changes: condensed and restructured for implementation, with tables, equations and algorithms taken from the paper and its code, each cited to its source. Not affiliated with or endorsed by the authors. Code citations refer to https://github.com/hongwei-zhao/Applied_Sciences-DLEPEM-main at commit 397847c779a7 (not stated (no LICENSE file in repository; README badge says MIT)). Any quoted code is shown under that license.