acceptodds
Under review as a conference paper at ICLR 2027

What Must Replay Preserve? Separating Correctable Bias from Class Correspondence

Abstract

Class-incremental learning must recognize all classes seen so far without task labels. Logit replay methods such as DER and DER++ mitigate forgetting by matching the model’s past predictions on stored examples. Deleting this matching reveals its benefit, but the resulting accuracy cost cannot show whether the stored scores themselves are needed, or whether the cost survives correction of the classifier’s bias toward recent classes. We propose a diagnostic framework that treats a cached prediction as temporally heterogeneous supervision: it separates classes known when an example was stored from classes learned afterward, edits each group, and evaluates every model before and after a task-level offset that leaves within-task predictions unchanged. On CIFAR-100 with DER++, suitable fixed constants replace the unrefreshed stored scores of later-learned classes within a ±1 percentage-point equivalence margin, and the offset reduces the cost of deleting their matching from 14.9 to 1.8 points. Reassigning the non-gold scores of classes known at storage, which preserves their values and each task’s target probability, costs 4.3 points before and 4.0 after the offset, and a parallel cost persists in image distillation. In the tested fixed-head setting, the large cost of deleting later-class matching is thus mostly correctable by this offset, whereas the smaller cost of disrupting class correspondence persists. Code and data are available at anonymous.4open.science/r/replay-preserve-E22B.

Primary area:
transfer learning, meta learning, and lifelong learning
Keywords:
continual learning, class-incremental learning, logit replay, experience replay, replay targets, knowledge distillation, bias correction

Reviews

Among:
Shape:
1234this paper, Bottom 27%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.00 over 3 reviews, above 27% of the others.
Reviewer_7mYSOpenReview ↗
Rating
1
Confidence
4
Informativeness
2
Presentation
1
Soundness
2
Read review
Paper summary

This paper investigates what stored logits need to preserve in replay-based class-incremental learning. Through controlled interventions and task-level bias correction, the authors find that logits for later-learned classes can be replaced with fixed constants, whereas class correspondence among previously known classes remains important. Experiments are conducted on CIFAR-100 and TinyImageNet using various ResNet configurations. However, the extent to which these findings generalize beyond fixed-head settings remains unclear, and their potential to improve existing continual learning methods has not been empirically demonstrated.

Critical strengths
  1. The paper propose a clear and meaningful research question.
  2. The paper examines whether the original logits are necessary for logit matching and proposes a diagnostic framework to investigate this question.
  3. The authors conduct targeted experiments to investigate the research.
Critical weaknesses

My main concern is that the paper’s limited implications for broader continual learning methods, along with the unclear practical applicability of its findings to the wider research community, may make it difficult to meet the acceptance threshold.

  1. Although the motivation of the paper is understandable, the Introduction does not sufficiently explain how each experimental design addresses the research questions raised earlier. Figure 1 summarizes the experimental results but provides limited intuition about why these specific interventions are necessary and how they collectively support the paper’s main contribution. Explicitly explaining the rationale behind each experiment and its connection to the corresponding research question would help readers better understand the paper’s overall logic and contribution.

  2. The experiments are conducted primarily in a controlled setting with a fixed classifier head and explicit task partitions. Although the paper evaluates multiple datasets and ResNet configurations, it remains unclear to what extent the identified mechanisms generalize beyond these settings. Further discussion is needed to clarify whether the findings reflect general principles of replay-based continual learning or phenomena specific to the evaluated configurations. A more explicit discussion of the scope and limitations of the findings would strengthen the paper.

  3. Although the paper provides useful diagnostic insights into the role of replayed logits, it does not demonstrate how these findings can be leveraged to improve existing replay-based continual learning (CL) methods. In particular, the paper does not evaluate whether selectively preserving or replacing logits can improve accuracy or reduce memory and computational costs. Developing and empirically validating methods based on these findings would strengthen the practical value and broader impact of the work on the CL community.

Questions for authors
  1. In Figure 1, I believe that explaining why these experiments are designed this way is more important at this stage than presenting specific numerical results or accuracy drops.

  2. How well do these findings generalize to other continual learning benchmarks and replay methods, and how might they inform the development of more memory-efficient replay strategies?

  3. Would selectively replacing or preserving certain logits affect the accuracy-memory trade-off in existing replay-based methods?

  4. How can the findings be applied to parameter-efficient fine-tuning methods, such as LoRA-based methods?

  5. Does replacing stored logits with fixed constants work across different datasets and settings? The results on TinyImageNet seem less conclusive than those on CIFAR-100. Does this limit the scope of the main claim?

6 comments
AuthorsOpenReview ↗

Practical gains from replay redesign across settings

