---
title: Continuity Self-Refinement Module
url: https://www.emergentmind.com/topics/continuity-self-refinement-module
type: topic
---

# Continuity Self-Refinement Module

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 [2303.10891].

## 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 [2303.10891].

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 [2303.10891].

| 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 \(c\) by adding controlled Gaussian noise around \(\mu^c\) [2303.10891]:
\[
\hat z_c^{\,k}
=
\mu^c + \lambda\,\epsilon_c^k,
\qquad
\epsilon_c^k \sim \mathcal{N}(0, I_d),
\quad
k=1,\ldots,K.
\]

The description gives \(\lambda \approx 0.5\) in practice. Each pseudo-point is then lifted through the projection module:
\[
\hat h_c^{\,k}
=
\mathrm{Proj}_{hp}\bigl(\theta_2(\hat z_c^{\,k})\bigr)
\in \mathbb{R}^D.
\]

A self-augment loss is defined to make these pseudo-points recognizable as class \(c\), using cross-entropy classification on the hyperdimensional features:
\[
L_{\mathrm{aug}}
=
\frac{1}{C\,K}
\sum_{c=1}^{C}\sum_{k=1}^{K}
\ell_{\mathrm{CE}}\!\Bigl(
\mathrm{softmax}\bigl(W\,\hat h_c^{\,k}\bigr),\,c
\Bigr),
\]
where \(W\) is the final linear classifier head and is frozen during self-refinement. The formulation also states that \(\ell_{\mathrm{CE}}\) 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 [2303.10891].

For each class \(c\), the **inner-level** optimization updates the prototype by minimizing
\[
\mathcal{L}_{\mathrm{in}}
=
\frac{1}{K}\sum_{k=1}^{K}
\bigl\| h - \hat h_c^{\,k} \bigr\|_2^2
+
\gamma\,\| h - h^c \|_2^2,
\]
yielding
\[
\tilde h^c
=
\arg\min_h \mathcal{L}_{\mathrm{in}}.
\]

The text gives the closed-form update, or equivalently one Newton step, as
\[
\tilde h^c
=
\frac{\sum_k \hat h_c^{\,k} + \gamma\,h^c}{K+\gamma}.
\]

This update has two explicit terms: attraction toward the pseudo-samples and regularization toward the previous prototype. The regularizer \(\gamma > 0\) is described as preventing huge prototype jumps.

The **outer-level** optimization adjusts \(\theta_2\) so that the newly generated pseudo-points remain classified correctly under the refined prototypes:
\[
\mathcal{L}_{\mathrm{out}}(\theta_2)
=
\frac{1}{C\,K}
\sum_{c=1}^{C}\sum_{k=1}^{K}
\ell_{\mathrm{CE}}\!\Bigl(
\mathrm{softmax}\!\bigl(
\{\langle \theta_2(\hat z_c^k), \tilde h^j\rangle\}_{j=1}^{C}
\bigr),\,c
\Bigr).
\]

The overall online step is then expressed as
\[
\min_{\theta_2}
\mathcal{L}_{\mathrm{out}}\bigl(\theta_2;\{\tilde h^c\}\bigr)
\quad \text{s.t.} \quad
\tilde h^c
=
\arg\min_h
\mathcal{L}_{\mathrm{in}}\bigl(h;\{\theta_2(\hat z_c^k)\}\bigr).
\]

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 \(\theta_1(\cdot)\) is frozen after the base session. On top of \(\theta_2(\theta_1(x))\), the framework places a small 2-layer MLP projection head \(\mathrm{Proj}_{hp}\), concretely described as [2303.10891]:
\[
\theta_2(\theta_1(x))
\rightarrow
\mathrm{FC}(160)
\rightarrow
\mathrm{ReLU}
\rightarrow
\mathrm{FC}(128)
\rightarrow
\mathrm{ReLU}
\rightarrow
\mathrm{FC}(D)
=
\mathrm{Proj}_{hp}(\cdot).
\]

During self-refinement, only the parameters of \(\mathrm{Proj}_{hp}\), and \(\theta_2\) if so desired, are updated by \(\nabla \mathcal{L}_{\mathrm{out}}\). The backbone \(\theta_1\) 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 \(\theta_1(x)\) for real examples in the batch; if they belong to existing classes \(c\), update the class-means \(\mu^c\) and \(h^c\) in a running-mean fashion.
2. Self-augment each class prototype \(\mu^c\) with \(K\) random draws of noise to obtain \(\{\hat z_c^k\}\).
3. Run exactly \(T\) inner-outer iterations of the bi-level recipe, updating only \(h^c\) in the inner step and \(\theta_2/\mathrm{Proj}_{hp}\) in the outer step.
4. Discard the pseudo-examples and keep only the refined prototypes \(\{h^c\}\) and the updated \(\mathrm{Proj}_{hp}\).

The implementation guidance specifies stable settings of \(D=2048\), \(K=20\), \(\lambda=0.5\), and \(T=20\). 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 [2303.10891]. The inner objective \(\mathcal{L}_{\mathrm{in}}(h)\) is stated to be strictly convex in \(h\), so its minimizer \(\tilde h^c\) is unique and can be obtained in closed form or by one Newton step. Under standard Lipschitz-smoothness assumptions on \(\mathrm{Proj}_{hp}\), each gradient step on \(\theta_2\) is said to decrease the outer objective. Because the inner solution changes continuously in \(\theta_2\) 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 \(\lesssim 5\) 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 [2510.27315]. 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 [2505.09168]. 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.

Source: https://www.emergentmind.com/topics/continuity-self-refinement-module