Forget but Recall: Incremental Latent Rectification in Continual Learning

## Abstract

Abstract Intrinsic capability to continuously learn a changing data stream is a desideratum of deep neural networks (DNNs). However, current DNNs suffer from catastrophic forgetting, which hinders remembering past knowledge. To mitigate this issue, existing Continual Learning (CL) approaches either retain exemplars for replay, regularize learning, or allocate dedicated capacity for new tasks. This paper investigates an unexplored CL direction for incremental learning called Incremental Latent Rectification or ILR . In a nutshell, ILR learns to propagate with correction (or rectify) the representation from the current trained DNN backward to the representation space of the old task, where performing predictive decisions is easier. This rectification process only employs a chain of small representation mapping networks, called rectifier units. Empirical experiments on several continual learning benchmarks, including CIFAR10, CIFAR100, and Tiny ImageNet, demonstrate the effectiveness and potential of this novel CL direction compared to existing representative CL methods.

## 1 Introduction

Humans exhibit the innate capability to incrementally learn novel concepts while consolidating acquired knowledge into long-term memories []. More general Artificial Intelligence systems in real-world applications would require similar imitation to capture the dynamic of the changing data stream. These systems need to acquire knowledge incrementally without retraining, which is computationally expensive and exhibits a large memory footprint []. Nonetheless, existing learning approaches are yet to match human learning in this so-called Continual Learning (CL) problem due to catastrophic forgetting []. These systems encounter difficulty balancing the capability of incorporating new task knowledge while maintaining performance on learned tasks, or the plasticity-stability dilemma.

Representative CL approaches in the literature usually involve the use of memory buffer for rehearsal [, , , , , ], auxiliary loss term for learning regularization [, , , ], or structural changes such as pruning or model growing [, , , ]. These methods share the common objective of discouraging the deviation of learned knowledge representation. Rehearsal-based methods allow the model to revisit past exemplars to reinforce previously learned representations. Alternatively, regularization-based methods prevent changes in parameter spaces by formulating additional loss terms. However, both approaches present shortcomings, including keeping a rehearsal buffer of all past tasks during the model lifetime or infusing ad-hoc inductive bias into the regularization process. Meanwhile, structure-based methods utilize the over-parameterization property of the model by pruning, masking, or adding parameters to reduce new task interferences.

This paper studies a novel approach for CL named Incremental Latent Rectification (ILR), where we allow the model to “forget” knowledge of old tasks but then “recall” or rectify such “catastrophic forgetting” during inference using a sequence of lightweight knowledge mapping networks. These lightweight knowledge mapping networks, called rectifiers, help significantly reduce information loss on learned tasks by incrementally correcting the changes in the representation space. Specifically, for each new task, we add a small, simple, and computationally inexpensive auxiliary unit that will rectify the representation from the current task to the previous task. Our method differs from many network expansion methods, where additional parameters are allocated to minimize changes to the old parameters. Instead, we iteratively recover past task representations by backwardly propagating current representations through a series of mapping networks. Through this mechanism, ILR allows the optimal adaptation of a new task (plasticity) while separately mitigating catastrophic forgetting. In addition, different from previous CL approaches that modify the sequential training process (e.g., by changing the loss functions or using an additional buffer in fine-tuning), ILR does not change the new task’s learning, hence, ILR can be easily integrated into the existing CL pipelines.

##### Contributions.

We propose a new direction for CL by sequentially correcting the representation of the current task into the past task’s representation using a chain of lightweight rectifier units:

- •
We propose a novel loss function for aligning the latent representation to guide the training procedure. The loss function is designed as a weighted sum of an L2-norm reconstruction error and a cosine distance metric.
- •
To train the rectifier unit, we rely on either data samples from task $t-1$ or the current task $t$; when such data is unavailable (e.g., due to memory constraint or privacy concerns), a generative model that synthesizes task $t-1$’s data can also be utilized. At inference time, for the task-incremental setting, we construct a chain of rectifiers based on the provided task identity and forward the latent representation and inputs to correct the representation.
For the class incremental setting,
ILR forms the final prediction from an ensemble of predictions based on the reconstructed representations.
- •
We empirically evaluate our approach on three widely-used continual learning benchmarks (CIFAR10, CIFAR100, and Tiny ImageNet) to demonstrate that our approach achieves comparable performance with the existing representative CL directions.

This paper unfolds as follows. Section 2 discusses the literature on the continual learning problems, and Section 3 describes our Incremental Latent Rectification method. Finally, Section 4 provides the empirical evidence for the effectiveness of our proposed solution.

## 2 Related Work

Catastrophic forgetting is a critical concern in artificial intelligence and is arguably one of the most prominent questions to address for DNNs. This phenomenon presents significant challenges when deploying models in different applications. Continual learning addresses this issue by enabling agents to learn throughout their lifespan. This aspect has gained significant attention recently  [, , , ]. Considering a model well-trained on past tasks, we risk overwriting its past knowledge by adapting it for new tasks. The problem of knowledge loss can be addressed using different methods, as explored in the literature[, , , , , , , ]
. These methods aim to mitigate knowledge loss and improve task performance through three main approaches: (1) Rehearsal-based methods, which involve reminding the model of past knowledge by using selective exemplars; (2) Regularization-based methods, which penalize changes in past task knowledge through regularization techniques; (3) Parameter-isolation and Dynamic Architecture methods, which allocate sub-networks or expand new sub-networks, respectively, for each task, minimizing task interference and enabling the model to specialize for different tasks.

Rehearsal-based. Experience replay methods build and store a memory of the knowledge learned so far [, , , , , ]. As an example, Averaged Gradient Episodic Memory (A-GEM) [] builds an episodic memory of parameter gradients, while ER-Reservoir [] uses a reservoir sampling method to maintain the episodic memory. These methods have shown strong performance in recent studies. However, they require a significant amount of memory for storing the examples.

Regularization-based.
A popular early work using regularization is the elastic weight consolidation (EWC) method [].
Other methods [, , , , ] propose different criteria to measure the “importance” of parameters.
A later study showed that many regularization-based methods are variations of Hessian optimization []. These methods typically assume that there are multiple optima in the updated loss landscape in the new data distribution. One can find a good optimum for both the new and old data distributions by constraining the deviation from the original model weights.

Parameter Isolation.
Parameter isolation methods allocate different subsets of the parameters to each task [, , , ]. From the stability-plasticity perspective, these methods implement gating mechanisms that improve stability and control plasticity by activating different gates for each task. Masse et al. [] proposes a bio-inspired approach for a context-dependent gating that activates a non-overlapping subset of parameters for any specific task. Supermask in Superposition [] is another parameter isolation method that starts with a randomly initialized, fixed base network and, for each task, finds a sub-network (supermask) such that the model achieves good performance.

Dynamic Architecture. Different from Parameter Isolation, which allocates subnets for tasks in a fixed main network, this approach dynamically expands the structure of the network. Yoon et al. [] proposes a method that leverages the network structure trained on previous tasks to effectively learn new tasks, while dynamically expanding its capacity by adding or duplicating neurons as needed. Other methods [, ] reformulate CL problems into reinforcement learning (RL) problems, and leverage RL methods to determine when to expand the architecture during learning of new tasks. Yan et al. [] introduces a two-stage learning method that first expands the previous frozen task feature representations by a new feature extractor, then re-trains the classifier with current and buffered data.

## 3 Proposed Framework

We consider the task-incremental and class-incremental learning scenarios, where we sequentially observe a set of tasks $t\in\{1,\ldots,N\}$. The neural network comprises a single task-agnostic feature extractor $f$ and a classifier $w$ with task-specific heads $w^{(t)}|_{t=1}^{N}$.
The architecture of $f$ is fixed; however, its parameters are gradually updated as new tasks arrive. At task $t$, the system receives the training dataset $\mathcal{D}_{t}^{\mathrm{train}}$ sampled from the data distribution $\mathcal{D}_{t}$ and learns the updated parameters of the feature extractor $f$ and $w$. For easier discussion, the feature extractor and classifier obtained after learning at task $t$ are denoted as $f_{t}$ and $w_{t}$, respectively. Thus, after learning on task $t$, we obtain the evolved feature extractor $f_{t}$ and classifier $w_{t}$. We call the latent space created by the feature extractor trained with $\mathcal{D}_{t}^{\mathrm{train}}$ as the $t$-domain. Catastrophic forgetting occurs as the feature extractor $f_{t^{\prime}}$ is updated into $f_{t}$, $t^{\prime}<t$, which causes the $t^{\prime}$-domain to be overwritten by the $t$-domain. This domain shift degrades the model’s performance over time.

