Continuity Self-Refinement Module

• Continuity Self-Refinement Module is a mechanism within DSR that maintains stable class geometries by self-augmenting low-dimensional prototypes and refining high-dimensional ones.
• It employs dual-prototype representations and generates controlled pseudo-examples to update prototypes without buffering raw data, effectively mitigating catastrophic forgetting.
• The module uses a bi-level optimization process that alternates between a closed-form inner update and a lightweight outer projection refinement, ensuring efficient online adaptation.

Searching arXiv for the specified papers and closely related work on self-refinement and refinement modules. The continuity self-refinement module is a subroutine within the Dual-prototype Self-augment and Refinement (DSR) framework for Non-exemplar Online Class-incremental continual Learning (NO-CL). In that setting, the objective is to preserve the discernibility of base classes without buffering data examples while learning novel classes continuously in a single-pass online data stream. The module operates by self-augmenting low-dimensional class prototypes, refining associated high-dimensional prototypes through a bi-level optimization procedure, and adapting a lightweight projection module while keeping the backbone fixed. Its stated role is to preserve continuity in the representation, mitigate catastrophic forgetting, and avoid exemplar replay (Huo et al., 2023).

1. Problem setting and functional role

Within DSR, continuity self-refinement addresses two difficulties of NO-CL. First, both base and novel classes suffer from severe catastrophic forgetting because no previous samples are available for replay. Second, because online data can only be observed once, there is no way to fully re-train the whole model, for example by re-calibrating decision boundaries via prototype alignment or feature distillation (Huo et al., 2023).

The subroutine is therefore designed as a lightweight online update rule rather than a full-network retraining mechanism. It is embedded in a framework with two stated strategies: dual class prototypes, consisting of vanilla and high-dimensional prototypes, and self-augment and refinement, in which high-dimensional prototypes are optimized alternatively with an extra projection module based on self-augment vanilla prototypes. The resulting procedure is explicitly formulated as a bi-level optimization problem.

A common misunderstanding is to treat this module as a replay substitute that reconstructs past datasets. The description is narrower. It stores and updates class prototypes rather than raw data, and it uses noisy pseudo-embeddings generated from the vanilla prototypes. This suggests that its notion of continuity is representational rather than sample-level: the method attempts to maintain a stable class geometry under strictly online updates.

2. Dual-prototype representation

The module maintains, for each seen class $c$, two class prototypes (Huo et al., 2023).

Prototype	Definition	Stated role
Vanilla prototype $\mu^c \in \mathbb{R}^d$	Mean of the low-dimensional embedding from $\mathrm{Proj}_{vp}(\theta_1(x))$	Used to self-augment pseudo-examples
High-dimensional prototype $h^c \in \mathbb{R}^D$	Mean of $\mathrm{Proj}_{hp}(\theta_2(\theta_1(x)))$ in a hyperdimensional space	Continually adjusted during self-refinement

The vanilla prototype is defined as

$$\mu^c = \frac{1}{|\mathcal{D}_c|} \sum_{(x,y)\in\mathcal{D}_c} \mathrm{Proj}_{vp}\bigl(\theta_1(x)\bigr).$$

The high-dimensional prototype is initialized at the start of an incremental session as

$$h^c = \frac{1}{|\mathcal{D}_c|} \sum_{(x,y)\in\mathcal{D}_c} \mathrm{Proj}_{hp}\bigl(\theta_2(\theta_1(x))\bigr).$$

The text characterizes the high-dimensional space as “much larger,” with the example $D=2048$. In the abstract, the use of vanilla and high-dimensional prototypes is motivated by the need to exploit pre-trained information and obtain robust quasi-orthogonal representations rather than example buffers, with privacy preservation and memory reduction explicitly cited as consequences. The continuity self-refinement routine acts primarily on $h^c$, not on the frozen backbone representation.

3. Self-augmentation and pseudo-example generation

The first stage of the subroutine is self-augmentation from the vanilla prototypes. At the start of each incremental online minibatch, the method hallucinates $K$ pseudo-embeddings for each class $\mu^c \in \mathbb{R}^d$0 by adding controlled Gaussian noise around $\mu^c \in \mathbb{R}^d$1 (Huo et al., 2023): $\mu^c \in \mathbb{R}^d$2