Thank you for distinguishing an interesting diagnosis from a practically useful contribution. We apologize for the late reply. We understood your central concern to be that the original paper had not shown how its findings improve replay, especially beyond fixed heads. The revision now includes direct tests of those consequences.

Practical consequences (W3, Q2, Q3). Two design changes follow from the diagnosis, and both are tested.

  1. A constraint without stored scores (Section 7, Table 2). The later-class values are replaceable, so the constraint can be built from the head width at storage (four bytes per record), for outputs that did not exist when the record was stored. On a pretrained ViT-B/16 with LoRA and growing heads it improves its parent in all ten planned comparisons:

    • label replay (ER) gains 4.95–9.31 pp, including streams without task boundaries;
    • an ER-ACE-style parent gains 1.32–1.66 pp;
    • replay that already matches stored scores still gains 2.34–4.34 pp.

    On accuracy versus memory: without storing any score, label replay with the constraint closes about 70% of the gap to full stored-logit replay in the ten-task study (CIFAR-100 77.9 → 82.9% against 84.9%; TinyImageNet 70.1 → 79.4% against 83.5%; Table S75). This comparison is descriptive, because the reference uses a preallocated head.

  2. Removing matching when both policies receive correction (Section 6, Figure 4c). Given 500 images, both policies replay 400 and fit task offsets on the other 100. Dropping later-class matching beats keeping it by 2.37 pp [1.83, 2.92] in deployed accuracy and by 4.82 pp within tasks. It also beats replaying all 500 images without correction by 4.19 pp [2.86, 5.52]. The correction needs known task shares.

The same reading also changes how methods compare. Across nine natively trained methods, differences from ER change under task offsets by very different amounts, from 13.40 → 11.11 pp for BiC to 10.88 → −1.69 pp for ER-ACE (Section 8).

W1, Q1. Why each intervention, and Figure 1. The Introduction now derives the design from two obstacles:

  • Deleting part of a target removes its values and the constraint of matching them together, so a constant replacement is needed to tell them apart.
  • All-class accuracy does not show whether within-task discrimination survives, so each model is also read after a task offset and within tasks.

Table 1 pairs each edit with the question it answers. Figure 1 now asks three questions of one stored record (are the stored values needed, is the whole pattern needed, does higher accuracy protect discrimination) and answers each with its comparison.

W2, Q2. Beyond fixed heads and task partitions. Section 7 uses growing heads, a pretrained backbone, and overlapping streams without task identity, class list or stage reset. Section 8 adds nine native methods and a separate teacher. One difference is informative: the within-task price appears in the scratch model, not in the pretrained recipes. What transfers is therefore the design idea, not every scratch behavior. Table 3 states where each claim holds.

Q3. Selectively preserving logits. Keep the three largest non-gold scores of each earlier task at their classes and average the remaining non-gold scores: accuracy approaches Full (Full − Top-3: −0.02 pp [−0.44, 0.40]; descriptive). Three randomly chosen scores recover less, and reassigning the reduced target costs 3.58 pp relative to Top-3 (Section 5). Storage was dense; this identifies a promising compact target, not a measured memory saving or a minimum sufficient structure.

Q4. LoRA. Section 7 is this setting (rank-8 LoRA on ViT-B/16). On the overlapping streams, a dense variant that does not use which outputs came later recovers most of the gain; the largest observed gain from the exact support is 0.45 pp. Dense still uses insertion metadata to set its strength.

Q5. Constants across datasets. The constant −2 meets the ±1 pp margin on CIFAR-100 under DER++ and DER, at three memory sizes, on ResNet-32, and at 5 and 10 tasks; equivalence is not established at 20 tasks.

On TinyImageNet, the original eight-seed study is inconclusive. A follow-up with ten of twelve planned pairs passes the original 90% TOST (p = .019) but not a stricter rule adopted after an interim look. The constant 0 fails, and refreshed targets are an exception (6.4 pp cost under X-DER).

The claim is bounded accordingly: stored later-class values are not needed where equivalence was established, and the level of the constant matters.

We hope these additions address the practical-value gap central to your assessment. We would be grateful for your reconsideration in light of the improvements in Figure 4c and Table 2, and the clearer account of where they apply.

Dear authors,

I appreciate the efforts to address my concerns, particularly the new experiments demonstrating the practical implications and broader applicability of the findings. However, some concerns remain regarding the generality and robustness of the results, particularly on TinyImageNet and in LoRA-based settings. In addition, the manuscript has expanded considerably from 29 to 63 pages without indicating where the changes have been made, making the revision difficult to assess. I acknowledge the improvements, but still have reservations about the strength and generality of the contributions.

Best,

Reviewer 7mYS

Thank you for the follow-up, and for noting that the new experiments demonstrate the practical implications and broader applicability of the findings, which was the main concern of your review. On the two points that remain, the evidence is specific, so we state it directly. Your comment does not say which results you find insufficiently robust, so we end with three short questions that would let us answer exactly.