To overcome catastrophic forgetting, we propose a new CL paradigm: learning a latent rectification mechanism. This mechanism relies on a lightweight rectifier unit $r_{t}$ that learns to align the representations from the $t$-domain to the $(t-1)$-domain. Intuitively, this module “corrects” the representation change of a sample from the old task $t-1$ due to the evolution of the feature extractor $f$ when learning the newer task $t$. These rectifier units will establish a chain of corrections for the representation of any task’s input, allowing the model to predict the rectified representation better.  Figure 1 provides a visualization of the inference process on a task-$t$ sample, after learning $N$ tasks.

Learning the latent rectification mechanism is central to our proposed framework. In general, each rectifier unit should be small compared to the size of the final model or the feature extractor $f$, and its learning process should be resource-efficient. In the following sections, we present and describe our solution for learning this mechanism.

Figure: Figure 1: At task $t$, the feature extractor $f_{t}$ and classifier head $w_{t}$ are optimized on the dataset $D_{t}^{\mathrm{train}}$. During inference for a test sample from task $t$, we forward the input data $x\in D_{t}^{\mathrm{test}}$ through the feature extractor and classifier head to obtain the logits. After learning all $N$ tasks, the DNN loses performance on task $t$ due to catastrophic forgetting. Therefore, the latent representation $f_{N}(x)$ is propagated through a series of rectifiers $r_{N},\ldots,r_{t+1}$ to perform incremental latent rectification and obtained approximated representations $\hat{f}_{N-1},\ldots,\hat{f}_{t}$. The logits can be obtained by passing the recovered representation to the respective classifier head.
Refer to caption: x1.png

### 3.1 Learning the Rectifier Unit

As the training dataset $\mathcal{D}_{t}^{\mathrm{train}}$ of task $t$ arrives, we first update the feature extractor $f_{t}$ and the classifier head $w_{t}$. The primary goal herein is to find $(f_{t},w_{t})$ that has high classification performance for task $t$, and the secondary goal is to choose $f_{t}$ that can reduce the catastrophic forgetting on previous tasks. To combat catastrophic forgetting, we will first discuss the objective function for learning the lightweight rectifier unit $r_{t}$ and the potential alignment training data (or alignment set) $\mathcal{S}_{t}$.

#### 3.1.1 Alignment Loss

The goal of $r_{t}$ is to reduce the discrepancy between task $t$’s representation $f_{t}(x_{i})$ and the previous data representation $f_{t-1}(x_{i})$, for $x_{i}\sim\mathcal{D}_{t-1}$; i.e. $r_{t}(f_{t}(x_{i}),x_{i})\approx f_{t-1}(x_{i})$. One choice is the weighted linear combination of the $l_{2}$ error and the cosine error between $f_{t}(x_{i})$ with $r_{t}(f_{t}(x_{i}),x_{i})$. This combination promotes alignment in both the magnitude and the direction between two representation vectors for improved representational similarity.

Let $s$ be a function, with parameters $\theta_{s}$, that encodes inputs $x_{i}$ into its respective past representation in domain $t-1$,
and $\tau>0$ be the weight hyper-parameter; we define the alignment loss as:

$$ $\mathcal{L}_{\mathrm{align}}(\theta_{s};s,\tau,\mathcal{S}_{t},f_{t-1})= \mathbb{E}_{x_{i}\sim\mathcal{S}_{t}}\left[\|s(x_{i})-f_{t-1}(x_{i})\|_{2}^{2} +\tau(1-\cos(s(x_{i}),f_{t-1}(x_{i})))\right].$ (1) $$

In practice, we could either store the value of $f_{t-1}(x_{i})$ together with $x_{i}$ in memory or $f_{t-1}$ directly.

#### 3.1.2 Alignment Set

The alignment set $\mathcal{S}_{t}$ is used as the training data for the rectifier unit $r_{t}$ enables the rectifier unit to efficiently learn the mapping from the $t$-domain back to the $t-1$-domain. The design of ILR enables several options for selecting the alignment set, including $\mathcal{D}_{t-1}^{\mathrm{train}}$, $\mathcal{D}_{t}^{\mathrm{train}}$, or a generative method.

Task $t-1$ data. The simplest choice for the alignment set $\mathcal{S}_{t}$ is the $\mathcal{D}_{t-1}^{\text{train}}$ (i.e., the training data from the previous task $t-1$), which is sampled directly from the task $t-1$’s distribution. With this option, each element in $\mathcal{S}_{t}$ is a pair $(x_{i},\hat{z}_{i})$, where $x_{i}\in\mathcal{D}_{t-1}^{\text{train}}$ is chosen randomly and $\hat{z}_{i}=f_{t-1}(x_{i})$ is the associated latent representation of $x_{i}$ under the feature extractor $f_{t-1}$.
Note that this option does not keep data samples from all past tasks $t\in\{1,\ldots,N\}$ like the rehearsal-based methods [].

Task $t$ data. Another potential option for $\mathcal{S}_{t}$ is task-$t$’s data. If we expect the tasks’ data to not be completely unrelated, using data from $\mathcal{D}_{t}^{\text{train}}$ to train $r_{t}$ is reasonable. As we show in Section 4, we could achieve comparable performance to some rehearsal-based methods while remaining data-free when setting $\mathcal{S}_{t}=\mathcal{D}_{t}^{\text{train}}$. Additionally, for this option, since we do not have access to $t-1$-domain data, we need to keep a copy of $f_{t-1}$ to approximate $\hat{z_{i}}=f_{t-1}(x_{i})$ with $x_{i}\in\mathcal{D}_{t}^{\mathrm{train}}$.

Generated task $t-1$ data. Generative methods provide a potential option for creating training data for the rectifier unit $r_{t}$. Instead of keeping the alignment set $\mathcal{S}_{t}\subseteq\mathcal{D}_{t-1}^{\mathrm{train}}$, we could train a generative neural network $G_{t-1}$ that learns the task $t-1$ distribution. Unlike generative continual learning methods, $G_{t-1}$ only needs to remember the task $t-1$ distribution instead of all past tasks. Thus, LRB can easily integrate with existing generative methods.

In addition, we could fill $\mathcal{S}_{t}$ with randomly initialized samples. Nonetheless, our experiments indicate that this approach is ineffective. Therefore, we will focus our discussion on the first three options and leave the exploration for other choices of $\mathcal{S}_{t}$ for future works.

Distiction from buffer-based methods. Rehearsal-based methods retains the data from all past tasks $t\in\{1,\ldots,N\}$ during the lifetime of the DNN. Meanwhile, depending on the choice of alignment set $\mathcal{S}_{t}$, ILR could be considered strictly data-free if $\mathcal{S}_{t}=\mathcal{D}_{t}$ or using the generative method. While for $\mathcal{S}_{t}\subseteq\mathcal{D}_{t-1}$, ILR can still arguably be a data-free method since task $t-1$ data is only retained until the end of task $t$.

### 3.2 Incremental Latent Alignment

The latent alignment mechanism relies on a chain of task-specific rectifier units $(r_{t})_{t=2}^{N}$ that aims to correct the distortion of the representation space as the extractor $f$ learns a new task.

#### 3.2.1 Latent Alignment

For an input $x$ at task $t-1$, its feature representation under the feature extractor $f_{t-1}$ is $f_{t-1}(x)$. One can heuristically define the $(t-1)$-domain as the representation of the input under the feature extractor $f_{t-1}$. Unfortunately, the $(t-1)$-domain is brittle under extractor update: as the subsequent task $t$ arrives, the feature extractor is updated to $f_{t}$, and the corresponding feature representation of the same input $x$ will be shifted to $f_{t}(x)$. Likely, the $t$-domain and the $(t-1)$-domain do not coincide, and $f_{t}(x)\neq f_{t-1}(x)$.

The feature rectifier unit $r_{t}$ aims to offset this representation shift. To do this, $r_{t}$ takes $x$, and its $t$-domain representation $f_{t}(x)$ as input, and it outputs the rectified representation that satisfies

$$ $r_{t}\circ(f_{t}\times I)(x)=r_{t}(f_{t}(x),x)\approx f_{t-1}(x),$ (2) $$