The description gives $\mu^c \in \mathbb{R}^d$3 in practice. Each pseudo-point is then lifted through the projection module: $\mu^c \in \mathbb{R}^d$4

A self-augment loss is defined to make these pseudo-points recognizable as class $\mu^c \in \mathbb{R}^d$5, using cross-entropy classification on the hyperdimensional features: $\mu^c \in \mathbb{R}^d$6 where $\mu^c \in \mathbb{R}^d$7 is the final linear classifier head and is frozen during self-refinement. The formulation also states that $\mu^c \in \mathbb{R}^d$8 may be replaced by a supervised-contrastive term exactly as in the SCR setup.

Conceptually, this stage supplies synthetic local support around each class mean without retaining exemplars. A plausible implication is that the module uses the low-dimensional prototype as a compact generator of class-consistent perturbations, then asks the hyperdimensional representation to remain discriminative under those perturbations.

4. Bi-level prototype refinement

The core of continuity self-refinement is a bi-level routine that refines the high-dimensional prototypes while adapting the projection module (Huo et al., 2023).

For each class $\mu^c \in \mathbb{R}^d$9, the inner-level optimization updates the prototype by minimizing

$\mathrm{Proj}_{vp}(\theta_1(x))$0

yielding

$\mathrm{Proj}_{vp}(\theta_1(x))$1

The text gives the closed-form update, or equivalently one Newton step, as

$\mathrm{Proj}_{vp}(\theta_1(x))$2

This update has two explicit terms: attraction toward the pseudo-samples and regularization toward the previous prototype. The regularizer $\mathrm{Proj}_{vp}(\theta_1(x))$3 is described as preventing huge prototype jumps.

The outer-level optimization adjusts $\mathrm{Proj}_{vp}(\theta_1(x))$4 so that the newly generated pseudo-points remain classified correctly under the refined prototypes: $\mathrm{Proj}_{vp}(\theta_1(x))$5

The overall online step is then expressed as

$\mathrm{Proj}_{vp}(\theta_1(x))$6

This division of labor is central to the module. Prototype refinement is handled by a convex inner step, while representational adaptation is delegated to a lightweight outer step. The method description explicitly frames the routine as alternating optimization between prototypes and a small projection component rather than end-to-end updating of the backbone.

5. Architecture and single-pass online update

The architectural support for continuity self-refinement is minimal by design. The feature extractor $\mathrm{Proj}_{vp}(\theta_1(x))$7 is frozen after the base session. On top of $\mathrm{Proj}_{vp}(\theta_1(x))$8, the framework places a small 2-layer MLP projection head $\mathrm{Proj}_{vp}(\theta_1(x))$9, concretely described as (Huo et al., 2023): $h^c \in \mathbb{R}^D$0

During self-refinement, only the parameters of $h^c \in \mathbb{R}^D$1, and $h^c \in \mathbb{R}^D$2 if so desired, are updated by $h^c \in \mathbb{R}^D$3. The backbone $h^c \in \mathbb{R}^D$4 remains frozen. The text states that this head continuously adapts to the refined prototypes, “stretching” or “rotating” the hyperdimensional space so that pseudo-examples remain well-clustered.

The online update cycle is given as a four-step procedure:

1. Extract $h^c \in \mathbb{R}^D$5 for real examples in the batch; if they belong to existing classes $h^c \in \mathbb{R}^D$6, update the class-means $h^c \in \mathbb{R}^D$7 and $h^c \in \mathbb{R}^D$8 in a running-mean fashion.
2. Self-augment each class prototype $h^c \in \mathbb{R}^D$9 with $\mathrm{Proj}_{hp}(\theta_2(\theta_1(x)))$0 random draws of noise to obtain $\mathrm{Proj}_{hp}(\theta_2(\theta_1(x)))$1.
3. Run exactly $\mathrm{Proj}_{hp}(\theta_2(\theta_1(x)))$2 inner-outer iterations of the bi-level recipe, updating only $\mathrm{Proj}_{hp}(\theta_2(\theta_1(x)))$3 in the inner step and $\mathrm{Proj}_{hp}(\theta_2(\theta_1(x)))$4 in the outer step.
4. Discard the pseudo-examples and keep only the refined prototypes $\mathrm{Proj}_{hp}(\theta_2(\theta_1(x)))$5 and the updated $\mathrm{Proj}_{hp}(\theta_2(\theta_1(x)))$6.