TinyImageNet: the three core findings replicate.

  • Later-class matching is a correctable bias. Deleting it costs 8.4 pp [7.1, 9.8] (eight seeds). After one task offset the cost is gone (8.3 → −1.1 pp; six pairs, offset cross-fitted on test folds, marked so in Table S22).
  • Class correspondence is needed. Flattening the seen-class scores costs 4.1 pp [3.2, 4.9] and reassigning them 6.1 pp [5.1, 7.1] (four seeds, Table S16), both larger than on CIFAR-100. The reassignment cost stays after the offset (5.9 pp, three pairs).
  • The stored later-class values are not needed. In both studies the constant was at least as accurate as the stored scores on average (Full − constant: −0.65 and −0.03 pp), and both 90% intervals exclude a loss of 1 pp (upper limits 0.18 and 0.69 pp). The shortfall is in the equivalence verdict, not in the constant's accuracy: the first interval, [−1.48, 0.18], crosses the margin on the side where the constant is better. The follow-up (ten of twelve planned pairs) passes the ±1 pp rule used throughout the paper, and not a stricter rule adopted for it after an interim look. Figure 2 and Table 3 report exactly this.
  • The design consequence is largest here. The constraint without stored scores adds 9.3 pp to label replay in both kinds of stream (Table 2).

LoRA (your Q4): ten of ten planned comparisons. You asked how the findings apply to LoRA-based methods. Section 7 applies them directly. On ViT-B/16 with rank-8 LoRA and a growing head, a constraint that reads no stored score (four bytes per record) improved its baseline in all ten planned comparisons, each on eight paired seeds with Holm correction, across three datasets, streams with and without task boundaries, and baselines with and without stored scores (Table 2). Label replay gains 4.95 to 9.31 pp; the smallest gain of all ten is +1.32 pp [0.96, 1.68]. The result does not rest on TinyImageNet, which overlaps the backbone's pretraining data: on CIFAR-100 and ImageNet-R, label replay still gains 4.95 to 5.28 pp. Two limits are stated in the paper: a dense variant recovers most of the gain on overlapping streams, and the within-task price of the scratch model does not appear here.

Why we consider the contribution strong. A deletion ablation ranks the two parts of DER's target in the wrong order, and the paper shows this with matched controls. Deleting later-class matching costs 15 pp and reassigning seen-class scores 4 pp. After one scalar offset the costs are 1.8 and 4.0 pp, and the order reverses on all three backbones. The larger term is thus a bias correction: a constant replaces its stored values, it lowers within-task accuracy by 4.7 pp, and with an equal budget and the same correction, removing it wins by 2.37 pp [1.83, 2.92]. X-DER showed that these scores go stale, and BiC and WA that recency bias is correctable. None of them shows that the main benefit of DER's later-class matching is that correction, that its stored values are unnecessary, or that it has a within-task cost. The same reading changes how methods compare: ER-ACE's 10.9 pp lead over ER becomes −1.7 pp, while X-DER keeps 9.9 pp (Section 8).

Three questions, so that we can answer exactly.

  • On TinyImageNet, which result do you consider not robust: the equivalence verdict for the constant, or one of the effects above (and if so, is the concern the number of seeds)?
  • On LoRA, is the concern the consistency of the gains in Table 2, the single backbone and adapter, or the absence of the within-task price?
  • On strength, is the remaining doubt about effect sizes, about novelty relative to X-DER, BiC and WA, or about a setting we did not test? If a setting, which one?

Where the changes are. We should have marked them. The main text is ten pages (nine before). Appendices A–E (Tables S1–S29) are the original appendix under the same numbering, and all 33 new pages are Appendices F–H. For your points: W1 and Q1 are answered in the Introduction, Figure 1 and Table 1; W2, Q2 and Q4 in Section 7 and Table 2; W3 in Figure 4c; Q3 in Figure 3b; Q5 in Figure 2 and Table 3. A map for all reviews is posted as "Summary of changes".

If these answers resolve your reservations, we would be grateful if your assessment could reflect that.

Reviewer_nSCBOpenReview ↗
Rating
3
Confidence
3
Informativeness
2(−1)
Presentation
3(+1)
Soundness
3(+1)
Read review
Paper summary

The paper asks what logit-replay methods like DER and DER++ actually need to keep in their stored predictions. Each stored score vector is split into classes the model already knew when the example was saved (H) and classes it learned later (N). The authors edit each part separately: they delete the matching on N, replace the N scores with the record’s mean or a fixed constant, or shuffle the non-gold H scores among classes within each task while keeping the same values. Every trained model is checked before and after a single task-level offset that only changes predictions across tasks. On 10-task CIFAR-100 with DER++, deleting N matching costs about 15 points. Replacing the N scores with a constant (a = −2 or −4) works just as well as keeping them, and the offset shrinks the deletion cost to about 2 points. Shuffling the H scores costs about 4 points, and that cost stays after the offset. The authors conclude that N matching mostly corrects bias toward recent classes, while for H it matters which class holds which score. The results hold under DER, on TinyImageNet, at other memory sizes and on ResNet-32, and there’s a similar finding in image distillation.