with identity function $I$.

With this formulation, we can effectively minimize the difference between the rectified representation $r_{t}\circ(f_{t}\times I)(x)$ and the original representation $f_{t-1}(x)$. In practice, we only want to train the rectifier unit $r_{t}$ and retain the learned feature extractor $f_{t}$; therefore, let $s=r_{t}\circ(f_{t}\times I)$, we can minimize the difference by using $L_{\mathrm{align}}(\theta_{r_{t}};s,\tau,\mathcal{S}_{t},f_{t-1})$ as in Equation 1.

Figure: Figure 2: The rectifier unit includes a weak feature extractor $h_{t}$, a linear compress $\mathrm{a}_{t}$ layer, and a linear combine $\mathrm{b}_{t}$. The compress layer forms a bottleneck to select the remaining $(t-1)$-domain knowledge in $f_{t}$, while $h_{t}$ extracts compensation information for the loss information in $f_{t}$. The combine layer aggregates and transforms the information from both $h_{t}$ and $f_{t}$ to form the rectified representation.
Refer to caption: x2.png

#### 3.2.2 Rectifier Architecture

The proposed rectifier is composed of three trainable components: a weak feature extractor $h_{t}$, a compress layer $a_{t}$, and a combine layer $b_{t}$. The size of the rectifier units increases linearly with respect to the number of tasks, similar to the classification heads. However, since the rectifier unit is lightweight, this is trivial compared to the size of the full model. Figure 2 visualizes the feature rectifier unit.

Weak feature extractor $h_{t}$. The weak feature extractor $h_{t}$ processes the input data $x$ to generate a simplified representation $h_{t}(x)$. $h_{t}$ is distilled from $f_{t-1}$ to compress the knowledge of $f_{t-1}$ into a more compact, lower-dimensional representation while remaining parameter-efficient. For our experiment, we choose the simplest and most naive design of a weak feature extractor composed of only two 3x3 convolution layers and two max pooling layers. Instead of processing the full-size image, we use max-pooling to downsample the input to 16x16 images before feeding into $h_{t}$. The weak feature extractor is a small network compared to the main model ($h_{t}$’s architecture is provided in Table 6).

Compress layer $a_{t}$. The compress layer $a_{t}$ receives the current latent value $f_{t}(x)$ and produces a compact representation $a_{t}(f_{t}(x))$ of reduced dimensionality. This layer essentially forms a bottleneck that only allows relevant $t-1$-domain knowledge to pass through. We design the compress layer as a simple linear layer.

Combine layer $b_{t}$. The combine layer $b_{t}$ recevies the concatenated representaton of the compressed representation $a_{t}\circ f_{t}(x)$ and the weakly extracted features $h_{t}(x)$ to form the rectified representation $r_{t}(f_{t}(x),x)$. We design the combine layer as a simple linear layer.

Distiction from network-expansion approach. It could be argued that one can, instead, separately train a weak feature extractor $h_{t}$ for each task, making it a network-expansion CL approach. However, because $h_{t}$ is a small network, this approach is ineffective; specifically, our experiments demonstrate that the task-incremental average accuracy across all tasks of this approach on CIFAR100 falls below $53\%$. Furthermore, for network-expansion approaches, the dedicated parameters are allocated for new task learning,
which is fundamentally different from ILR’s objective to correct representation changes. The new task’s knowledge is acquired by $f_{t}$ and $w_{t}$.

### 3.3 Training Procedure

Network training.
Similar to conventional DNN training, the performance of the feature extractor $f_{t}$ and the classifier head $w_{t}$ is measured by the standard multi-class cross-entropy loss:

$$ $\mathcal{L}_{\mathrm{train}}(\theta_{f_{t}},\theta_{w_{t}})=\mathcal{L}_{ \mathrm{CE}}(\theta_{f_{t}},\theta_{w_{t}};f_{t},w_{t},\mathcal{D}_{t}^{ \mathrm{train}})=\mathbb{E}_{(x_{i},y_{i})\sim\mathcal{D}_{t}^{\mathrm{train}} }\left[-\sum_{c=1}^{M_{t}}y_{i}\log(\hat{y}_{i})\right],$ (3) $$

where $M_{t}$ is the number of classes of task $t$, $\hat{y}_{i}$ is the probability-valued network output for the input $x_{i}$ that depends on the feature extractor $f_{t}$ and the classifier $w_{t}$ as $\hat{y}_{i}=w_{t}\circ f_{t}(x_{i})$.

Furthermore, if the alignment set $\mathcal{S}_{t}$ uses either task $t-1$ data or generative network $G_{t-1}$, we could also utilize $\mathcal{S}_{t}$ to further enforce task $t-1$ representation consistency, reduce forgetting, and enable more effective rectification by training and regularizing $f_{t}$ on $\mathcal{D}_{t}^{\mathrm{train}}$ and $\mathcal{S}_{t}$, respectively. Let $s=f_{t}$, then we can similarly use
$\mathcal{L}_{\mathrm{align}}$
in Equation 1 with hyperparameter $\alpha$ :

$$ $\mathcal{L}_{\mathrm{train}}(\theta_{f_{t}},\theta_{w_{t}})=\mathcal{L}_{ \mathrm{CE}}(\theta_{f_{t}},\theta_{w_{t}};f_{t},w_{t},\mathcal{D}_{t}^{ \mathrm{train}})+\alpha\mathcal{L}_{\mathrm{align}}(\theta_{f_{t}};s,\tau, \mathcal{S}_{t},f_{t-1}).$ (4) $$

This is different from the rehearsal method since $f$ only visits $\mathcal{D}_{t-1}$ at task $t-1$ and task $t$. After task $t$, $f$ never seen $\mathcal{D}_{t-1}$ again, while for rehearsal method, $f$ observe samples from $\mathcal{D}_{t-1}$ throughout its lifetime, risk overfitting on stored exemplars.

Figure: Algorithm 1 Full training framework at task $t\in\{1,2,...,n\}$

Rectifier training.
Training the rectifier follows two main steps: train the weak feature extractor and then the compress/combine layers. The weak feature extractor $h_{t}$ is distilled from $f_{t-1}$ as task $t-1$ training is completed. Let $g_{t}$ be a temporary linear layer mapping $h_{t}$’s smaller dimension to $f_{t-1}$’s higher dimension, $s=g_{t}\circ h_{t}$ and $\mathcal{S}_{t}=\mathcal{D}_{t-1}$, we train $h_{t}$ using the $\mathcal{L}_{\mathrm{align}}(\theta_{s};s,\tau,\mathcal{S}_{t},f_{t-1})$ in Equation 1. Similarly, as detailed in Section 3.2.1, we train the remaining components of $r_{t}$, i.e., compress/combine layers, at the end of task $t$. Details of ILR’s training algorithm are provided in Algorithm 1

### 3.4 Inference Procedure

We now describe how to stack multiple rectifier units $r_{t}$ into a chain for inference. As a new task arrives, our model dynamically extends an additional rectifier unit, forming a sequence of rectifiers.

Task-Incremental.
We consider a task-incremental learning setting where a test sample $x_{i}$ is coupled with a task identifier $t_{i}\in\{1,\ldots,N\}$. To classify $x_{i}$, we can recover $\hat{f}_{t_{i}}(x)$ by forwarding the current latent variable $f_{N}(x)$ through a chain of $N-t_{i}$ rectifiers. We then pass this recovered latent variable through classifier head $w_{t_{i}}$ to make a prediction. The output $\hat{y}_{i}$ is computed as

$$ $\displaystyle\hat{y}_{i}=w_{t_{i}}(\hat{f}_{t_{i}}(x_{i}))\quad\text{where} \quad\hat{f}_{t_{i}}(x_{i})=r_{t_{i}+1}\circ(\hat{f}_{t_{i}+1}\times I)(x) \quad\text{with}\quad t_{i}<N,\hat{f}_{N}=f_{N}$ $$

Class-Incremental.
ILR relies on the task identity to reconstruct the appropriate sequence of rectifier units for propagating the latent representation to the original space. However, no identity is provided for the CL method in the class-incremental learning setting.
We provided a simple method for inference without task identity, which demonstrates the method’s extension to class-incremental learning; however, more robust task-identity inference methods could also be incorporated.

