IDER: Idempotent Experience Replay in Continual Learning

• The paper introduces a rehearsal-based approach that applies an idempotence constraint to maintain consistent model outputs and mitigate catastrophic forgetting.
• IDER leverages an idempotence distillation loss between current predictions and a frozen checkpoint to enhance calibration and control drift.
• Empirical results on CIFAR benchmarks demonstrate that integrating IDER with replay methods increases accuracy and reduces forgetting with minimal extra overhead.

Searching arXiv for the specified paper and closely related continual-learning replay work to ground the article. Idempotent Experience Replay (IDER) is a rehearsal-based continual learning method that injects the algebraic principle of idempotence into replay training in order to address catastrophic forgetting while improving predictive reliability and calibration. In the formulation introduced by Liu et al., the network is trained so that repeated application of its own output leaves that output unchanged, and this self-consistency is coupled to a frozen checkpoint from the previous task through an idempotence distillation loss (Liu et al., 28 Feb 2026). The method is positioned against two concurrent pressures in continual learning: maintaining past knowledge under sequential task updates, and producing calibrated confidence estimates in mission-critical settings without the high computational overhead and replay incompatibility attributed to existing uncertainty-aware continual learning approaches.

1. Problem setting and conceptual motivation

Catastrophic forgetting is described as the tendency of neural networks to forget previously learned knowledge when learning new tasks. Within continual learning, replay-based methods mitigate this effect by storing and revisiting past examples, but the paper argues that reliable deployment also requires uncertainty awareness, specifically calibration of predictive confidences. IDER is proposed as a response to the stated limitation that existing uncertainty-aware continual learning methods suffer from high computational overhead and incompatibility with mainstream replay methods (Liu et al., 28 Feb 2026).

The central conceptual move is to reinterpret replay through an idempotent lens. Rather than only requiring that the model classify current and buffered samples correctly, IDER requires that the model’s output be stable when fed back into the model itself, and that this stability remain compatible with the behavior of an earlier checkpoint. The exposition motivates this with three desiderata. First, self-consistency: if the model’s own prediction is stable under a second forward pass, its confidence estimates tend to be better calibrated. Second, drift control: repeated applications map examples into a “stable manifold,” preventing decision-boundary shifts when learning new tasks. Third, forgetting mitigation: enforcing idempotence on replayed data helps anchor the current model to its previous state, thereby regularizing against forgetting.

This framing places IDER within replay-based continual learning, but not as a replacement for replay. Instead, it is designed as an add-on principle that can be imposed on top of replay baselines.

2. Idempotence as a continual-learning constraint

The algebraic definition used in the paper is standard: a function $f$ is idempotent if

$f(f(x)) \;=\; f(x)\quad\forall\,x.$

In continual learning, the network is written as a task-indexed function $f_t(x,z)$ taking an input $x$ and an auxiliary label signal $z\in\{\text{one-hot }y,\;\text{empty (uniform)}\}$. The continual-learning-specific idempotence condition is imposed with respect to the second argument: $$f_t\bigl(x,\;f_t(x,z)\bigr)\;=\;f_t(x,z)\quad\forall\,x,z.$$

This definition is not merely a restatement of repeated inference. It changes the object being learned: the model is trained to accept either a one-hot label signal or an “empty” uniform signal, produce a first-pass output, and then remain stable when that output is supplied again as the auxiliary input. During task $t$, the desired behavior on current data $\{(x,y)\}\sim T_t$ is stated as

$$f_t(x,0)\approx y,\quad f_t(x,y)\approx y \;\Longrightarrow\; f_t\bigl(x,f_t(x,0)\bigr)\approx f_t(x,0).$$

A plausible implication is that the model’s output distribution becomes a fixed point of its own update rule on the second input channel. The exposition, however, makes the operational claim more specifically: this stability is intended to support calibration, reduce drift, and preserve past knowledge through replay.

3. Loss construction: standard idempotence and distillation