Critical strengths

A simple, convincing experimental design. Deleting a loss term removes two things at once: the matching itself and the stored values it matches. Separating them with replacements and value-preserving shuffles, then checking how much of each cost survives a bias correction, is a clean idea that I found convincing. The breakdown in Eq. 4 also explains nicely why matching a constant isn’t the same as no supervision. The paper’s advice to pair deletion ablations with replacement and shuffle controls, and to report accuracy before and after bias correction, is practical and should help other replay studies. Careful statistics and good replication. The authors use equivalence tests with a stated ±1 pp margin and split the seeds into two separate sets. In the main cohort they fit the offset on held-out training images, correct for multiple tests where they planned them in advance, and repeat the results across methods, datasets, memory sizes and backbones. They’re also upfront about weaker results, like the TinyImageNet case that only passes their original rule. The ER-ACE result is a nice bonus: the offset almost wipes out ER-ACE’s advantage over ER, while DER and DER++ keep about 5 points.

Critical weaknesses

Some main findings are close to what’s already known, and the setting is narrow. X-DER already argued that the later-class scores are stale and need updating, and work like BiC and WA already showed that much of the class-incremental gap is a fixable bias toward recent tasks. So showing that DER’s N matching mostly works by keeping new-class scores low feels more like a clean confirmation than a new insight. The most surprising result gets less attention than it deserves. Within the true task, deleting N matching is about 5 points better than keeping it, and with per-task offsets it beats Full by 2.4–3.0 points. That suggests N matching actually hurts discrimination and only helps by correcting bias. The setting is also limited: a fixed output head, ResNets trained from scratch, CIFAR-100 and TinyImageNet, and 10 tasks. I’m not sure the conclusions carry over to growing heads, pretrained backbones, or the longer task sequences common in recent work. A few details make the claims harder to read than they should be. -Exactly how the constant was chosen is unclear. The paper tries a = 0, −1, −2 and −4 and reports the two that pass on both seed sets (Table S6). The tests on seeds 9–20 were planned before they ran, which is good. But some constants were added to seeds 1–8 after the first results, so I can’t tell how much the first seed set shaped the final {−2, −4} choice. Also, a = −2 on seeds 1–8 is within the margin but has a small positive cost estimate (90% CI [+0.04, +0.85]). -The key control for H is weaker than it should be. Shuffling H scores also gives the model wrong class relationships, so its cost mixes “losing which class holds which score” with “being taught misleading targets.” The block-mean control that separates the two was run in a separate implementation and is labeled “descriptive only.” The shuffle is also one fixed cyclic shift, not random reorderings. -The offset uses information a real system wouldn’t have. It assumes the last task’s share of classes is known, and several cohorts fit it on the test set using cross-fitting. The main held-out cohort avoids this, but the paper should make clear which results rely on which fitting method.

Questions for authors

1.What level do the stored N scores typically sit at (their record means)? If they’re already close to −2, then the constant a = −2 working well follows almost directly from the record mean working well, which would be worth saying. 2.Table S6 notes that families E–H were planned before their runs. Could you share the dates of those test plans in the supplementary material? Was the decision to also test a = −1 and −4 on seeds 1–8, and to report {−2, −4} in the main text, made before or after the first a = −2 and a = 0 results? 3.Can you run the block-mean control on H in the same implementation and cohort as the H shuffle, and try random within-task reorderings instead of a single cyclic shift? 4.Since deleting N matching is better within tasks, and better than Full with per-task offsets, would you go as far as saying DER’s N matching is mainly a bias-correction trick? Do standard bias corrections like BiC or WA give the same picture as your single offset? 5.Which results use offsets fit on the test set, and do any conclusions change if all of them use held-out training images instead?

1 comment
AuthorsOpenReview ↗

Matched controls and held-out bias correction

Thank you for recognizing the value of the diagnostic design and identifying its gaps. We apologize for the late reply. Your emphasis on within-task discrimination and matched H controls reshaped the revision: both are now central, and the behavioral finding leads to a tested policy change.