We obtain the class-incremental probabilities by forming an ensemble that averages the class probabilities over all domains. From the current task $t$’s domain, we iteratively rectified the latent back to task $t-1$, task $t-2$, …, task $1$’s domain. At each domain, we obtain the rectified representation corresponding with the domain, which we forward through the respective classifier.
We then average the softmax probabilities of each domain, essentially forming an ensemble of $w_{i}(f_{i})|_{i=1}^{t}$.

## 4 Experiments

Our implementation is based partially on the Mammoth  [, ] repository, TAMiL [] repository, and CLS-ER  [] repository.

### 4.1 Evaluation Protocol

Datasets. We select three standard continual learning benchmarks for our experiments: Sequential CIFAR10 (S-CIFAR10), Sequential CIFAR100 (S-CIFAR100), and Sequential Tiny ImageNet (S-TinyImg). Specifically, we divide S-CIFAR10 into 5 binary classification tasks, S-CIFAR100 into 5 tasks with 20 classes each, and S-TinyImg into 20 tasks with 20 classes each.

Baselines.
We evaluate ILR against representative continual learning methods, including EWC (online) [], and LwF (multi-class) [], ER [], AGEM [], DER++ [], ER-ACE [], CLS-ER  [], TAMiL []. We further provide an upper and lower bound for all methods by joint training on all tasks’ data and fine-tuning without any catastrophic forgetting mitigation. We employ ResNet18 [] as the unified feature extractor for all benchmarks. The classifier comprises a fixed number of separate linear heads for each task. More datasets and implementation details are provided in the Appendix.

**Table 1: Task-Incremental Average Accuracy across all tasks after CL training. Joint: the upper bound accuracy when jointly training on all tasks (i.e., multi-task learning). Finetuning: the lower bound accuracy when learning without any CL techniques. $|\mathcal{B}|$ is the buffer of all past tasks data, while $|\mathcal{S}_{t}|$ is the alignment training data set, which only contains data from task $t-1$.**
| Method | $|\mathcal{B}|$ | $|\mathcal{S}_{t}|$ | S-CIFAR10 | S-CIFAR100 | S-TinyImg |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| TIL |  |  | NP | AA | NP | AA | NP | AA |
| Joint | - | - | 11.17M | 98.46$\pm$0.07 | 11.22M | 86.37$\pm$0.17 | 11.27M | 81.86$\pm$0.57 |
| Finetuning | 11.17M | 64.16$\pm$2.40 | 11.22M | 24.01$\pm$2.14 | 11.27M | 13.79$\pm$0.23 |  |  |
| o-EWC | - | - | 11.17M | 69.60$\pm$5.22 | 11.22M | 36.61$\pm$3.82 | 11.27M | 15.67$\pm$0.67 |
| LwF.mc | 11.17M | 60.96$\pm$1.48 | 11.22M | 41.00$\pm$1.01 | 11.27M | 23.24$\pm$0.71 |  |  |
| AGEM | 500 | - | 11.17M | 90.37$\pm$1.05 | 11.22M | 63.35$\pm$1.47 | 11.27M | 37.14$\pm$0.32 |
| ER | 11.17M | 94.24$\pm$0.24 | 11.22M | 67.41$\pm$0.70 | 11.27M | 46.07$\pm$0.16 |  |  |
| DER++ | 11.17M | 92.49$\pm$0.55 | 11.22M | 68.52$\pm$0.91 | 11.27M | 50.84$\pm$0.12 |  |  |
| ER-ACE | 11.17M | 94.52$\pm$0.13 | 11.22M | 67.26$\pm$0.50 | 11.27M | 47.72$\pm$0.42 |  |  |
| TAMiL | 22.68M | 94.89$\pm$0.16 | 22.77M | 76.39$\pm$0.29 | 23.20M | 64.24$\pm$0.69 |  |  |
| CLS-ER | 33.52M | 95.35$\pm$0.34 | 33.66M | 77.03$\pm$0.81 | 33.81M | 54.69$\pm$0.37 |  |  |
| ILR | - | 500 | 13.31M | 86.28$\pm$0.69 | 13.36M | 74.59$\pm$0.52 | 16.08M | 59.78$\pm$0.39 |
| AGEM | 1000 | - | 11.17M | 91.68$\pm$1.48 | 11.22M | 67.43$\pm$1.37 | 11.27M | 46.94$\pm$0.91 |
| ER | 11.17M | 95.25$\pm$0.07 | 11.22M | 69.69$\pm$1.49 | 11.27M | 54.54$\pm$0.40 |  |  |
| DER++ | 11.17M | 93.76$\pm$0.23 | 11.22M | 72.27$\pm$1.13 | 11.27M | 58.67$\pm$0.28 |  |  |
| ER-ACE | 11.17M | 94.69$\pm$0.25 | 11.22M | 72.46$\pm$0.58 | 11.27M | 57.37$\pm$0.49 |  |  |
| TAMiL | 22.68M | 95.22$\pm$0.42 | 22.77M | 78.72$\pm$0.31 | 23.20M | 70.89$\pm$0.04 |  |  |
| CLS-ER | 33.52M | 96.05$\pm$0.11 | 33.66M | 79.36$\pm$0.20 | 33.81M | 65.00$\pm$0.02 |  |  |
| ILR | - | 1000 | 13.31M | 91.02$\pm$1.76 | 13.36M | 78.53$\pm$0.25 | 16.08M | 66.79$\pm$0.64 |
| ILR | - | 5000 | 13.31M | 94.84$\pm$0.31 | 13.36M | 82.05$\pm$0.29 | 16.08M | 72.50$\pm$0.92 |

### 4.2 Results

Table 1 shows the performance of ILR and other CL methods, including rehearsal-based and regularization-based methods, on multiple sequential datasets, including S-CIFAR10, S-CIFAR100, and S-TinyImg. For ILR, we create an alignment set from 500, 100, and 5000 samples of $\mathcal{D}_{t-1}^{\mathrm{train}}$. As can be observed from the table, ILR achieves comparable results on S-CIFAR10, compared to the baselines. On S-CIFAR100 and S-TinyImg, ILR outperforms all the baselines given a sufficient alignment set, indicating its ability to rectify representation changes incrementally.

**Table 2: Class-Incremental Average Accuracy across all tasks after CL training. The settings are similar to Table 1.**
| Method | $|\mathcal{B}|$ | $|\mathcal{S}_{t}|$ | S-CIFAR100 |  |
| --- | --- | --- | --- | --- |
| CIL |  |  | NP | AA |
| Joint | - | - | 11.22M | 71.07$\pm$0.27 |
| Finetuning | 11.22M | 17.50$\pm$0.09 |  |  |
| DER++ | 1000 | - | 11.22M | 46.96$\pm$0.17 |
| ER-ACE | 11.22M | 47.09$\pm$1.16 |  |  |
| TAMiL | 22.77M | 51.83$\pm$0.41 |  |  |
| CLS-ER | 33.66M | 51.13$\pm$0.12 |  |  |
| ILR | - | 1000 | 13.56M | 42.53$\pm$0.43 |
| ILR | - | 5000 | 13.56M | 48.90$\pm$0.28 |

Table 2 demonstrates the extension of ILR to class-incremental settings. As the class-incremental probabilities are simply obtained through averaging, we can still achieve comparable performance to other rehearsal-based methods given a sufficient alignment set.

### 4.3 Result with different alignment sets

We further evaluate choices of training data used for alignment set $\mathcal{S}_{t}$, as discussed in  Section 3. The choices include using samples from the previous task’s training data $\mathcal{D}_{t-1}^{\text{train}}$, the current task’s training data $\mathcal{D}_{t-1}^{\text{train}}$, and generative network $G_{t-1}$. Details for $G_{t-1}$ training are included in the Appendix.

Table 3 shows the results of these experiments. As can be observed, training with data from $\mathcal{D}_{t-1}^{\text{train}}$ expectedly achieves better performance since the data is sampled directly from the data distribution $\mathcal{D}_{t}$ of the previous task; increasing the number of samples from $\mathcal{D}_{t-1}^{\text{train}}$ yields better performance results. The generative network also achieves comparable results due to its ability to synthesize data from $\mathcal{D}_{t}$. Nevertheless, training with $\mathcal{D}_{t}^{\text{train}}$ is also an attractive choice for its reasonable performance and the fact that we do not need to keep a copy of the previous task’s data.