IDER is built from two losses. The first is the Standard Idempotent Module loss, denoted $\mathcal{L}_\mathrm{ice}$, which enforces idempotence on the current data stream: $f(f(x)) \;=\; f(x)\quad\forall\,x.$0 Here $f(f(x)) \;=\; f(x)\quad\forall\,x.$1 is the cross-entropy. The first term enforces ordinary supervised learning under the auxiliary input $f(f(x)) \;=\; f(x)\quad\forall\,x.$2, while the second term requires that a second pass through the model remain label-consistent.

The second term is the Idempotence Distillation Module loss, denoted $f(f(x)) \;=\; f(x)\quad\forall\,x.$3. The exposition first notes a naive idempotence loss on the union of current-task data and buffer,

$f(f(x)) \;=\; f(x)\quad\forall\,x.$4

but explicitly states that this can reinforce errors if $f(f(x)) \;=\; f(x)\quad\forall\,x.$5 is wrong. To avoid that failure mode, the previous-task checkpoint $f(f(x)) \;=\; f(x)\quad\forall\,x.$6 is frozen, and the distillation loss is defined as

$f(f(x)) \;=\; f(x)\quad\forall\,x.$7

The paper’s interpretation is that the current model’s first-pass output $f(f(x)) \;=\; f(x)\quad\forall\,x.$8 is aligned with how the old model $f(f(x)) \;=\; f(x)\quad\forall\,x.$9 would process that output. This couples current predictions to a prior checkpoint without requiring direct replication of all old outputs. In the paper’s terminology, the standard idempotent module promotes self-consistency on the current stream, while idempotence distillation preserves past knowledge and self-consistency under task transitions (Liu et al., 28 Feb 2026).

4. Training procedure and replay integration

The algorithmic outline is specified for tasks $f_t(x,z)$0 using a fixed-size reservoir buffer $f_t(x,z)$1. At the start of each task, the previous checkpoint is copied and frozen, $f_t(x,z)$2 previous checkpoint, and the current model is initialized from it, $f_t(x,z)$3, or warm-started. Training then proceeds over epochs or minibatches from the current task $f_t(x,z)$4.

For each minibatch, current-task samples $f_t(x,z)$5 are used to compute $f_t(x,z)$6 via two forward passes of $f_t(x,z)$7. Buffered samples $f_t(x,z)$8 are then drawn from $f_t(x,z)$9 and used to compute $x$0 by forwarding $x$1 through $x$2 once and then through $x$3. An optional replay term is also defined: $x$4 The parameters of $x$5 are updated by minimizing

$x$6

After optimization, a subset of current-task examples is inserted into $x$7 via reservoir sampling, and the checkpoint $x$8 is saved for the next task. This makes IDER structurally compatible with rehearsal workflows that already maintain a memory buffer.

The paper emphasizes that the method is plug-and-play: the two losses can be added to replay baselines including ER, DER, CLS-ER, BFP, and SARL. One reported example is an FAA increase for CLS-ER+IDER from $x$9 to $z\in\{\text{one-hot }y,\;\text{empty (uniform)}\}$0 on CIFAR-100 with buffer $z\in\{\text{one-hot }y,\;\text{empty (uniform)}\}$1 (Liu et al., 28 Feb 2026). This characterization is important because IDER is not introduced as a wholly separate family of continual-learning algorithms; it is formulated as a reliability-oriented augmentation to replay.

5. Benchmarks, metrics, and reported empirical behavior