Novelty relative to X-DER, BiC and WA. Section 2 acknowledges stale later-class scores (X-DER), correctable recency bias (BiC, WA), and WA's finding that imbalance masks what distillation preserves. Our contribution connects the original-value requirement of a specific replay term to its within-task cost and to tested changes in its use:

  1. Utility without the values. A constant replaces the stored N scores within ±1 pp, while deleting the term costs 15 pp (Section 4).
  2. Two effects of one term. An offset removes most of the deletion gap (14.89 → 1.76 pp), and the term lowers within-task accuracy (−4.02 pp [−4.61, −3.43] when added to label replay matched to DER++; Section 6).
  3. A policy result. Both policies get the same 500 images, each replaying 400 and fitting offsets on 100. Dropping the term beats keeping it by 2.37 pp [1.83, 2.92] in deployed accuracy (one-sided Holm-adjusted p = 1.8×10⁻⁵, positive in all eight seeds) and by 4.82 pp within tasks. As trained it is far worse (20.34% vs 34.00%), so the gain belongs to the corrected policy (Figure 4c).
  4. A construction for learners that store no predictions (Section 7).

Q4. Bias correction, BiC and WA. Your interpretation is supported in the main scratch setting: one task offset removes most of the deletion gap, while the H reassignment cost stays (4.29 → 3.98 pp; Figure 4a).

  • A BiC-form affine correction gives the same picture on two further backbones (deletion 6.06 → −1.48 and 10.60 → −0.57 pp; Table S31).
  • WA-style norm equalization does not recover the deletion loss (Appendix B.5).
  • These are probes on finished models. Natively trained BiC is in the new nine-method comparison: 13.40 pp over ER as trained, including its own correction, and 11.11 pp after offsets (Section 8).

Two qualifications keep it from being only a trick. The matching also lowers within-task accuracy, which no offset can undo; and a penalty on the block mean alone does not reproduce its benefit, so the form of the constraint matters. In pretrained recipes the constructed constraint shows no within-task loss (Table S76).

Q1. Level of stored N scores. Over 20 seeds and 200 boundary snapshots, the record mean is −0.66 logits with a within-record RMS of 0.34. So −2 is not a copy of the natural level: the level of the reference matters; the stored values do not.

Q2. Chronology of the constants. Appendix A.2 gives timestamps:

  • The initial plan (22 Sep, about 20:30 UTC) specified 0 and −2 on seeds 1–8; −2 was informed by a separate development run.
  • −1 and −4 were added after those results (23 Sep, about 01:00 UTC).
  • The tests on seeds 9–20 were fixed between 03:43 and 05:47 UTC that day, before those seeds ran.

Highlighting {−2, −4} is a post-hoc choice, and Section 4 says so. −2 on seeds 1–8 has a small positive cost inside the margin (+0.44 [0.04, 0.85]).

Q3. Block mean and random reorderings in one setup. Done: Full, Flattened (block mean), Reassigned (random per record) and two variants on 20 paired seeds in one implementation, each arm with its own memory. All three prespecified contrasts pass after one offset:

  • Full − Flattened 2.61 [2.29, 2.92];
  • Full − Reassigned 3.52 [3.17, 3.86];
  • Flattened − Reassigned 0.91 [0.57, 1.26].

So losing the pattern is costly on its own, and wrong class relations add to that cost. A flat target is still an edited target, so we read these as two measured edits, not a pure decomposition. In a follow-up, retaining the three largest non-gold scores per earlier task and averaging the rest approaches Full (Full − Top-3: −0.02 [−0.44, 0.40]; descriptive); reassigning that reduced target costs 3.58 [3.08, 4.07] relative to Top-3 (Section 5).

Q5. Test-fitted offsets. Every main-text offset now uses training images withheld before training. The earlier test-fitted analyses remain in the appendix with their original fitting labels (Table S61, Figure S4). Held-out fitting supports the central contrast: 14.89 → 1.76 pp for deletion and 4.29 → 3.98 pp for reassignment. In the held-out nine-method comparison, ER-ACE's advantage over ER disappears under the offsets, while DER++ keeps part of its advantage.

Setting. Section 7 covers growing heads, a pretrained ViT/LoRA backbone and streams without task boundaries; 20 tasks are covered in Appendix C. Table 3 states where each claim holds.

We would be grateful for your reassessment in light of the matched controls and the equal-resource policy result (Figures 3–4), both prompted by your review.

Reviewer_pWkYOpenReview ↗
Rating
2(+1)
Confidence
3
Informativeness
1
Presentation
1
Soundness
1
Read review
Paper summary

Among traditional CL methods, memory-based ones are the ones with the best performance. These methods consist of storing samples from previous experiences to use them during training on the new task. DER and DER++ store not only samples but their logits to help mitigate the drift of the output from previous samples. This paper analyses the phenomenon of removing and modifying the matching between ground truth and their samples, showing how performance decreases based on different experiments. Experimenting with the ResNet model and CIFAR100 and TinyImageNet as benchmarks, the paper shows multiple analyses and results.

Critical strengths