**Table 3: Average Accuracy across 5 tasks for S-CIFAR100 dataset with different options of alignment training data.**
| Variation | Keep $t-1$ data | Keep $f_{t-1}$ | Keep $G_{t-1}$ | Avg. Accuracy |
| --- | --- | --- | --- | --- |
| ILR with $\mathcal{S}_{t}=\mathcal{D}_{t}^{\mathrm{train}}$ | - | ✓ | - | 69.22$\pm$0.40 |
| ILR with $\mathcal{S}_{t}\subset\mathcal{D}_{t-1}^{\mathrm{train}},|\mathcal{S}_{t}|=5000$ | ✓ | - | - | 82.05$\pm$0.29 |
| ILR-GAN $(\mathcal{S}_{t}\sim\mathcal{D}_{t-1}$) | - | ✓ | ✓ | 79.51$\pm$0.48 |

### 4.4 Parameter Growth Comparison

**Table 4: Number of parameters $\downarrow$ (in millions) of different methods after $N$ tasks. Results for baselines are taken from [] and [], measured on the S-TinyImg. The ResNet-18 network with no classifier head is 11.17 million parameters**
| Methods | 5 tasks | 10 tasks | 20 tasks |
| --- | --- | --- | --- |
| ResNet-18 | 11.27M | 11.27M | 11.27M |
| TAMiL [] | 22.87M | 23.20M | 23.85M |
| CLS-ER [] | 33.81M | 33.81M | 33.81M |
| LRB | 13.94M | 16.08M | 21.96M |

This section studies the network-size footprint of our framework. The base ResNet-18 has 11.17 million parameters. We report the network sizes after 5, 10, and 20 tasks for ILR and the two baselines, CSL-ER, and TAMIL in Table 4. As we can observe, ILR exhibits a linear memory growth and has the smallest memory footprint among the three baselines. Further analysis reveals that the compress layer (512x384 linear layer) and the combine layer (512x512 linear layer) contribute the most to memory usage, requiring approximately 0.20 million and 0.26 million parameters per task, respectively. Meanwhile, the weak feature extractor contribution to the total number of parameters is negligible at 0.07 million parameters per task.

### 4.5 Rectifier Quality Experiment

In this section, we utilize Principal Component Analysis (PCA) to visualize our learned latent space against the target latent space of the previous task and verify the behaviors of the rectifier in recovering past representation. Figure 3 shows the PCA plots with the first two components. As can be observed, the new representations of data from the previous task (red) after learning the current task change significantly from their original representations (green), which explains catastrophic forgetting. With ILR’s mechanism, the rectified data representations (blue) can now accurately align with the ‘true’ data representations (green), supporting the empirical effectiveness of our framework.

Figure: Figure 3: We employ principal component analysis (PCA) to visualize our rectified latent space after training on task $t$ and predicting task $t^{\prime}(t^{\prime}<t)$. By visualizing the original latent representation ($f_{t}$), the rectified latent representation ($\hat{f}_{t^{\prime}}$), and the target latent representation ($f_{t^{\prime}}$), we assess our training method’s effectiveness. The closer the proximity between our rectified latent representation and the target latent representation, the better our training method performs. The experiment is conducted by training S-CIFAR10 with $\mathcal{S}_{t}\subset\mathcal{D}_{t-1}$ and $\alpha=0$.
Refer to caption: x3.png

### 4.6 Ablation study

In this section, we investigate the impact of our alignment loss. We isolate the effect of the alignment loss by setting $\tau=0$ in Equation 1, effectively replacing it with a simple $l$-$2$ norm. To analyze the contribution of the representation regularization on rectification effectiveness, we set $\alpha=0$ in Equation 4, eliminating it from the main feature extractor’s training process.

**Table 5: Ablating $\tau$ and $\alpha$ for $|\mathcal{S}_{t}|=5000$**
| Method | Hyperparameter | S-CIFAR10 | S-CIFAR100 | S-TinyImg |
| --- | --- | --- | --- | --- |
| ILR | $\alpha=0.0,\tau\neq 0.0$ | 89.68$\pm$0.75 | 72.45$\pm$0.42 | 58.73$\pm$0.81 |
| ILR | $\alpha\neq 0.0,\tau=0.0$ | 90.82$\pm$1.17 | 81.67$\pm$0.22 | 72.07$\pm$0.37 |
| ILR | $\alpha\neq 0,\tau\neq 0$ | 94.84$\pm$0.31 | 82.05$\pm$0.29 | 72.50$\pm$0.92 |

## 5 Limitations

We have shown the potential and high utility of ILR’s CL learning mechanism in this paper. Nevertheless, ILR also has some limitations. One limitation is that ILR still maintains an additional DNN, i.e., the rectifier, which incurs an additional overhead as the number of tasks increases. Inference cost for long chain would be costly, which can be further explored with modified chaining methods such as skipping (i.e., building a rectifier every two tasks). Additionally, the best performance is achieved when having access to task $t-1$’s data. Ideally, we would want to remove this requirement; thus, future research should focus on the creation of the alignment training data. We have attempted to demonstrate that generative methods are a viable option. Furthermore, since ILR relies on the task identity to reconstruct the rectifier sequence, application to class-incremental learning settings requires either inferring task identity or forming an ensemble of predictions. The proposed ensemble solution might suffer from over-confident or under-confident classifiers. Class-incremental learning is still an open research, where more effective adaptations of our framework can be discovered.

## 6 Conclusion

This work proposes a new CL paradigm, ILR, for task incremental learning. ILR tackles catastrophic forgetting through its novel backward-recall mechanism that learns to align the newly learned presentation of past data to their correct representations. Unlike existing CL methods, it requires neither a replay buffer nor intricate training modifications. Our experiments validate that the proposed ILR achieves comparable results to the performance of existing CL baselines for task-incremental and class-incremental learning.

## Appendix

## Appendix A Detailed Experimental Setup

Computing resource. We run the experiments on a machine with 8 NVIDIA RTX A5000s.

### A.1 Baselines

As detailed in Section 4.1, we evaluate ILR against EWC (online version), LwF (multi-class) version, ER, AGEM, DER++, ER-ACE, CLS-ER, and TAMiL.

For extensive comparison, we provide rehearsal-based methods with a buffer with a max capacity of 500 and 1,000 samples, respectively. Since our method does not rely on a buffer of all task data but only an alignment set of task $t-1$ data, the forgetting can be more significant, which is not a fair comparison of ILR against other rehearsal-based methods. Therefore, we provide ILR with an alignment set of 500, 1,000, and 5,000 samples.

We replicate training settings as follows: For ER, DER++, ER-ACE, TAMiL, and CLS-ER, we employ the reservoir sampling strategy to remove the reliance on task boundaries as in the original implementation. On the other hand, ILR, AGEM, and TAMiL rely on the task boundary to learn the rectifier, modify the buffer, and add a new task-attention module, respectively. For TAMiL, we use the best-reported task-attention architecture. For CLS-ER, we perform inference using the stable model per the original formulation.

### A.2 Datasets

To demonstrate the effectiveness of our method, we perform empirical evaluations on three standard continual learning benchmarks: Sequential CIFAR10 (S-CIFAR10), Sequential CIFAR100 (S-CIFAR100), and Sequential Tiny ImageNet (S-TinyImg). The datasets are split into 5, 5, and 10 tasks containing 2, 20, and 20 classes, respectively. The dataset of S-CIFAR10 and S-CIFAR100 each includes 60000 $32\times 32$ images splitter into 50000 training images and 10000 test images, with each task occupying 10000 training images and 2000 testing images. The dataset S-TinyImg contains 1100000 $64\times 64$ images with 100000 training images and 10000 test images divided into 10 tasks with 10000 training images and 1000 test images each. We perform simple augmentation of random horizontal flips and random image cropping for each training and buffered image.

### A.3 Training

Settings. The training set of each task is divided into 90%-10% for training and validation. All methods are optimized by the Adam optimizer available in PyTorch with a learning rate of $5\times 10^{-4}$. As the validation loss plateau for 3 epochs, we reduce the learning rate by 0.1. Each task is trained for 40 epochs. For ILR, we train $h_{t}$ and $r_{t}$ using the same formulation with Adam optimizer at a learning rate of $5\times 10^{-4}$ for 50 epochs.

Weak feature extractor. We provide the architecture of the weak feature extractor $h_{t}$ in Table 6. We choose a simple design of two 3x3 convolution layers coupled with two max pooling layers.