The experimental protocol covers single-pass continual learning without task IDs at test time. The listed datasets are Split-CIFAR-10 with $z\in\{\text{one-hot }y,\;\text{empty (uniform)}\}$2 tasks $z\in\{\text{one-hot }y,\;\text{empty (uniform)}\}$3 $z\in\{\text{one-hot }y,\;\text{empty (uniform)}\}$4 classes and $z\in\{\text{one-hot }y,\;\text{empty (uniform)}\}$5 train / $z\in\{\text{one-hot }y,\;\text{empty (uniform)}\}$6 test images per class; Split-CIFAR-100 with $z\in\{\text{one-hot }y,\;\text{empty (uniform)}\}$7 tasks $z\in\{\text{one-hot }y,\;\text{empty (uniform)}\}$8 $z\in\{\text{one-hot }y,\;\text{empty (uniform)}\}$9 classes and $$f_t\bigl(x,\;f_t(x,z)\bigr)\;=\;f_t(x,z)\quad\forall\,x,z.$$0 images per class; Split-TinyImageNet with $$f_t\bigl(x,\;f_t(x,z)\bigr)\;=\;f_t(x,z)\quad\forall\,x,z.$$1 tasks $$f_t\bigl(x,\;f_t(x,z)\bigr)\;=\;f_t(x,z)\quad\forall\,x,z.$$2 $$f_t\bigl(x,\;f_t(x,z)\bigr)\;=\;f_t(x,z)\quad\forall\,x,z.$$3 classes and $$f_t\bigl(x,\;f_t(x,z)\bigr)\;=\;f_t(x,z)\quad\forall\,x,z.$$4 train/val/test images; and a generalized CIL variant on CIFAR-100 in which task lengths vary, classes may reappear, and tasks are imbalanced. The reported metrics are Final Average Accuracy (FAA), Final Forgetting (FF), and Expected Calibration Error (ECE), with lower values preferred for FF and ECE (Liu et al., 28 Feb 2026).

The paper reports that IDER consistently improves prediction reliability while simultaneously boosting accuracy and reducing forgetting. Representative numbers are summarized below.

Setting	Baseline	With IDER
Split-CIFAR-10, FAA, buffer 200	ER: $$f_t\bigl(x,\;f_t(x,z)\bigr)\;=\;f_t(x,z)\quad\forall\,x,z.$$5	ER + IDER: $$f_t\bigl(x,\;f_t(x,z)\bigr)\;=\;f_t(x,z)\quad\forall\,x,z.$$6
Split-CIFAR-100, FAA, buffer 500	BFP: $$f_t\bigl(x,\;f_t(x,z)\bigr)\;=\;f_t(x,z)\quad\forall\,x,z.$$7	BFP + IDER: $$f_t\bigl(x,\;f_t(x,z)\bigr)\;=\;f_t(x,z)\quad\forall\,x,z.$$8
GCIL CIFAR-100, FAA, buffer 200	DER++: $$f_t\bigl(x,\;f_t(x,z)\bigr)\;=\;f_t(x,z)\quad\forall\,x,z.$$9	ER + IDER: $t$0
CIFAR-10, ECE, buffer 200	ER: $t$1	ER + IDER: $t$2
CIFAR-100, ECE, buffer 500	ER: $t$3	ER + IDER: $t$4
CIFAR-100, FF, buffer 500	ER: $t$5	ER + IDER: $t$6

In the summary statistics, the paper also states that ER’s FAA increases from $t$7 to $t$8 on CIFAR-100 with buffer $t$9, ER’s ECE reduces from approximately $\{(x,y)\}\sim T_t$0 to approximately $\{(x,y)\}\sim T_t$1, and DER’s ECE reduces from approximately $\{(x,y)\}\sim T_t$2 to approximately $\{(x,y)\}\sim T_t$3. For GCIL on CIFAR-100, ER’s FAA rises from $\{(x,y)\}\sim T_t$4 to $\{(x,y)\}\sim T_t$5. On forgetting, Table 7 lists XDER at $\{(x,y)\}\sim T_t$6 FF and ER + IDER at $\{(x,y)\}\sim T_t$7 FF on CIFAR-100 with buffer $\{(x,y)\}\sim T_t$8; the accompanying note makes the intended comparison explicit by stating that IDER reduces forgetting relative to ER’s $\{(x,y)\}\sim T_t$9 down to $$f_t(x,0)\approx y,\quad f_t(x,y)\approx y \;\Longrightarrow\; f_t\bigl(x,f_t(x,0)\bigr)\approx f_t(x,0).$$0. The figures support these claims with FAA/ECE/parameter comparisons against DER and NPCL (Fig. 1), taskwise accuracy curves (Fig. 6), runtime and forgetting analyses (Fig. 7), and a top-5 prediction visualization indicating recency bias correction (Fig. 8).