To correctly train with a memory, it is important to understand how the samples can affect future performance in both new and old tasks. There have been studies on which samples are better to be added to the memory (an area called Storage policies) and how different methods may benefit different benchmarks and scenarios. This also touches on the idea of identifying which samples to replace with samples from new data. However, the idea of modifying the memory and studying its effect on performance is something new.

  • Although it is new, and may be interesting to analyse potential ways of better storing samples, the motivation is not completely clear in the paper. Why might this study be relevant? How can it impact future research in the area?
Critical weaknesses

The paper lacks a clear story and motivation, and the writing is generally poor. The paper is very hard to follow, from the introduction through the methodology to the results. It is unclear why we would want to modify the memory, how it is modified, and what effect the modification has.

Questions for authors
  • Why deleting or modifying samples from the memory is relevant to understanding its properties? What are the main conclusions about what type of data is relevant to keep? How do these analyses compare to storage policy papers?
  • When proposing an analysis of some methodologies, it is important to study them completely. Why focus the experiment only on a few small benchmarks and hyperparameters? For example, how does the number of tasks affect the analysis? Or how does the memory size (which seems very relevant) affect the results?
  • Is there a way to expand this analysis to other memory-based methods that do not use logits?
  • One argument mentioned in Section 3 is that samples from classes in a batch may modify the classifier weights of other classes. A very common approach to avoid that is freezing the weights of the classes not present in the batch. How could this affect the analysis?
  • In line 172. What does a block mean? And how are the logits represented in Eq. 3?
  • What does a preallocated ResNet mean?
  • In line 362, what is a “terminal memory”?
6 comments
AuthorsOpenReview ↗

What logit replay stores and why the target edits matter

Thank you for identifying where our explanation failed. We apologize for the late reply and for the effort needed to follow the original paper. Your questions made clear that we had not explained either what is edited or why those edits matter. We have reorganized the revision around both.

What is edited. In logit replay (DER, DER++), each memory slot holds an image, its ground-truth label, and the scores (logits) an earlier model gave that image when it was stored. Later the model is trained to reproduce those scores, so they act as a distillation target, separate from the label. We edit only this target, or remove the loss term that matches it. Images and labels are never changed (Section 3.1, Table 1, Figure 1).

Why it matters, and for future research. A stored prediction is written at one moment of learning, but the later model must reproduce all of it, including scores for classes the earlier model had never seen. Knowing which parts of that requirement help tells us what replay needs to store and how its supervision can be built. The answer changes practice in two tested ways. The useful constraint can be built without storing any scores. And with the same 500 images and the same correction after training, a learner without later-class matching is more accurate overall (+2.37 percentage points (pp) [1.83, 2.92]) and within tasks (+4.82 pp) (Sections 6–7). It also changes evaluation: a term can raise all-class accuracy while lowering within-task accuracy (Sections 6, 8).

Q1. Relevance, what to keep, and storage policies. Editing the target is how we test what each part contributes: a constant replacement separates "the term helps" from "its values are needed". Storage policies choose which examples enter memory; we hold the examples fixed and ask which supervision attached to them is needed. The two are complementary (Section 2). What to keep, in the settings tested:

  • Scores of classes seen at storage: which class holds which value. Flattening them costs 2.61 pp and reassigning them 3.52 pp after a task offset (20 paired seeds). Keeping the three largest non-gold scores per earlier task at their classes and averaging the rest comes close to Full (Full − Top-3: −0.02 pp [−0.44, 0.40]; descriptive). Reassigning that reduced target costs 3.58 pp relative to Top-3 (Section 5, Figure 3).
  • Scores of classes introduced after storage: not their values. A constant in their place stays within ±1 pp of the full target (Section 4, Figure 2).

Q2. Tasks, memory, benchmarks, hyperparameters.

  • Tasks: at 5, 10 and 20 tasks, deleting later-class matching costs 13.2, 14.6 and 13.4 pp. The constant is equivalent at 5 and 10 tasks; equivalence is not established at 20 (Table 3).
  • Memory: at 200, 500 and 2,000 exemplars the deletion cost is 9.1, 15.2 and 11.7 pp. The constant −2 stays within the margin at all three, and reassigning seen-class scores costs 2.6, 4.7 and 3.7 pp.
  • Benchmarks: besides scratch CIFAR-100 and TinyImageNet, Section 7 uses a pretrained ViT-B/16 with LoRA on CIFAR-100, TinyImageNet and ImageNet-R, and Section 8 compares nine natively trained replay methods.
  • Hyperparameters: every cohort states its coefficients; an incomplete sweep of DER++'s two coefficients is not reported.