**Table 6: Architecture of the weak feature extractor $h_{t}$. We use ReLU activation after each convolution layer. For each task, a weak feature extractor $h_{t}$ is distilled from the current feature extractor $f_{t}$. The output dimension of $h$ is 128, while the output dimension of the main feature extractor is 512.**
| Layer | Channel | Kernel | Stride | Padding | Output size |
| --- | --- | --- | --- | --- | --- |
| Input | 3 |  |  |  | $16\times 16$ |
| Conv 1 | 64 | $3\times 3$ | 2 | 1 | $8\times 8$ |
| MaxPool |  |  | 2 |  | $4\times 4$ |
| Conv 2 | 128 | $3\times 3$ | 2 | 1 | $2\times 2$ |
| MaxPool |  |  | 2 |  | $1\times 1$ |

GAN training. We use the StudioGan repository’s default implementation [, , ] of the BigGAN LeCam [] to train the network on each task of S-CIFAR100. The obtained FID score for each task is between 17 and 23. The BigGAN network has nearly 95 million parameters. During ILR training, we sampled directly from the BigGAN network.

### A.4 Hyperparameter search

For all methods, experiments, and datasets, we perform a grid search over the following hyper-parameters using a validation set. Some of the following hyperparameters are obtained directly from their original implementation to narrow down the search range.

- •
Joint, Finetuning, LwF.mc, ER, AGEM, ER-ACE: No hyperparameters
- •
o-EWC:
–
$\lambda\in\{10,20,50,100\}$
–
$\gamma\in\{0.9,1\}$
- •
DER++:
–
$\alpha\in\{0.1,0.2,0.5,1\}$
–
$\beta\in\{0.1,0.2,0.5,1\}$
- •
CLS-ER:
–
$r_{p}\in\{0.5,0.9\}$
–
$r_{s}\in\{0.1,0.5\}$
–
$\alpha_{p}\in\{0.999\}$
–
$\alpha_{s}\in\{0.999\}$
- •
TAMiL:
–
$\alpha\in\{0.2,0.5,1\}$
–
$\beta\in\{0.1,0.2,1\}$
–
$\theta\in\{0.1\}$
- •
ILR:
–
$\alpha\in\{1,2,3\}$
–
$\tau\in\{0.5,1,2\}$

**Table 7: Hyperparameters for method in Table 1**
| Method | $|\mathcal{B}|$ | $|\mathcal{S}_{t}|$ | S-CIFAR10 | S-CIFAR100 | S-TinyImg |
| --- | --- | --- | --- | --- | --- |
| o-EWC | - | - | $\lambda=100,\gamma=0.9$ | $\lambda=50,\gamma=0.1$ | $\lambda=20,\gamma=0.9$ |
| DER++ | $\alpha=0.5,\beta=0.1$ | $\alpha=0.2,\beta=0.1$ | $\alpha=0.5,\beta=0.1$ |  |  |
| TAMiL |  |  | $\alpha=1.0,\beta=1.0$ | $\alpha=1.0,\beta=1.0$ | $\alpha=1.0,\beta=0.5$ |
| CLS-ER |  |  | $r_{p}=0.5,r_{s}=0.1$ | $r_{p}=0.9,r_{s}=0.1$ | $r_{p}=0.5,r_{s}=0.1$ |
| ILR | - | 500 | $\alpha=3,\tau=2$ | $\alpha=1,\tau=2$ | $\alpha=1,\tau=2$ |
| DER++ |  |  | $\alpha=1.0,\beta=0.1$ | $\alpha=0.2,\beta=0.1$ | $\alpha=1.0,\beta=0.1$ |
| TAMiL |  |  | $\alpha=1.0,\beta=1.0$ | $\alpha=1.0,\beta=1.0$ | $\alpha=1.0,\beta=0.5$ |
| CLS-ER |  |  | $r_{p}=0.5,r_{s}=0.1$ | $r_{p}=0.5,r_{s}=0.1$ | $r_{p}=0.9,r_{s}=0.1$ |
| ILR | - | 1000 | $\alpha=3,\tau=2$ | $\alpha=1,\tau=2$ | $\alpha=2,\tau=2$ |
| ILR | - | 5000 | $\alpha=3,\tau=2$ | $\alpha=3,\tau=2$ | $\alpha=2,\tau=2$ |

## Appendix B Versatility of ILR Framework

In ILR, as the tasks arrive, conventional fine-tuning or training on the new task happens without any CL’s intervention. ILR only augments or adds to this process with a separate training of the backward-recall mechanism. The attractiveness of this framework is twofold. First, ILR allows the best adaptation on the new task to possibly achieve maximum plasticity while the backward-recall mechanism mitigates catastrophic forgetting. Second, different from previous CL approaches that modify the sequential training process (e.g., by changing the loss functions, using an additional buffer, or dynamically adjusting the network’s architecture in fine-tuning), ILR does not change the fine-tuning process, allowing the users to more flexibly incorporate this framework into their existing machine learning pipelines.