The implementation guidance specifies stable settings of $\mathrm{Proj}_{hp}(\theta_2(\theta_1(x)))$7, $\mathrm{Proj}_{hp}(\theta_2(\theta_1(x)))$8, $\mathrm{Proj}_{hp}(\theta_2(\theta_1(x)))$9, and $$\mu^c = \frac{1}{|\mathcal{D}_c|} \sum_{(x,y)\in\mathcal{D}_c} \mathrm{Proj}_{vp}\bigl(\theta_1(x)\bigr).$$0. The description also notes that each prototype is updated only once, in a single pass, per batch and that no data revisit is required. This is the operational basis for the claim that the method is online and non-exemplar.

6. Theoretical properties, interpretation, and relation to other refinement modules

Several theoretical properties are explicitly attached to the subroutine (Huo et al., 2023). The inner objective $$\mu^c = \frac{1}{|\mathcal{D}_c|} \sum_{(x,y)\in\mathcal{D}_c} \mathrm{Proj}_{vp}\bigl(\theta_1(x)\bigr).$$1 is stated to be strictly convex in $$\mu^c = \frac{1}{|\mathcal{D}_c|} \sum_{(x,y)\in\mathcal{D}_c} \mathrm{Proj}_{vp}\bigl(\theta_1(x)\bigr).$$2, so its minimizer $$\mu^c = \frac{1}{|\mathcal{D}_c|} \sum_{(x,y)\in\mathcal{D}_c} \mathrm{Proj}_{vp}\bigl(\theta_1(x)\bigr).$$3 is unique and can be obtained in closed form or by one Newton step. Under standard Lipschitz-smoothness assumptions on $$\mu^c = \frac{1}{|\mathcal{D}_c|} \sum_{(x,y)\in\mathcal{D}_c} \mathrm{Proj}_{vp}\bigl(\theta_1(x)\bigr).$$4, each gradient step on $$\mu^c = \frac{1}{|\mathcal{D}_c|} \sum_{(x,y)\in\mathcal{D}_c} \mathrm{Proj}_{vp}\bigl(\theta_1(x)\bigr).$$5 is said to decrease the outer objective. Because the inner solution changes continuously in $$\mu^c = \frac{1}{|\mathcal{D}_c|} \sum_{(x,y)\in\mathcal{D}_c} \mathrm{Proj}_{vp}\bigl(\theta_1(x)\bigr).$$6 and the outer loss is smooth, the two-block Gauss-Seidel procedure is stated to converge to a stationary point of the full bi-level problem. The text further claims a no-forgetting guarantee in the sense that the update rule provably does not increase the classification loss on classes whose prototypes have already converged, and reports empirically that the bi-level loop converges in $$\mu^c = \frac{1}{|\mathcal{D}_c|} \sum_{(x,y)\in\mathcal{D}_c} \mathrm{Proj}_{vp}\bigl(\theta_1(x)\bigr).$$7 steps and never “unlearns” old classes.

These properties clarify the intended meaning of continuity. The term does not denote geometric continuity in image contours or object boundaries. Instead, it refers to continual, per-class adjustment that preserves continuity in the representation while avoiding catastrophic drift. This distinction is important because the term “refinement” appears in other domains with different mechanisms.

Two contemporary examples illustrate that distinction. In CASR-Net for coronary artery segmentation, continuity preservation is pursued in image space through a Self-ONN decoder and a rule-based contour refinement module that suppresses false positives in binary vessel masks; the stated target is continuity of narrow and stenotic vessel branches (Hassan et al., 31 Oct 2025). In DRRNet for camouflaged object detection, the Dual Reverse Refinement Module applies two successive rounds of inverse refinement using spatial edge priors and frequency-domain noise suppression to sharpen object boundaries and enhance boundary continuity (Sun et al., 14 May 2025). By contrast, the continuity self-refinement module in DSR operates in prototype space for online continual learning. A plausible implication is that these methods share a refinement vocabulary and a continuity objective, but they act on fundamentally different state variables: class prototypes in DSR, vessel masks in CASR-Net, and multiscale decoder features and predictions in DRRNet.