Q3. Methods that do not store logits. Yes, and this is now a main result. Because the later-class values are replaceable, the constraint can be built from the head width when each record was stored (four bytes per record). On a pretrained ViT/LoRA learner with a growing head it improves its parent in all ten planned comparisons: label replay (ER) gains 4.95–9.31 pp, including streams without task boundaries; an ER-ACE-style rule 1.32–1.66 pp; and replay that also matches stored scores still 2.34–4.34 pp (Section 7, Table 2).

Q4. Freezing classifier rows of absent classes. We ran this on eight paired seeds. With freezing, deleting later-class matching still costs 12.55 pp [11.04, 14.06]. Freezing reduces that cost by 2.64 pp [1.45, 3.83], and frozen DER++ itself loses 2.78 pp. A frozen row does not freeze the class's output, which still moves with the shared features (Table S40).

Q5–Q7. Definitions. All three are now defined in Section 3 before first use.

  • A block is a set of class indices within one score vector, such as the classes of one task. Equation 2 writes the stored and current scores on a block as a mean plus a zero-mean remainder; this shows why a constant target differs from deleting the term.
  • A preallocated head has one output for every benchmark class from the start, so each stored vector has scores even for classes not yet introduced.
  • Terminal memory meant the buffer at the end of training; we removed it from the main text.

We hope Figure 1, Table 1 and the tested design consequences now make the question and its value clear. We would be grateful for your reassessment of the revised paper.

Dear Authors,

Thanks for your response and for the modifications to the paper.

I saw that the paper has changed drastically, with around 20 additional pages, more experiments and figures, and even a new abstract. Despite the improvements, I still struggle to understand the contribution of the proposal, both because of the writing style and the proposed methodology. Could you write a short paragraph, in simple terms, about the contribution and conclusions? What should the community take away from the paper?

I do not understand how Section 7 answers my question about common replay strategies. Adding LoRA approaches is not needed and may obscure the conclusions. The question about memory size is related to my question about replay practices without scores. With a larger memory size, one can assume that forgetting will decrease, and methods that use scores will become irrelevant to training, because replaying is enough to maintain performance. Can we see something like that with the proposed methodology? Or can the methodology show the opposite?

In Figure 2, what does “seed” mean? Why split the seed into two batches? Where is “a” represented in the new Eq. 2? The major changes to the paper make it difficult to review the latest version and to check whether my original questions have been addressed. This new version would require a new review phase, which I do not think is the objective of the rebuttal.

Thank you for reading the revision carefully and for telling us plainly what is still unclear. This reply is self-contained; there is no need to re-read the paper.

The paper in simple terms. DER and DER++ store, with each image, the scores (logits) the model gave it at that time, and later train the model to reproduce them. We ask which part of these stored scores is really needed. To find out, we change one part of the scores at a time and retrain; images and labels are never changed. This is an analysis, not a new method. The answer is that the stored scores do two different jobs.

  • Scores of classes the model had not yet seen at storage do not need to be stored at all. A fixed low number in their place gives the same accuracy (within one point). Reproducing them helps because it keeps new-class scores low, which reduces the bias toward recent classes.
  • Scores of classes it had already learned are real knowledge: which class received which value. If we scramble them, accuracy drops, and no bias correction we tried brings it back.

Why this is not obvious. The usual way to judge a part of a method is to delete it and measure the loss. Here that test gives the wrong answer. Deleting the first part costs 15 points and scrambling the second costs 4, so the first looks more than three times as important. The truth is the reverse. One number applied after training recovers 13 of the 15 points and almost none of the 4. Reproducing the first part even makes old classes harder to tell apart (4.7 points within a task), and when both models receive the same correction, the model trained without it is the better one (+2.4 points). Earlier work knew that such scores become outdated (X-DER) and that recency bias can be corrected (BiC, WA). It had not shown that the largest benefit of stored scores is this bias correction, that their values can be replaced by a constant, or that reproducing them has a hidden cost. Showing this takes controls that a deletion test does not have: a constant in place of the scores, a correction that cannot change predictions within a task, and paired runs with equivalence tests.

What the community can take away. (1) Store the class pattern of the learned classes; the rest of the score vector need not be stored. (2) The bias-correcting part can be built without stored scores, so plain replay of images and labels can use it too. (3) Compare replay methods after a bias correction as well: ER-ACE's 10.9-point lead over ER disappears under it.

Section 7 and replay without scores. Section 7 compares ordinary replay of images and labels (ER) with the same ER plus one extra loss that uses no stored scores. This is take-away (2), and it answers your original question about methods that store no logits: ER improves by 5 to 9 points in all five comparisons (Table 2). LoRA is not our proposal. It is only the model trained in that section, a pretrained ViT, included because Reviewer 7mYS asked. Without LoRA, on the ResNet trained from scratch, label replay with DER++'s settings gains 6.6 points (Figure 4b); with ER's default settings the gain is smaller and not significant (+1.3).