Relationship to Memory Linking.
ILR’s process of mapping newly learned knowledge representation resembles the popular humans’ mnemonic memory-linking technique, which establishes associations of fragments of information to enhance memory retention or recall. (^1^11[https://en.wikipedia.org/wiki/Mnemonic_link_system](https://en.wikipedia.org/wiki/Mnemonic_link_system)) As the model learns a new task, the feature rectifier unit establishes a mnemonic link from the new representation of the sample from the past task to its past task’s correct representation.

## Appendix C Societal Impacts

Our work has the potential to improve the capability of ML systems toward better adaptation to the changing world, which is usually the case for domains such as healthcare, education, and finance. This results in more reliable and robust learning systems. On the other hand, our framework will also have similar potential negative impacts that are often found in classification/predictive tasks, including bias, privacy, and misclassification.

## Peer Reviews

confidence: 4
contribution: 2
initial_rating: 5
presentation: 3
questions: 1. Is Incremental Latent Rectification a new CL direction?

At a higher level, learning rectifiers for each task falls into the category of model expansion of CL, as the overall model does expand, despite the objective (lines 54-58). At a lower level, the proposed method in this paper can also be categorized as a distillation method, i.e. regularization method, as the rectifiers are basically trained with feature distillation to preserve previous knowledge. I find it overclaiming to declare ILR as a new research direction.

2. The core idea might have already been explored.

In [a], the authors proposed to learn a predictor network (equivalent to the rectifier) that maps the current state of the representations to their past state to mitigate forgetting. The core idea is very similar to that of this paper with minor differences in the implementation of rectifiers. I acknowledge that the scenario is different (supervised CL and self-supervised CL). However, it is unfortunate that [a] was not mentioned or discussed in the paper. From my understanding, the main difference lies in the use of rectifiers: either we do not keep previous rectifiers but learn to generate features that are quasi-invariant to the state of the model as in [a] or we train and keep all rectifiers and then reconstruct the previous features for inference as in this paper. I am interested to see which strategy is more effective.

3. The comparison might not be sufficient

While the authors claimed several times the difference between the proposed method w.r.t. replay-based methods, the evaluation is mainly with replay-based methods. I find this evaluation contradictory. Also, the compared regularization-based methods (o-EWC and LwF) are too old. Some more recent model expansion or distillation-based methods might be considered, for instance [b].

4. The main table (Table 2) is based on Task-incremental learning, whereas Class-incremental learning evaluation is much less complete.  I am especially interested in ILR-G, as it might be much more challenging to perform generative replay in the CIL setting. And the performance gain of the proposed method in the CIL setting in Table 3 seems to be diminished.

[a]: Self-Supervised Models are Continual Learners, CVPR2022

[b]: Foster: Feature boosting and compression for class-incremental learning, ECCV2022
soundness: 2
strengths: 1. The paper is well-motivated and well developed

2. The paper is easy-to-follow, well explained
summary: The paper proposed a research direction as Incremental Latent Rectification (ILR), which consists of learning a rectifier module to match previous data representation from the current learning model. The authors leveraged a weak feature extractor and a gated function to construct the rectifier unit for each task. The rectifiers are trained with feature distillation. During inference, previous features are reconstructed by the rectifiers and forwarded to the classifier. The authors validate the effectiveness of this design through experiments on representative CL benchmarks.
weaknesses: The paper might be overclaiming the contribution, and the central idea might have already been explored but not cited or mentioned in the paper. Some experimental comparisons might be missing. Please refer to the Questions sections.

---

confidence: 5
contribution: 2
initial_rating: 3
presentation: 3
questions: The reviewer would like to check the authors' rebuttal for the comments in the weaknesses.
soundness: 2
strengths: + The motivation of exploring incremental latent representation alignment with lightweight implementation is good. 
+ The proposed alignment loss and its usage in learning are straightforward. 
+ The paper is easy to follow.
summary: This paper presents an Incremental Latent Rectification (ILR) method for continual learning, which learns a chain of backward lightweight rectifiers to approximate the latent representation of a previous task using the final feature backbone trained on all tasks. In learning, the backward 2-streaming-task latent alignment loss is based on minimizing the $\ell_2$ error. To train the latent alignment, three choices are used for the alignment sample set (examples sampled from the previous task and their latent representations, examples of the current task and the saved checkpoint of the previous feature backbone, and a generative model trained on the previous task). In experiments, the proposed method is tested under both task-incremental and class-incremental settings, where the class-incremental setting is implemented by averaging predictions from all tasks. It is evaluated on three datasets: CIFAR-10 as 5 binary streaming tasks, CIFAR-100 as 5 20-class tasks, and TinyImageNet as 20 20-class tasks. It obtains reasonably good performance.
weaknesses: - Overall, the proposed ILR relies on a chain of rectifiers in recovering the latent representation of a previous task from the final feature backbone. There are several drawbacks to be addressed: 1) It's unclear how to prevent error magnification or distributional drift during the chain; 2) The proposed $\ell_2$ error based alignment loss seems less optimal for retaining the classification accuracy on the previous tasks, since the importance of different dimensions in latent features is subject to the classifier weights; 3) The class-incremental setting uses simple averaging strategy which relies on the less practical assumption that all the tasks have the same number of classes in continual learning. 
- The proposed method is tested with small deep neural networks (ResNet-18) on streaming tasks with equal number of classes in each task. It also assumes that different tasks are not very different. These limits the applicability and potential significance of the proposed method. For example, it is unclear if the proposed method can handle continual learning on benchmarks with domain shifts such as the VDD benchmark [1].  It is also unclear if the proposed lightweight rectifier will be expressive enough when a larger backbone is used, e.g., Vision Transformer. The rectifiers are learned with significantly downsampled ($16\times 16$) images to be efficient, which seems to be limited in representation learning.  Since a common evolving backbone and lightweight rectifiers are used, there may exist strong limitations, from the perspectives of representational learning and the underlying shear complexity of continual learning in practice,  of the upper bound performance in continual learning, especially for a relative large number classes.
- There are some prior art methods missing in discussions and/or task-incremental comparisons:  Supermasks in Superposition (SupSup) [2], Efficient Feature Transformation (EFT) [3] and Lightweight Learner [4] and learn-to-grow [5]. Comparisons with those method may be helpful in accessing the potential significance of the proposed ILR. 

---
[1] Sylvestre-Alvise Rebuffi, Hakan Bilen, and Andrea Vedaldi. Learning multiple visual domains with residual adapters. In Isabelle Guyon, Ulrike von Luxburg, Samy Bengio, Hanna M. Wallach, Rob Fergus, S. V. N. Vishwanathan, and Roman Garnett (eds.), Advances in Neural Information Processing Systems 30: Annual Conference on Neural Information Processing Systems 2017, December 4-9, 2017, Long Beach, CA, USA, pp. 506–516, 2017a. URL https://proceedings.neurips.cc/paper/2017/hash/e7b24b112a44fdd9ee93bdf998c6ca0e-Abstract.html.

[2] Mitchell Wortsman, Vivek Ramanujan, Rosanne Liu, Aniruddha Kembhavi, Mohammad Rastegari, Jason Yosinski, and Ali Farhadi. Supermasks in superposition. In Hugo Larochelle, Marc’Aurelio Ranzato, Raia Hadsell, Maria-Florina Balcan, and Hsuan-Tien Lin (eds.), Advances in Neural Information Processing Systems 33: Annual Conference on Neural Information Processing Systems 2020, NeurIPS 2020, December 6-12, 2020, virtual, 2020. URL https://proceedings.neurips.cc/paper/2020/hash/ad1f8bb9b51f023cdc80cf94bb615aa9-Abstract.html.

[3] Vinay Kumar Verma, Kevin J. Liang, Nikhil Mehta, Piyush Rai, and Lawrence Carin. Efficient feature transformations for discriminative and generative continual learning. In IEEE Conference on Computer Vision and Pattern Recognition, CVPR 2021, virtual, June 19-25, 2021, pp. 13865–13875. Computer Vision Foundation / IEEE, 2021. doi: 10.1109/CVPR46437.2021.01365. URL https://openaccess.thecvf.com/content/CVPR2021/html/Verma_Efficient_Feature_Transformations_for_Discriminative_and_Generative_Continual_Learning_CVPR_2021_paper.html.

[4] Yunhao Ge, Yuecheng Li, Di Wu, Ao Xu, Adam M. Jones, Amanda Sofie Rios, Iordanis Fostiropoulos, shixian wen, Po-Hsuan Huang, Zachary William Murdock, Gozde Sahin, Shuo Ni, Kiran Lekkala, Sumedh Anand Sontakke, and Laurent Itti. Lightweight learner for shared knowledge lifelong learning. Transactions on Machine Learning Research, 2023b. ISSN 2835-8856. URL https://openreview.net/forum?id=Jjl2c8kWUc

[5] Xilai Li, Yingbo Zhou, Tianfu Wu, Richard Socher, and Caiming Xiong. Learn to grow: A continual structure learning framework for overcoming catastrophic forgetting. In Kamalika Chaudhuri and Ruslan Salakhutdinov (eds.), Proceedings of the 36th International Conference on Machine Learning, ICML 2019, 9-15 June 2019, Long Beach, California, USA, volume 97 of Proceedings
of Machine Learning Research, pp. 3925–3934. PMLR, 2019. URL http://proceedings.mlr.press/v97/li19m.html.

---

confidence: 4
contribution: 2
initial_rating: 5
presentation: 2
questions: How does the ILR method handle parameter growth when applied to large-scale datasets, such as Full-ImageNet, which involve significantly more classes and complexity? What are the potential limitations or strengths of ILR when applied to datasets with different characteristics (e.g., higher resolution, more complex patterns, or domain-specific features)?

How does the ILR method maintain its performance as the number of tasks increases significantly? What are the scaling limitations of ILR in terms of the maximum number of tasks it can effectively handle?

What is the impact of extended task sequences on memory efficiency and computational overhead?

How can the ILR method be adapted to work effectively in task-agnostic scenarios? What is the performance impact when task identification must be inferred rather than explicitly provided?
soundness: 3
strengths: The Incremental Latent Rectification (ILR) approach effectively addresses the issue of catastrophic forgetting in deep neural networks by utilizing lightweight rectifier units. This allows the model to incrementally correct and align representations from new tasks back to previous tasks, ensuring better retention of past knowledge without the need for extensive memory buffers.

ILR integrates seamlessly into existing continual learning pipelines with minimal modifications required during the training process. This flexibility allows practitioners to adopt ILR without overhauling their current systems, making it a practical solution for real-world applications.

Competitive Performance on Benchmarks: Empirical evaluations on standard continual learning benchmarks, such as CIFAR10, CIFAR100, and Tiny ImageNet, demonstrate that ILR achieves performance comparable to or better than established continual learning methods. This indicates its robustness and effectiveness in various learning scenarios.
summary: The paper presents Incremental Latent Rectification (ILR), a novel approach to continual learning that addresses catastrophic forgetting in deep neural networks. ILR utilizes lightweight rectifier units to correct and align representations from new tasks back to previous tasks, enabling effective knowledge retention. Unlike traditional methods that rely on memory buffers or complex training modifications, ILR integrates seamlessly into existing frameworks. Empirical results on benchmarks like CIFAR10 and Tiny ImageNet demonstrate ILR's competitive performance compared to established continual learning techniques, highlighting its potential for efficient incremental learning without extensive memory requirements.
weaknesses: 1. Ambiguity in Abbreviations (LRB and ILR): The abbreviations LRB and ILR used in the abstract of ICLR web are not clearly defined, which could lead to confusion. Ensuring that these terms are either defined in context or avoided in the abstract would improve clarity and help readers understand the contributions without ambiguity.

2. Limited Evaluation on Diverse Datasets: The experiments primarily focus on three standard benchmarks. While these datasets are widely used, the lack of evaluation on more diverse or complex datasets may limit the generalizability of the Incremental Latent Rectification (ILR) method's effectiveness in real-world applications.

3. Absence of Long-Term Evaluation: The experiments do not address the long-term performance of the ILR method over extended task sequences. Continuous learning scenarios often involve many tasks, and the paper does not provide insights into how well ILR maintains performance over a larger number of tasks or over time, which is critical for assessing its robustness.

4. Reliance on Task Identity: The ILR method's performance is contingent on the availability of task identity during inference, particularly in class-incremental settings. The experiments do not sufficiently explore alternative strategies for inferring task identity or handling situations where task identity is not available, which could limit the method's applicability in practical scenarios.

5. Lack of Open-Source Code: The absence of code or detailed implementation instructions limits the reproducibility and practical application of the ILR method. Providing the code would enhance the transparency of the work, allowing researchers to replicate the results and facilitating further exploration of the method's potential in diverse continual learning scenarios.

---

confidence: 4
contribution: 1
initial_rating: 3
presentation: 3
questions: Q1: How sensitive is ILR-P to the number of samples from $t-1$ saved? A buffer size of 1000 is still pretty big. 

Q2: Alg 1: Do you train for a single epoch per task, once for $f_t$ and $w_t$, and once for $h_t$?

Q3: What are the quantitative timings of the proposed method? It would be interesting to see how long inference takes for task incremental learning and class incremental learning settings, as a function of number of tasks.
soundness: 3
strengths: S1: Novelty: As far as I’m aware, the backward chaining of latent space rectification is relatively novel for continual learning. The rectifier architecture is also somewhat novel, with inspiration that seems to stem from LSTMs or GRUs. At a high level, I can understand where this sort of chaining structure can arise from sequential task learning.

S2. Multiple option for alignment set (Section 3.1.2): The authors propose 3 (actually 4, but random doesn’t work well) ways of creating alignment sets to train each rectifier unit. Given the rectifier design, all three approaches are quite sensible; each have various pros and cons. Depending on the restrictions of a particular deployment setting, one option may be preferable over others, so it’s good to have choices. Table 1 is a good summary of the various differences between the alignment methods, especially their privacy/modeling implications.

S3. Alternative rectifier architectures: There would seem to be many potential rectifier architectures possible, and the overall rectifier chaining strategy doesn’t depend on the specific instantiation (indeed, they can even be different per task, depending on task needs). The Appendix contains an exploration of alternative architectures. On the other hand, I would have liked to see more ablations. For example, is h() even necessary?

S4. Writing: The writing is generally clear in its introduction of the method, and the paper is well-organized, with good visuals. There are a few small errors (see Miscellaneous, under Weaknesses), but nothing that prevents understanding of the paper. One major exception is Section 3.3, where for whatever reason the writing quality drops substantially. I recommend revisiting that section in particular for edits. I’d also suggest taking a look at the notation, which can be at times confusing.
summary: This paper proposes Incremental Latent Rectification (ILR) for continual learning. While the main feature extractor weights remain plastic to adapt to new tasks, ILR proposes using a chain of learned feature rectifiers which sequentially map the latent space back to that of previous tasks through a sequence of learned compact feature extractors and gating functions. Because of the compact design of the rectifiers, parameter growth, while linear, is relatively small. To achieve this, these rectifiers must be sequentially aligned with the previous task. Several different alignment set options are proposed: data from the previous task (ILR-P), data from the current task as a surrogate (ILR-C), and synthetic data of the previous task from a learned generator (ILR-G). Experiments are done on sequential versions of CIFAR-10/100 and TinyImageNet, with experiments in both task incremental learning and class incremental learning settings.
weaknesses: W1. Architecture design flaws: One of my major concerns is that I’m not convinced of the overall architecture design, for a number of reasons:
- The rectification process becomes linearly slower as the number of tasks increases, due to having to propagate through a chain of rectifiers. For task incremental learning settings, this meaning propagating back to whatever task a sample is coming from; in class incremental learning settings, it’s worse, as not knowing the task ID means having to backpropagate through the entire chain every time, as outline in Section 3.4. 
- Due to its chain structure, ILR is highly vulnerable to any single poorly learned rectifier, which would break the chain and make earlier tasks unlearnable. This could practically occur if a particular task has low data, or is particularly out of domain.
- Like many expansion-like CL methods, the proposed ILR becomes less practical for long sequences (experiments consider only up to 20), and likely unusable for continuous stream continual learning settings.
- In addition to all of the above weaknesses, the other major question that leaps out to me is why this sequential rectification process is even necessary. Why not just have a separate independent rectifier per task? That’s essentially what Side-Tuning [a] does. Without the need to chaining, inference time is constant w.r.t. the number of tasks, and any failure for a single task doesn’t doom the prior ones.

W2. Parameter efficiency: While the rectifier compactness is meant to be one of the major selling points of ILR, in practice they’re actually still pretty sizable. On ResNet-18, they represent an almost 10% increase in model parameters after 10 tasks, and as mentioned earlier, will also impact inference time (see Q3). In contrast, see [b] for a method that is able to add feature transformation networks throughout the entire feature extractor (not just the end), but significantly more compactly.

W3. Alignment set design: While I do appreciate the thoroughness of multiple alignment set options, I still see a few weaknesses:
- ILR-P: Saving data from task $t-1$ is still saving data, and not much different from a replay buffer (which typically saves data across all tasks). In the strictest sense, continual learning aims to learn changing data without having to save data from the prior distribution; in many settings, even saving data from the most recent tasks is still not allowable.
- $f_{t-1}$: Both ILR-C and ILR-G use the previous feature extractor for alignment. I see a couple problems with this. a) If $f$ is large, this effectively doubles the model size during training (though not inference). b) If task $t$ is significantly different from $t-1$, there’s a good chance that the data from $t$ will not adequately represent the latent space from $t-1$, limiting the effectiveness of the rectifier alignment.