6. Overhead, ablations, limitations, and open directions

IDER is presented as computationally light relative to uncertainty-aware continual-learning alternatives. The reported overhead is one extra forward pass per example on current and buffer data, with no new large modules. For a ResNet-18 backbone, parameter count increases from $$f_t(x,0)\approx y,\quad f_t(x,y)\approx y \;\Longrightarrow\; f_t\bigl(x,f_t(x,0)\bigr)\approx f_t(x,0).$$1 M to $$f_t(x,0)\approx y,\quad f_t(x,y)\approx y \;\Longrightarrow\; f_t\bigl(x,f_t(x,0)\bigr)\approx f_t(x,0).$$2 M due to the added linear layer for the second input. Runtime in Fig. 7(a) is described as $$f_t(x,0)\approx y,\quad f_t(x,y)\approx y \;\Longrightarrow\; f_t\bigl(x,f_t(x,0)\bigr)\approx f_t(x,0).$$3–$$f_t(x,0)\approx y,\quad f_t(x,y)\approx y \;\Longrightarrow\; f_t\bigl(x,f_t(x,0)\bigr)\approx f_t(x,0).$$4 slower than DER++ but $$f_t(x,0)\approx y,\quad f_t(x,y)\approx y \;\Longrightarrow\; f_t\bigl(x,f_t(x,0)\bigr)\approx f_t(x,0).$$5 faster than X-DER, and still practical on a single GPU/TPU (Liu et al., 28 Feb 2026).

The ablation results clarify which components are doing the work. On CIFAR-100 with buffer $$f_t(x,0)\approx y,\quad f_t(x,y)\approx y \;\Longrightarrow\; f_t\bigl(x,f_t(x,0)\bigr)\approx f_t(x,0).$$6, Table 8 reports that the Standard Idempotent Module alone yields no FAA gain over ER, whereas Standard Idempotent Module plus Idempotent Distillation yields the full $$f_t(x,0)\approx y,\quad f_t(x,y)\approx y \;\Longrightarrow\; f_t\bigl(x,f_t(x,0)\bigr)\approx f_t(x,0).$$7 pp gain. A common misconception would therefore be to treat current-stream self-consistency as sufficient; the paper’s own ablation indicates that checkpoint-mediated distillation is the critical component.

Hyperparameter sensitivity is reported as relatively stable. For $$f_t(x,0)\approx y,\quad f_t(x,y)\approx y \;\Longrightarrow\; f_t\bigl(x,f_t(x,0)\bigr)\approx f_t(x,0).$$8 and $$f_t(x,0)\approx y,\quad f_t(x,y)\approx y \;\Longrightarrow\; f_t\bigl(x,f_t(x,0)\bigr)\approx f_t(x,0).$$9 in $\mathcal{L}_\mathrm{ice}$0, FAA remains in $\mathcal{L}_\mathrm{ice}$1. The empty-signal probability $\mathcal{L}_\mathrm{ice}$2 is reported as best at $\mathcal{L}_\mathrm{ice}$3, although $\mathcal{L}_\mathrm{ice}$4, corresponding to always using the uniform signal, still gives approximately $\mathcal{L}_\mathrm{ice}$5 FAA. These results suggest that the method does not depend on unusually narrow settings of its principal weights.

The limitations are stated explicitly. The current implementation is described as “naïve” and straightforward; richer distillation pathways or learned second-input encoders may further boost performance. The exposition also identifies exploration of idempotence in sample selection for buffer construction and extension beyond image classification, including RL and language, as promising directions. Finally, the theoretical analysis of idempotent manifolds in high dimension remains open. Taken together, these limitations locate IDER as a practically effective but not theoretically exhausted proposal: its empirical recipe is concrete, while its broader geometric and cross-domain implications are left for future work.