Larger memory. This is a separate question from Section 7, and our data answer part of it.

  • At 500 images and the same training recipe, DER++ is 14.2 points above plain replay as trained and 3.2 points above after the same bias correction on both (41.9% vs 38.7%; Table S67). Plain replay does not catch up at this size, but most of the gap disappears under the correction.
  • From 200 to 2,000 images, scrambling the learned-class scores costs less, but still a lot: 13.3, 11.9 and 8.6 points of within-task accuracy (Table S18).

So your expectation leaves a visible trace (the cost declines as memory grows), yet at 2,000 images the scores are far from irrelevant. We did not train plain replay at 200 and 2,000 images, so the size at which the two meet remains open.

Figure 2 and Eq. 2.

  • A seed is one independent repetition of the whole experiment, with its own random class order and initialization. All variants within a seed share these and are compared in pairs.
  • Two groups of seeds: we first tried the constants on seeds 1–8. The twelve new seeds (9–20), with tests fixed in advance, check that each result repeats. A constant counts only if it passes in both groups.
  • a is the fixed number written in place of the stored later-class scores. With it, Eq. 2 becomes (α/K) Σ_j (z_j − a)², which pulls each of those scores toward a.

All three are now stated in the paper where you looked for them.

Size of the revision. We understand the concern and do not ask for a new review. The question, the method and the two findings above are those of the original submission. The main text is ten pages, Appendices A–E are the original appendix, and the new records are in Appendices F–H. A map is posted for all reviewers as "Summary of changes".

Comments on the paper

1 comment
AuthorsOpenReview ↗

Summary of changes: what is unchanged, what was added, and where

Two reviewers noted that the revision is hard to assess because we did not mark what changed. That was our omission, and we apologize. This note says what the paper shows, what is unchanged, what was added and why, and where to find each item.

The paper in brief. Logit replay stores a model's past scores and trains later models to reproduce them. The usual test of such a target, deleting part of it, misleads here. In the main setting (CIFAR-100, DER++), deleting the scores of classes not yet seen at storage costs 15 pp, yet a constant can replace their values, one offset after training recovers 13 of the 15 pp, and matching them lowers within-task accuracy. Disturbing the scores of classes already learned costs less (about 4 pp), yet that cost survives every correction we tried, because it matters which class holds which value. Replay therefore needs to preserve class correspondence, not every stored value. This is an analysis with two tested design consequences, not a new method.

Size. The main text went from nine to ten pages, the limit for revisions, and is self-contained. Appendices A–E, with Tables S1–S29, are the original appendix under the same numbering; only the timeline of the constants was added to A.2. The other 33 added pages are Appendices F–H (Tables S30–S80): the protocols and per-seed records of the additions below, there for checking.

Unchanged from the original submission. The title and question; the method (edit the stored target, retrain, read accuracy before and after a task offset); and the core results above, which were Sections 4.1–4.3 of the original and are Sections 4–6 now.

The three additions that carry most weight.

  • Figure 3a: flattening and random reassignment in one 20-seed implementation. This separates the two effects that the original shuffle mixed: flattening alone costs 2.61 pp, and reassignment adds 0.91 pp [0.57, 1.26] (AC 4; nSCB Q3).
  • Figure 4c: two policies with the same 500 images and the same correction. Removing later-class matching raises all-class accuracy by 2.37 pp [1.83, 2.92] and within-task accuracy by 4.82 pp (AC 7; nSCB; 7mYS W3).
  • Table 2: a constraint that reads no stored score improves ViT/LoRA learners with growing heads in ten of ten planned comparisons, including replay that stores only images and labels (AC 6; 7mYS W2, Q2, Q4; pWkY Q3).

Other additions.

  • What is edited and why: Abstract, Introduction, Figure 1, Table 1 (AC 1; pWkY; 7mYS W1).
  • Timeline of the constants and level of the stored scores: Section 4, Appendix A.2 (AC 3; nSCB Q1–Q2).
  • Keeping only the leading scores: Section 5, Figure 3b (7mYS Q3).
  • Held-out fitting for all main-text offsets, with BiC-form and WA-style corrections: Sections 3.3 and 6, Figure 4a (AC 2, 5; nSCB Q4–Q5).
  • Nine natively trained replay methods: Section 8, Figure 5a (AC 2).
  • Scope of each claim: Table 3 (AC 6; 7mYS Q5).
  • Frozen classifier rows: Table S40 (pWkY Q4).

Since the 12 November upload we edited about a dozen sentences of the main text for clarity, following the two follow-ups: where the constant a enters Eq. 2 and what a seed is (Section 3), why Figure 2 has two groups of seeds (its caption), the sentences that close the Introduction, and the opening of Section 7. Section 6 now also quotes one comparison from Table S22. No result, figure or table changed, and the appendix is untouched.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.