W4. Experiments: Overall, my general sentiment looking at the main experimental results is that the proposed method’s performance doesn’t distinguish itself compared to the baselines. While not every new method needs to smash the old state-of-the-art, the proposed method doesn’t convincingly outperform the baseline methods (some from 7-8 years ago), even with considerations of model size or buffer size. Some more specific comments:
- Unfair comparison on replay size: I found it a little strange that the size of the alignment set for certain ILR-P results had an alignment set of  $\mathcal S_t = 5000$, but was compared with baselines using a buffer size of 1000. Given the large impact that buffer size can have, this renders comparison with such a row unfair. I suspect this was done because the more equitable comparison at $\mathcal S_t = 1000$ looks less favorable for ILR-P, particularly in the harder class-incremental setting (though that is also the case for S-CIFAR-10). Also disappointing is even with the advantage of a higher buffer size, ILR-P is unable to convincingly claim state of the art results.
- Most experiments are on the task incremental learning setting instead of class incremental learning. Part of this is due to ILR not seeming to be a good fit for CIL, as acknowledged by the authors (Section 5).
- I’m a little disappointed that there is only really one result for ILR-G (task incremental S-CIFAR-100). Given that it’s given a prominent part of the methodology presentation, I was hoping to see more results here.

Miscellaneous:
- Fig 2: It may be helpful to indicate what $s(x)$ is in this figure
- Line 264: “we choose the simplest and most naïve” <= Simpler architectures are possible. Maybe rephrase this as “a simple and naïve”
- Line 278: “Distiction” 
- Line 293: “probability-valued network output” => “predicted output probability” 
- Line 295: “presentation” <= was this supposed to be “representation”
- Line 302: “risk” => “risking”,
- Line 302: “see” => “sees”
- $s(x)$: I find it confusing that s is being defined to mean different things. There’s probably a better way to introduce this in a technically rigorous way.
- Table 2: Should bold highest value from each AA column
- Line 374: Space before footnote
- Line 482: “it requires neither a replay buffer nor intricate training modifications” <= This claim feels like a stretch. The $t-1$ samples saved by ILR-P is effectively a buffer, with the main distinction that it exclusively comes from the most recent previous task. Similar “intricate” is a vague term. While I agree it’s not that complex, Alg 1 still has more steps than many other continual learning methods.

[a] Zhang et al. “Side-Tuning: A Baseline for Network Adaptation via Additive Side Networks.” ECCV 2020. \
[b] Verma et al. “Efficient feature transformations for discriminative and generative continual learning.” CVPR 2021.