Continual Learning by Modeling Intra-Class Variation
Authors: Longhui Yu
Tianyang Hu
Lanqing HONG
Zhen Liu
Adrian Weller
Weiyang Liu
Venue: Accepted by TMLR ()

Abstract: It has been observed that neural networks perform poorly when the data or tasks are presented sequentially. Unlike humans, neural networks suffer greatly from catastrophic forgetting, making it impossible to perform life-long learning. To address this issue, memory-based continual learning has been actively studied and stands out as one of the best-performing methods. We examine memory-based continual learning and identify that large variation in the representation space is crucial for avoiding catastrophic forgetting. Motivated by this, we propose to diversify representations by using two types of perturbations: model-agnostic variation (i.e., the variation is generated without the knowledge of the learned neural network) and model-based variation (i.e., the variation is conditioned on the learned neural network). We demonstrate that enlarging representational variation serves as a general principle to improve continual learning. Finally, we perform empirical studies which demonstrate that our method, as a simple plug-and-play component, can consistently improve a number of memory-based continual learning methods by a large margin.

Published in Transactions on Machine Learning Research (01/2023)
Continual Learning by Modeling Intra-Class Variation
Longhui Yu School of ECE, Peking University
malonghuuiastu..ku...tee
Tianyang Hu, Lanqing Hong" Huawei Nooh's Ark Lab
Slowwwei. com
Zhen Liu
Mila, Universilé Montréal
Adrian Weller
au665@cam..cc uk
University of Cambridge and The Alan Turing Institutt
Weiyang Liu
w13960cam.cc uk
University of Cambridge and Mox Planek Institute for Intelligent Systems
Tübingen
Reviewed on OpenReview: https: // openreview. net/ forun? id= &DafGaMYVr
Abstract
It has been observed that neural networks perform poorly when the data tasks presented sequentially. Unlike humans, neural networks suffer greatly from catastrophic forgetting, making it impossible to perform life-long learning. To address this issue, memory-based continual learning has been actively studied and stands out as one of the best-performing methods. We cxamine memory-basee based continual learning and identify that large variation in the representation space is crucial for avoiding catastrophic forgetting. Motivated by this, we propose to diversify representations by using two types of perturbations: model-agnostic variation (f.e., the variation is generated without the knowledge of the learned neural network) and model-based variation (i.e., the variation is conditioned We demonstrate that enlarging representational variation serves as general principle to improve continual Icarning. Finally, we perform empirical studies which demonstrate that our method, as a simple plug-aud-play component, can consistently improve a number of memory- based continual learning methods by a large margin.
the learned neural network).
1 Introduction
Recent years have witnessed tremendons success achioved by deep neural networks in a number of applications ranging from object recognition (Krizhevsky et al., 2012) to game playing (Silver et al., 2016). Despite such success, these models stay static once Iearned and in case of new incoming data, retraining required, which often suffers from catastrophic forgetting (French, 1999). A naive and highly unscalable solution is to include both old and new data during retraining. Inspired by how humans learn in their lifespan, continual learning aims to learn concepts in sequential and lifelong fashion. In contrast to standard training, continual learning relaxes the i. assumption for training data, which has long been one of the major bottlenecks for existing machine learning models (Hassabis et al., 2017).
The core challenge in continual learning is how to efficiently acquire new knowledge while retaining the old. This problem is closely connected to the cabblitt-plasttcite dilemma (Ditzler et al., 2015; Grossberg, 1982; Grossberg et al., 2012) in biological systems, where system should be plastic enough to absorb new knowledge and at the same time stable enough not to catastrophically forget the previous experience. Analogously, the goal of continual learning is to achieve an appropriate trade-off between stability and plasticity in neural network training. Earlier methods to achieve this trade-off can be roughly categorized as regularization-ban
The code made publicly available https: / //github.bb.////////g con//yulonhuu//OOAA

---

Published in Transactions on Machine Learning Research (01/2023)
methods (Li & Hoiem, 2017; Rebufii et al., 2017; Hou et al., 2019; Wu et al., 2019; Yu et al., 2020), dynamic architecture- methods (Rajasegaran et al., 2019; Hung et al., 2019; Yan et al., 2021) and memory-based methods (Rebuffi et al., 2017; Buzzega et al., 2020; Tiwari et al., 2022; Riemer et al., 2018). Memory- based continual learning preserves learned knowledge by storing a handful of past data points (f.e., protolypes"), and is able to achieve competitive performance while only requiring minimal modifications to standard training. Interestingly, wemory-based methods also serve as an effective model for approximating the complementary learning systems (MeClelland et al., 1995; O'Reilly et al., 2014; O'Reilly& & Norman, 2002) where episodic memories are retained by regular experience replay.
Avange fan Clas Argulla Desiatin
Old Clases New Clases
200
DER+
ER-ACE
Moki-ggaett: Modditaad MOCA
MOCA
Figure 1: Average intra-class angle deviation (degree) within old classes new classes. As example, use Caussian perturbation for model-agnostic MOCA and adversarial represen- tational perturbation for modal-based MOCA. All MOCA variants are applied to ER. (Riemer al., 2018). This is computed by final models.
However, approximating the original training data distribution
with few prototypes inevitably results in a lack of intra-class diversity. Figure I compares the angle variation of intra-class features (i.e., the average angle between intra-class features and their corresponding class mean) between some popular contimual learning method, joint training and our methods, validating that old classes are substantially less diverse in continual learning. Due to the lack of intra-class diversity, we identify two phenomena in memory-bascd continual learning: representation collapse and gradient collapse, which lead to poor generalization on past data. Representation collapse corresponds to the phenomenon where the representations from old classes shrink to a straight line during training (i.e., it can be viewed as point projected on hypersphere). It happens due to severe overfitting to a few past training data. This is also theoretically grounded in the concept of neural collapse (Papyan et al., 2020). Figure 2 gives a 2D feature
demonstration for representation collapse. Gradient collapse, the phenomenon that the gradicnts of data collapse in a few directions, is a direct consequence of representation collapse since the direction of the representative determines that of its gradient. We em- pirically verify the problem of degenerated gradients in Figure 3 by showing that gradients w.r.l representa- tions from old classes are intrinsically low-dimensional and contain limited information. This observation mo- tivates us to increase the intra-class diversity during training to alleviate these two detrimental phenomena and induce regularization that prevents overfitting to past. data. To this end, we propose a simple yet. ef- fective framework, called MOCA, which models the intra-class variation in the representation space with only a few prototypes. We emphasize that MOCA is quite different from standard data augmentation, since we perform perturbation in the representation space rather than the imput data space. Performing perturba- tion in the representation space shares similar spirit to Manifold mixup (Verma et al., 2019).
20
2.5
0,-
-10-
-25
-18
68
5.5
20
Fo ofl Thaning
10120 Feazo Modddd MOCAla Traning
03-
(1) FOTTFFOteOLEERRR.
MMM00 lood MDCA
Figure 2: 2D feature visualization of ER (Riemer et al., 2018) (a,c) and ER with model-based MOCA (WAP) (b,d). We construct a simple continual learning task on MNIST, where the first 5 classes are old classes, and the other 5 classes are new classes. We can observe MOCA indeod cnlarges the training feature variation, and the testing features generated by MOCA are more discriminative and well separated.
Another motivation behind MOCA comes from our intuition that better mimicking of the gradients standard i. training leads to better generalization in continual learning. By looking into how the original í. gradients are computed, we find that feature dynamics (i..,, representation al different. iterations) and labels can largely determine the back-propagation gradients. If we can approximate or even recover the feature dynamics of f. joint training in the continual learning setting, catastrophic forgetting can be greatly alleviated. However, this is an intrinsically difficult task, since the feature dynanics of standard training are high-dinensional, model-dependent and non-stationary.
We prototypes to represent the raw data points the paper, which differs from few-shot learning (Snell al., 2017).
2

---

Published in Transactions on Machine Learning Research (01/2023)
MOCA takes one step closer to this goal by explicitly modeling and effectively en- larging intra-class representation variation. We design two types of intra-class modeling methods: model-agnostic MOCA and model- based MOCA. Both MOCA variants aim to diversify the intra-class representation vari- ation. Specifically, model-agnostic MOCA diversifies the representation by modeling the intra-class variation with a generic para- metric distribution (e.g., Gaussian distribu- tion), and model-based MOCA takes the previously learned model (f.e., a neural net- work that is trained with the old data) into consideration when diversifying the intra- class representation. For model-agnostic MOCA, we consider Gaussian distribution and von Mises Fisher (vMF) distribution
(200)
Model- MOCA Modilitaut MOCA
Log Singala Volue
20 10*
Lag Singaler Value
60
100
50
100
Grudiene Dimmznsion
Gralion Dimenvion
(a) Comparison Different Methods
(3) Comppanin of Different Merrory Size
Figure 3: Singular values of (a) the training gradients for different methods (MOCA is trained on top of ER), and (b) the training gradients of ER (Riemer et al., 2018) under different memory size (200, 2000, 5000, 10000). We construct a simple contimual learning task for CIFAR-100, where 50 classes are old classes, and the other 50 classes are new classes. We can observe in (a) that both model-agnostic MOCA (Gaussian) and model-based MOCA (WAP) produce gradients with richer directions, and in (b) that larger memory size leads to more informative and diverse gradients, approaching to joint training. Full results are in Appendix D.
for modcling the intra-class variation; for model-based MOCA, we model the intra-class variation by a perturbation dependent on the trained network parameters. To generate such a perturbation, we propose coopuut-based augmentation (DOA), aeiggat-adversarial perturbation (WAP) and variation transfer (VT). DOA, inspired by Dropout (Srivastava et al., 2014), augments the data by randomly masking the neurons in a neural net and then viewing the resulting representation as the intra-class perturba- tion. While DOA perturbs neurons via random masking, WAP perturbs the neurons in an adversarial fashion. Different from DOA and WAP, VT assumes that intra-class variations are similar across different classes and models the variation in old classos with the variations in new classcs. Our contributions are listed below:
three different methods:
Driven by the goal of approximating the gradients of ii.dd joint training, we propose MOCA, a simple yet effective framework to model intra-class variation for continual learning, where both model-agnostic and model-based variations are extensively studied.
For model-agnostic MOCA, we propose two variants: Gaussian modeling and vMF modeling. For model-based MOCA, we propose three variants: Dropout- augmentation, variation transfer and weight-ad perturbation. Each variant has different modeling assumption and flexibility.
MOCA serves as a plug-ant aung-and-payy method for based continual learning, which effortlessly improves the empirical performance under offline, online and proxy-based settings. We empirically investigate the performance of MOCA and provide guidance on which variant is likely to work well in different settings.
2 Related Work
Regularization-basss approaches aims to acquire new knowledge while penalizing one of the following three entities: the previously learned parameters, gradient directions and activation outputs. The basic idea of parameter-basod rogularization method is to resist the change of the important paramcters of the Icarned model. Hence, some recent work (Kirkpatrick et al., 2017; Aljundi et al., 2018; Zenke et al., 2017; Benzing, 2022) explores different measurements of the parameter importance. Similar to our work, gradient- regularization methods (Lopez-Paz & Ranzato, 2017; Chaudhry et al., 2018; Saha et al., 2021) try to restrict the update directions in common space where gradients from old classes and new classes have the largest inner product. Some of these methods also aim to separate the network parameters for old tasks and new tasks by adjusting training gradients. For instance, Farajtabar et al. (2020) project the new training gradients to the orthogonal space of the old training gradicnts to minimize the change in neural activations for old tasks. Similarly, Adam-NSCL (Wang et al., 2021) first finds the mull space for old tasks by analyzing the covariance matrix of all the input features for each layer and then projects the gradients into the null space to prevent forgetting. The last type of method, activation-based regularization (Li & Hoiem, 2017; Rebuffi et al., 2017; Hou et al., 2019; Wu et al., 2019; Yu et al., 2020), leverages the information from the activations obtained from past tasks using strategies similar to knowledge distillation (Hinton et al., 2015). A notable
3

---

Published in Transactions on Machine Learning Research (01/2023)
example is iCaRL (Rebuffi et al., 2017), which uses knowledge distillation to transfer the old knowledge in the memory buffer by herding (Welling, 2009) from the previous model to the learned model. A number of methods (Wu et al., 2019; Hou et al., 2019; Liu et al., 2020; Douillard et al., 2020) take a path similar to iCaRL and utilize an extra model with a memory buffer to prevent forgetting. DER (Buzzega et al., 2020) improves iCaRL by preserving the old logit activations rather than ground truth labels with a distilled memory buffer. Additionally, Mirzadeh et al. (2020) studics how different training regimes (e.g., learning rate, batch size) can affect the continual learning performance. Mirzadeh et al. (2022) discusses the impact of architectures on continual learning. Different from regularizatiion-basel methods, we focus on the problem of representation and gradient collapse and address it by modeling intra-class variation of old classes.
approaches. Similar to regularization- based approaches that aim to separate network parameters, gradients and activations for both old and new classes, Dynamic-architecturs based approaches aim to directly separate the network parameters into subsets of task-specific ones, For instance, PNN (Rusu et al., 2016) freezes the parameters trained on old tasks but introduces new trainable sub-networks to the existing trained network to adapt to new tasks. In addition to the simple work expansion, Rajasegaran et al. (2019); Hung et al. (2019); Cao et al. (2022) perform additional steps to freeze or prune the old network parameters to prevent forgetting, while HAT (Serra et al., 2018) utilizes hard attention mask to constrain the amount of updates of important neurons. DynamicalER (Yan et al., 2021) takes a slightly different approach by sequentially training independent. networks for each task. Then the learned represcntations are also used encourage the difference between the representations of old and new lasks. von Oswald et al. (2020) uses dask-conditiones hypernetworks to generale network weights. Different. from the dynamic- aeraami--rrchittctureeeeeeee based approaches that introduce new network structures for new tasks, our paper aims to prevent catastrophic forgetting in a parfecter-cffcient and scalable way without any significant modification to the existing neural archilecture.
Dynamic-architectur--bee
Memory-based approaches maintain a buffer storing a small subset of past data to improve continual learning and achieve appcaling performance in both offine and online continual lcarning. During training, both the buffer data and the incoming new data are included in the constraint of the replay buffer, it is important to design good sample selection strategy so that the buffer stores the most representative data to prevent forgetting (Wang et al., 2022). Experience Replay (ER) (Riemer et al., 2018) establishes simple baseline by storing randomly selected subsets of data into the memory buffer. MTR (A (Aljundi et al., 2019a) selects the data whose losses are most sensitive to the data of the next task. GSS (Aljundi et al., 2019b) proposes to build memory buffers with the largest sample diversity and gradient variance. ASER (Shim et al., 2021) leverages Shapley value (Roth, 1988) to select buffer data. GCR (Tiwari et al., 2022) proposes a gradient-
Due to the memory
selection strategy by approximating the gradients of all the data seen so far with respect to current model parameters. With memory buffers, regularization-basse methods can better utilize the old activation knowledge (Rebuffi et al., 2017; Buzzega et al., 2020) and old gradient information (Lopez-Paz & Ranzato, 2017; Wang et al., 2021; Farajtabar et al., 2020). Instead of storing old samples, DGR (Shin et al., 2017) trains a generative model (Goodfellow et al., 2014a) to synthesize old data.
Our work is mostly related to the masery-based approaches. Existing memory- based approaches focus on either regularizing the old knowledge (Buzzega et al., 2020; Rebuffi et al., 2017; Caccia et al., 2021) or sampling the most representative data points (Riemer et al., 2018; Aljundi et al., 2018; 2019b). Taking different perspective, we identify general principle to improve continual learning bridging the large variation gap between the representations of the buffer data (f.e., old data) and new data. We discover that such a gap results in representation and gradient collapse which is harmful to generalization in continual learning. Motivated by this observation, MOCA models the intra-class representation variation such that the representation and gradient variation of the data in the buffer can match the i.i.d. joint training scenario.
3 Why Can Modeling Intra-class Variation Help Continual Learning?
Preliminaries. In this section, we briefly present the background knowledge for memory-based offline continual learning, proxy-based continual learning and memory-based online continual learning. Let Tı, T2,..., Ti represent the sequence of continual learning tasks. Each task has i.i.d. samples from the task data distribution D', and the composed training dataset is denoted by (x', D', where x' is the input data and y is the label. The new classes in the t-th task Te is denoted by C. = {Ck,- ++1, Cai-kkk-tt .2...... Cki J set of
4

---

Published in Transactions on Machine Learning Research (01/2023)
(ks- - - classes. We aim to find model, comprised of a feature extractor and a top classifier, that can perform well among all the learned tasks. More specifically, we consider a neural network he parameterized by 0, the output of which ho(x) is the fcature representation of x to be fed to the classifier layer g (parameterized by Φ). go (x)) a vector representing the predicted confidence of æ for the total & classes. k is the total number of classes till the task Tr. The general objective of continual learning is:
Te (xr wD (l
min Σ 0.0
(1)
where C is some loss function for classification. Usually, L is chosen be the cross-entropy between Iø (hohh(m) (x)) and Ey: formally written as (ce(0o(ho(z))))
llog exp(go(ho(=)))))
>. (xp(so(ha
Under the continual learning setting, the old task data while learning the current task Tr. The lack of the old class data causes overfitting to task Tr and catastrophic forgetting of previous knowledge. To prevent catastrophic forgetting, memory- offline continual learning (e.g., (Buzzega et al., 2020)) usually preserves replay memory buffer (a .yol) E M of limited size and optimizes the following general training objective:
~ 1,. 13 are mostly unavailable
min Ers y') )' [Coe (co )), y')] + B youd wewooee (ha y.ld)] 0.6
(2)
In proxy-based continual learning (e.g., (Zhu et al., 2021)), we consider the memory- scenario where old task data gold can not be stored. Instead of the old task data wold, the mean representation fo for each class E (21,02,..... Ch is stored and reusable. In this case, the general training objective is:
min (a (((d)))"))ii(//o (Loo ())())))((())))))))))))))))))))) Σ (o 0.6
(3)
Memory-based online continual learning (e.g., (Caccia et al., 2021)) is more memory- frienryyrreenly setting, which has the same training objective Equation but all the training data can only be sampled and used once.
3.1 On Approximating Joint Training Gradients with Intra-class Representation Modeling
We start by analyzing the back-propagated gradients w.r.l. the repre- sentation ho(x) and obtain that
fu
dLe @he(
(ho(ho()))
= (a Softmax(so((h(())) egy
ahe(ar)
(f)
(4)
(a) Original
Modclaggnstic MOCA
(b) Medai-hased MOCA
= [f (oftmax(go(f)) - Ey)
0f
Figure 4: Graphical models intra- class representation modeling for (a) original memory-hasen continual learn- ing and (b,c) the MOCA framework.
where Softmax(2) = E exp(w:))
exp(mr)
exp(we)
exp( E R 1xd
(v B Ixd
is a d-dimensional vector) and o denotes the feature representation of x (L.e., f = ha (z)). From Equation 4, we can observe that the back-propagated gradients for updating the neural network hg is uniquely determined by f. y and Φ. & is typically parameterized as a linear classifter which is easy to compute given f or can be well approximated with et al., 2019). Therefore the problem of approximating the original gradients, to large extent, reduces to modeling the intra-class representation, i.e., finding approximate f D(y, 0) where D(y, 0) denoles the feature distribution of the y-th class for the model 0. One may notice that to approximate the gradients, we could either approximate the distribution of f or the distribution of x. We seek to approximate the distribution of f rather than the distribution æ because the latent space produced by neural networks is more regularized and feature distributions for different classes also tend to be similar (see Figure 2 as an example). In contrast, modeling the distribution of is essentially to build a generative model for raw images, which itself is a highly challenging task especially with only a limited amount of images available. The construction of the memory buffer (Rebuffi et al., 2017) is essentially to approximate the distribution of
class centroids (Wen
5

---

Published in Transactions on Machine Learning Research (01/2023)
a with a few representative examples. Taking advantage of the memory buffer, we instead propose to model the intra-class representation with f = fM + Af" where I' denotes the prototypes from the y-th class in the memory buffer (i.e., fM E {ho( ... .......o hxx,)) where xu is the i-th prototype of the y-th class) and f is the deviation belween the actual representation and the protolype for the y-th class. In other words, original memory-
continual learning approximates the distribution of only with prototypes fMr from the memory buffer, while MOCA additionally approximates the distribution of A with either a generic distribution or model-based variation, as shown in Figure 4.
3.2 Why Is Modeling Representation Better Than Modeling Raw Input Images?
To simulate intra-class variation of features in i.i.d training, Equation 4 suggests that we can model either the distribution of the raw input images I or the distribution of the representation f. We argue that modcling the intra-class representation variation is much casier than modeling raw input images based on the following reasons. First, the dimensionality of the representation space usually much lower than that, of the raw input images, making easier to model the intra-class variation. Second, the representation space is more regularized, since it converges to the simplex equiangular tight frame (Papyan et al., 2020) which is also equivalent to hypersphericaalyy uniform space (Liu et al., 2018a; Lin et al., 2020; Liu et al., 2021c;b). Moreover, we empirically observe from Liu et al. (2016; 2018b); Wen et al. (2019) that the intra-class representations, when projected onto a unit hypersphere, are centered around the class mean and distributed like a vMF distribution. This observation directly motivales us to model the intra-class variation with a parametric distribution in the representation space, leading to model-agnostic MOCA, Last, the features from different classos share similar hyperspherical variation in the representation space (empirically validatod by Liu al. (2016)), while variation in the raw image space is completely different for different classes.
3.3 Modeling Intra- Class Representation Variation as Implicit Data Augmentation
Modeling intra-class representation variation can implicitly serve a form of data augmentation. Since we aim model the distribution of A in MOCA, the resulting baok-propagated gradient is computed by the feature f%r + A This new gradient can be viewed as being generated by a augmented input data i*:
a² := arg min (+) f% - 1 min || (i) ho 1
(5)
where #* can generate the same gradient as the perturbed representation ha( + f once the minimization can attain zero (x denotes prototype from the y-th class).
There are multiple solutions for the augmented data a given different x and 0. Even for the same set of æ and 0, & will also have different solutions due to the highly non-convex nature of neural networks, but all these solutions lead to the gradient as induced by the same Af. Therefore, MOCA can be viewed generating numerous equivalent augmented data at the same time by perturbing the representation space, which is quiet different from explicit data augmentation. This many-to- one mapping property of neural networks is one of the reasons that modeling intra-class variation in the representation space is easier than modeling in the raw data space. The same intuition has also been adopted in natural language processing when the raw data (e.g., sentence) is hard to augment (Gao et al., 2021). With the implicit data augmentation induced by MOCA, representation collapse can be greatly alleviated.
(0) Original Image
Model-igronic
(c)
Figure 5: Some implicit augmented images for the old class "bird". For model-agnostic MOCA, we normal- ized Caussian distribution. For model-based MOCA, use WAP. The augmented examples are generated by pretrained generative model. We ensure that these aug- mented images produce the same feature representation as MOCA, so they share same propugated gradient. Detailed visualization procedure given Appendix B.
4
MOCA: A Framework for Modeling Intra-Class Variation
4.1
Framework Overview
Aiming to model intra-class variation in the representation space, MOCA produces augmented representations with f ho( + Af where denotes prototype from the y-th class and A is the deviation added by MOCA. For better modeling expressiveness, there could be multiple prototypes per old class. Model-agnostic

---

Published in Transactions on Machine Learning Research (01/2023)
MOCA generates Af using& a parametric distribution without the knowledge of the model 0, and model-based MOCA generates Af by taking the model 0 into consideration.
Untrainable
Modeling hyperspherical variation. To enable an effective modeling of Af, we draw inspirations from the observations in (Liu et al., 2017b; 2018b;a; Chen et al., 2020) that geodesic distance hypersphere is well aligned with perceptual difference, and propose to model the distribution Af on the hypersphere in MOCA. We argue that projection on hypersphere can limit the space of A to a scmantically meaningful onc. To this end, we additionally perform a projection step on f to ensure that its magnitude is the same as ho()), yielding the final augmented
MOCA
Af
Trsinable
Infreence
Back prop
New Class
h
g
Neural Encoder
Linear Classifier
Represeniation Space
Figure 6: Inference and back-prop in MOCA.
feature as f = [[hp(*)+AfI] (2)( + Åf) where Åf is a unconstrained perturbation. We then end up with the following formulation for the augmented feature on the prototype feature hypersphere:
[*]]]]]
ho (
+ (1)o((z)) - | ho))) IIha (a:) 2f) l1ho(2)) + ASll"
Augmented Feature
Protatype Feature
Hyperspherical Augmentation Af
where A denotes the perturbation on the hypersphere (f.e., angular perturbation) and it does not change the magnitude of the original prototype feature ha(x)) (i.e., |[ = (x)))) With the hypersphere constraint, MOCA reduces the difficulty of finding good Af. Morcover, such a design implicitly constrains the intra-class represeniation modeling to be semantic (Liu et al., 2018b; Chen el. al., 2020).
Back-propagated gradient in MOCA. Taking advantage of the augmented feature, we design the &c.e
back-propagated gradient w.r.t. the representation to be 0c.- dcee + dCen af ahe(w) a&f instead of the original ahe( illustrated in Figure 6. This gradient is used to update the parameters O of the encoder h(-). From the pack-propagation perspective, MOCA can also be viewed as a gradient augmentation method. We show that the augmented gradient can well prevent both representation collapse and gradient collapse, leading to a discriminative feature representation in continual learning.
Usefulness of the model for intra-class variation. To model the unconstrained perturbation ås, we can use a parametric distribution such as Gaussian distribution and vMF distribution. This leads a simple variant: model-agnostic MOCA where Åf does not depend on the current model O. However, an accurate modeling of Âf should take the model 0 into consideration, because the representation f ha(#) is al always conditioned on 0. To leverage the current model parameters 0, we come up with an advanced variant: model-based MOCA where Åf is generated based on 0. Our experiments comprehensively validate the offectiveness of both model-agnostic MOCA and model-based MOCA.
4.2 Model-agnostic MOCA
For model-agnostic MOCA, we propose to use two simple distributions: Gaussian distribution and vMF distribution to model the intra-class variation the representation space.
Isotropic Gaussian distribution. To enlarge the variation of old class feature space, we propose to model Åf with an isotropic Gaussian distribution. We denote the prototype feature (from old classes) produced by the neural network as (2 where oll is the stored prototype for old classes. This model-agnostic MOCA variant is named as Gaussian for simplicity and the final perturbed feature f can be written as
f = [=
||| Ps (P + x))
(6)
where 6 ~~ (0, 1) is the isotropic Gaussian noise with the same dimension as the original old-class feature, Ps(v)) denotes the projection operator onto the unit hypersphere that outputs arg min 1o-voll3 (usually we have that Ps(v))= = ) and X denotes the variance and also controls the perturbation magnitude. The inner projection that applies ho (x ensures the consistency of À for different prototypes.
von Mises-Fisher distribution. Since we are modeling intra-class variation hypersphere, the Mises Fisher (yMF) distribution appears to be a valid choice. The vMF distribution is parameterized by

---

Published in Transactions on Machine Learning Research (01/2023)
mean direction and a concentration parameter R. We name this model-agnostic MOCA variant as vMF and we can produce the perturbation with arbitrary angle between the original prototype feature by adjusting the concentration parameter R. The augmented feature is written as f = o (x)l)) Ps(Ps(ho(zol))) + x c). where the random variable e follows the probability density function shown below:
ka/2-1
k(Elu, = (2m)d/2la/22210 exp(Eep T c), 1 P== P
where I, denotes the modified Bessel function of the first kind at order e and d is the dimension of the feature space. The vMF distribution becomes more concentrated with larger k. When = 0, the vMF distribution reduces to uniform distribution on the hypersphere. The sampling of the vMF distribution follows the procedure of Ulrich (1984); Davidson et al. (2018) and the detailed algorithm is given in Appendix A.
4.3 Model-based MOCA
g
Model-agnostic MOCA can diversify the intra-class distribution of old classes using generic parametric dis- tribution without considering the spe- cific model parameters. Therefore, model-agnostic MOCA has to treat all the feature dimension equally, which might not match the intrinsic feature distribution. To fill up this gap, we further consider model-based MOCA where the feature augmenta- tion is generated based on the current model parameters. By considering the model's knowledge, model-based MOCA can augment the feature with informative directions (unlike the isotropic distribution used in model- agnostic MOCA). To this end, the basic idea behind model-based MOCA is to generate the augmentation Af by perturbing the encoder (z)). There are generally two ways to perturb hg(x) - perturbing cither the model parameters or the input a. Conceptually, we have the following general feature perturbation models:
g
Dropoun
Samping
(a)
Baseline
(b) Model-agnostic MOCA
(c) Model-based MOCA (DOA)
g
update
vaniatin in new classes
(d) Model-based MOCA (VT)
(c) Model-based MOCA (WAP)
Figure 7: Illustration of different MOCA variants.
Perturbation I: Âf = Azhe(a)) soh)+ Perturbation II: Áf = \1 - >2he( + Ar),
(8)
where could be samples from old classes new classes (depending on the specific continual learning setting). We can observe that both perturbation models make the feature augmentation Âf dependent on the model parameters O. For the first perturbation model, we derive two instances: Dropout-based augmentation and weight-adversarial perturbation. Inspired by recent progresses in contrastive learning of natural language (Gao et al., 2021; Liu et al., 2021a), DOA uses Dropout (Srivastava al., 2014) to generale A0, which is essentially to randomly mask out neurons. Different from DOA, WAP uses adversarial training (Szegedy et al., 2013) to generate AO such that the resulting feature becomes closer to the decision boundary. For the second perturbation model, we make use of the accessible variation in the new class and propose to directly transfer the feature variation to the old classes, leading to variant called variation transfer.
Dropout-based augmentation. Dropout (Srivastava et al., 2014) was initially used for regularizing neural networks to avoid overfitting. Recently, it has been discovered that Dropout can serve as a form of data augmentation (Gao al., 2021). Inspired by this, we utilize Dropout diversify the representation distributions for old classes. Specifically, we have that Âf (1) - A where Dropout denotes the Dropout operator applied on the network O and X1, A2 hyperparameters (In this paper,
\1 22 = 1). After simplifying hyperparameters and hyperspherical projection, we can write DOA
f ho (1))) Ps (Ps (bdd)) + > Ps (z)))
where À controls the augmentation strength. We note that æ in Equation can be either prototypes from old classes (æ samples from new classes nmw) We term the former case as DOA-old and the later one as DOA-new, For DOA-old, we perform the inference twice for prototypes of old classes, with one full
8

---

Published in Transactions on Machine Learning Research (01/2023)
inference to output (a("") and one Dropout inference (where neurons are randomly masked to zero) to output (DDooout(e)) (a)). The intuition behind DOA-new is to take advantage of the representation richness in the new classes and transfer such information to diversify the representation space of old classos. Therefore, DOA-new takes both the model 0 and the feature manifold of the new classes inlo account. By considering the feature manifold of the new classes, we expect that DOA-new can introduce more informative gradients that aims to separate features from old classes and features from new classes.
Weight-adwersarial perturbation. While Dropout randomly perturbs the network parameters 0, we propose an alternative way to perturb 0 - adversarially generate AO in the first perturbation model (Equation 8). Specifically, we have that Å = X1 (a)) - )2ho+ where AO is generated adversarially to minimize the confidence of the new class. Then we use the following model in WAP:
f f= (ha )|| Ps (Ps (ho(z) + X Ps (ho+ (ho+so(z=ld)))
(10)
where we obtain Ao by performing projected gradient descent to optimize the following objective:
A arg min Lee (g+ (ho+so(x=)d)) , )
(11)
| Se
where AO is defined as a solution. In general, WAP aims to perturb f by generating AO in an adversarial fashion such that the input data can move closer to the decision boundary.
Despite focusing on different applications, WAP has intrinsic connections to (Wu et al., 2020; Zheng et al., 2021) where adversarial weight perturbation is shown to converge to flat minima (Hochreiter & Schmidluber, 1997) and is beneficial to generalization. Different from (Wu et al., 2020; Zheng et al., 2021), WAP perturbs the network weights adversarially based on the new class label yeew, , making it good preventing catastrophic forgetting. WAP first finds a new set of network weights 0adv 0 + AO that catastrophically forget the knowledge of old classes and confuse the old classes with the new ones. Then WAP uses Oadv to generate intra-class perturbation such that the model can be regularized away from Oddv and the concepts of old and new classes can be better separaled. In general, WAP seeks to model the intra-class variation following the direction to the decision boundary (as opposed to the isotropic direction in DOA), which leads to more informative gradicnts to learn discriminative fcatures that well separate old and new classos.
Variation transfer. We now consider the second perturbation model in Equation 8. Our core idea is to transfer the variation in new classes to diversify the intra-class variation in the old classes. Specifically in Equation 8(II), we let x be virtual sample that corresponds to the mcan feature of the new class (úe.. (=ew) and Ax be the difference between individual feature in the new class and the virtual sample (i.e., new n.ww). After simplifying hyperparameters, we have the following model for VT:
f= he (ld) ||| Ps (P' (z)d)) + X Ps ((ha(w hh(()
(12)
where ho (a denotes the mean feature that is also equal to (xreew = Fe ho uew.. VT implicitly imposes an assumption that intra-class representation variations for different classes are similar.
4.4 Discussions and Intriguing Insights
Connection to large-margin softmax. MOCA demonstrates the effectiveness of modeling intra-class representation in continual learning. The intuition of why MOCA can well regularize the representation space also comes from the scrics of works in large-margin softmax (Liu et al., 2016; 2017a;b; 2022; Wang et al., 2018;;b; Deng et al., 2019). The central idea of marge- softmax can be interpreted as constructing a hard virtual feature that is close to the decision boundary, and optimizing this virtual sample amounts to creating large between-class margins (see justification in Appendix C). MOCA adopts a similar approach to create margins between old classes and new classes such that the old classes will not be forgotten catastrophically.
Why intra-class modeling is difficult yet possible? Modeling intra-class representation in general a highly nontrivial task, because it requires us to jointly consider input distribution, properties of neural networks, objective functions and optimizers. Fortunately, recent theoretical studies (e.g., neural collapse (Papyan et al., 2020; Lu & Steinerberger, 2022) and uniformity (Wang & Isola, 2020; Liu et al., 2021c)) discover a regularity
9

---

Published in Transactions on Machine Learning Research (01/2023)
of hyperspherical uniformity in the representation space. Moreover, empirical studies (Liu et al., 2018b; Chen et al., 2020) also show that the intra-class representation is distributed like a vMF distribution. Motivated by these studics, MOCA proposes a unified framework and specific algorithms to model intra-class variation.
Open problems. We only consider a few simple variants and it remains an open problem to design a better variant. Another open problem is the structure of representation space, Stronger regularities for intra-class modeling (e.g., discrete (Van Den Oord et al., 2017), causal Schölkopf et al. (2021)) may improve MOCA.
5 Experiments and Results
Experimental settings. In this section, evaluate existing competitive baselines and different MOCA variants on CIFAR-10 (Krizhevsky et al., 2009), CIFAR-100 (Krizhevsky et al., 2009) and TinylmageNet (Deng et al., 2009). We consider three different continual learning settings, i.e., (1) offline continual learning, (2) online continual learning, and (3) proxy-based continual learning. For offline and online continual learning, we divide the dataset into five tasks for CIFAR-10 (two classes per task) and CIFAR-100 (20 classes per task), and divide the dataset into 10 tasks for TinyImageNet (20 classes per task). For the proxy- based continual learning, we follow the same experimental setting as in (Zhu et al., 2021). To facilitate the encoder learning, we further perform hyperspherical projection to all the learned features f for all the compared methods (i.e., make linear classifiers s()) fully rely on angles), following (Wang et al., 2018a). Full experimental and implementation details can be found in Appendix A. Additional experiments are given in Appendix D.
5.1 Empirical Comparison of Different MOCA Variants
We evaluate different variants of MOCA based on a simple and clean baseline - ER (Riemer ct al., 2018). We show in Figure 1 that all the MOCA variants can effectively increase the intra-class variation for old classes. Table 1 shows that most of MOCA variants can consistently improve continual learning. While both model-agnostic and model-based MOCA can achieve significantly better accuracy than the basclinc, we obscrve that modcl-based MOCA generally oulperforms both model-agnostic MOCA and the baseline by considerable margin. For the family of model- agnostic MOCA, Gaussian and vMF achieve similar performance, but sampling Gaussian distribution yields better efficiency and simplicity. For the family of model-based MOCA, WAP achieves the best performance in both offline and online continual learning, while VT performs the best in proxy-based continual learning. The proxy-based continual learning setting does not allow the memory replay, so both DOA-old and WAP can no longer be applied. Although all the MOCA variants can increase intra-class variation, we note that it does not necossarily lead to better performance. Therefore, the specific direction to model the intra-class variation is also important, which causes the performance difference for DOA, VT and WAP.
Setting
Raseline
Gaussian
vMF
DOA-old
DOA-new
VT
WAP
Offine
31.08
37.28
38.76
33.67
38.76
39.78
41.02
Online
31.90
32.78
31.25
30.20
29.48
32.55
33.72
Proxy
31.26
42.54
42.24
45.72
46.77
Table 1: Comparison of different MOCA variants in 3 continual
settings on CIFAR-100. Classification accuracy (%) on the full testing set is reported. Results are averaged with 3 random seeds and the best ones are marked in bold.
5.2 How Perturbation Magnitude Affects Performance
We evaluate how perturbation magnitude influ- ences different MOCA variants on CIFAR- 100.
Baidiac <MF
Chostiornnn Aocrayy (8g
%0
444
The experimental settings are the same as Sec- tion 5.1 (the offline setting). Results in Figure 8 show that most of the MOCA variants achieve consistent improvement under wide range of different perturbation magnitudes. Specifically, we consider two ways to measure the pertur- bation magnitude: (1) the hyperparamoter À in Section 4.3 and (2) the hard roist that the perturbation has a fixed angle to the pro-
x 12
Clastt0aaton Aucurac
DDA-a29
DDA-ol
VT
Basclac
36
WAP
Garclle
IME
12
0.5
155
10
60
Value of
Pertobation Angle (cegnas)
Figure 8: Left: the hyperparamoter À vs. classification accuracy. Right: the perturbation angle vs. classification accuracy.
totype feature (this is achieved by performing simple spherical projection after applying the specific MOCA variant). We observe that model-based MOCA performs generally better than model-agnostic MOCA under most perturbation magnitudes, and WAP is the best-perforning variant under all magnitude constraints.
10

---

Published in Transactions on Machine Learning Research (01/2023)
5.3 MOCA Learns Discriminative Classifiers
88.0
87.5
12
12
12
87.
One of the most significant problems in memory- based continual learning is the classifier bias caused by the highly imbalanced dataset (and imbalanced mini-batches in training). MOCA addresses this by diversifying the representation space of old classes. In order to visually compare MOCA and the baseline, compute the average pair-wise angle between learned classifier vectors in two tasks. For example, the block at the T2 column and the T1 row shows the average pair-wise angle between classifiers in the first task and classifiers in the second lask. Figure 9 gives the results. We note that a large angle between classifiers not only indicates more diseriminativeness in classifiers themselves, but it also implies inter-class separability in the representation space because more separable features generally lead to more separable classifiers Liu et al. (2022). The results show that both model-agnostic MOCA (i.e., Gaussian) and model-based MOCA (i.e,, WAP) can effectively improve the discriminativeness of the learned classifiers in continual learning.
86.5
86.0
T4
I
T4
85.5
T3
TS
T5
K5.0
84.5
T1
T2 T3 T4 T3
T1 T2 T3 T4 T5
T1 T3 T4 T3
(a) Baseline
(b) Mode agnostic MOCA
(6) Madel MOCA
Figure 9: Average angle between the classifiers. Ti denotes the i-th task. The color of blocks shows the average classifier angle between different tasks. Only the upper triangular part shown.
5.4 Comparison to taate-of-the-art Methods
CIFAR-10
Meihod
M=210
M=500
M=2000
We conduct a comprehensive comparison of existing state-of-tho-art methods in three settings including offline, online, and proxy-based continual learning. We use CIFAR-10, CIFAR-100, and TinylmageNer as the benchmark datasets.
GEM (Lopes. Pax Ranzato, 2017)
29.90#3.92
29.45:5.64
27:20:4.50
GSS (Aljund nl., 2018b)
38.6243.50
48.9743320 2.25
60-40:4:92
ICaRL (Rebufi al., 2017)
32.4410.53
34.9641 23
10.57
ER (Röener al., 2018)
49.07
61 58
76.8920.99
ER w/ Gausslan
61.02+1.42
08.544
78.27=00.2
ER w/ WAP
63.12:2.15
12.07711.33
00.38:10.95
DER++ (Bunereg et al., 2020)
64.8821.17
72.70::1.30 .66
78.5420.97
DER w/ Gaussian
63.0240.53
71.04460.22
79.22:50.22
Offline continual learning. We apply the best- performing variant of model-agnostic MOCA (i.e.
DER w/ WAP
65.12:0.77
75.01:0.224
81.54-0.112
ER-ACE (Carcia en al., 2021)
63.1840.66
71.9841 1.33
80.01
Gaussian) and model-based MOCA (d.e. WAP) to three baselines (i.e., ER (Riemer et al., 2018), DER++ (Buzzega et al., 2020), ER-ACE (Cac- cia et al., 2021)). Table 2 shows the results with three buffer sizes (200, 500 and 2000) on CIFAR-10, CIFAR-100 and TinylmageNet. The results con- sistently validate the effectiveness of both model- agnostic and model-based MOCA. On CIFAR-10, we observe that Gaussian greatly improves ER while only achieving incremental improvement on both DER++ and ER-ACE. This further emphasizes the importance of perturbation directions rather the absolute variance. In comparison, WAP im- proves all three baselines (ER, DER++ and ER- ACE) by a large margin (~10% in some cases). On both CIFAR-100 and TinyImacNeet, WAP still consistently improves all three baselines by a con- siderable margin. Gaussian able to improve the performance of ER and ER-ACE, while only be- ing comparable (sometimes even worse) in the case of DER++. We suspect that the distillation step in DER++ is not suitable for Gaussian perturba- tion, and to amend this, we may need to store all the logits for the perturbed features, which is memory-expensive. In contrast, WAP can work well with DER++, because only perturbs along the most informative and depedaryde di- rections. Moreover, the improvement of MOCA is consistent all three sizes of memory buffers. Applying
ER-ACE w/ Gaussian
65.2120.89
72.01:10:76
78:9220.38
ER-ACE w/ WAP
66.56=0.81
7.086=1.02
80.24=0.50
CIFAR-100
Method
M=200
M=500
M=000
GEM (Lopez Paz & Ranzato, 2017)
20.7520.06
25.54:20.65
37.5610.87
(Aljmdi al., 2019h)
19.42+0.29
21.9240.34
27.07=00.25
iCaRL (Rebufi al., 2017)
28.0010.991
$8.25.11.2 25
42.19122.42
ER (Riemner 2018)
22.14:1042
11.0220:77 79
43.54110.0
ER Gaussian
20.51
87.54:h0.71
19.61=1.01
ER w/ WAP
30.16:1.02
40.2410077
52.92:10003
DER++ (Bunorgu ot al. 2020)
20.6++1335
30.08 1.76
54.38=0088
DER+ w/ Gaussian
30.5920.00 40
40.62:00.22 29
52.720.42
DER + w/ WAP
32.18=0.67
43.78:0.80
66.04-0.81
ER-ACE (Caceia et al., 2021)
35.00400.22
43.12:t0.85
53.88::0.42
ER-ACE w/ Ganssian
37.01
44.57:20.85
54.8420.12
ER-ACE w/
37.46=0.77
45.79:0.73
56.02=0.64
Tangee
Method
M-200
M-500
M-2000
GEM (Lopes Paz & Ranzato, 2017)
GSS (Aljunái et al., 2019b)
8.57#0.13
9.63-10.14
11.9410.11
iCaBL (Rebrfli al., 2017)
5.5010.52
11.00:1.35
18.10::1.1
ER (Remer es al., 2018)
8.6510.11
10.05:10.26
18.1911.47
w/
9.4240.12
12.94::.322
21.43200.78
w/
10.4120.37
16.27:0.225
22.62:1.110
DER (Bussng 2020)
10.9
19.98:1141
80.11=0.67
DER++ w/ Gaussian
10.5210.12
15.75:10.35
25.2810.30
DER + w/ WAP
12.07=0.35
21.24:0.47
29.3320071
ER-ACE (Cacela et al., 2021)
14.29+00.7
20.87:50.69
30.10:29
ER-ACE w/ Gaussian
16.72:0.11 .11
22.52:10.0
30.9210.41
ER-ACE w/ WAP
17.05.10.22
23.5610.85
32.54-0.72
'able 2: Offline continual learning on CIFAR-10, CIFAR-100 and Tiny Imageet. Final classification accuracy (%) on the full testing set is given. Results are averaged with 3 random seeds.
11

---

Published in Transactions on Machine Learning Research (01/2023)
MOCA to the simplest baseline (ER) already leads to comparable performance to the state-of-the-ar methods
Online continual learning. We apply the best-performing MOCA variant (i.e., WAP) to online continual learning. The results are shown in Table 3. In the online setting, all the pre- viously seen data from this previous tasks are not accessible. We evaluate WAP using two different buffer sizes (20 and 100) on CIFAR-10, CIFAR-100 and MinilmageNet. We apply WAP on three baselines: ER, DER++ and ER-ACE. We draw a few conclusions from the results: (1)
CIFAR-10
CIFAR-100
MiniIraggNNet
Method
M=20
M=100
M=20
M=100
41=20
M=100
A-GEM (Chaudary et al, 2013)
18.58
18.00
3.50
3.26
2.94
3.04
MIR (Aljundi et al., 20196)
24.20
45.44
12.70
17.50
11.54
11.48
SS-11 (Aha es sl., 2021)
35.51
42.78
16.20
20.24
10.96
21.38
ICaRL (Rebuffi et al., 2017)
40.94
49.76
17.55
19:80
12.30
15.20
(Riemer et al., 2018)
31.90
42.48
13.52
25.24
16.16
21.02
ER w/ WAP
38.72
41.26
13,90
23:29
17.22
19:32
DRR++ (Busznga et. al. 2020)
34.36
43.38
12.84
13:74
17.00
18.56
DER++ WAP
41.56
45.64
18.76
22.54
16.32
19.20
ER-ACE (Cuceii al., 2021)
42.90
53.88
16.85 88
27.48
21.00
26.96
ER-ACE w/ WAP
43.57
64.42
18.90
29.52
22.56
29.70
WAP can consistently improve all three baselines by a considerable margin in most of the settings. This again validates the effectiveness of MOCA. (2) In comparison, the performance gain of WAP in the online setting is less significant than that in the offline setting, The reason behind this is that online continual learning suffers not only from catastrophic forgetting but also from the under-iitiing of the incoming data which can only be seen once, while MOCA can only help with catastrophic forgetting rather than data under-fitting
Table 3: Ouline continual learning on CIFAR-10, CIFAR-100 and TinyImageNet. Final classification accuracy (%) on the full testing set is given. Results are averaged with 3 random seeds.
Proxy-based continual learning. Since the mem- ory buffer is disabled in proxy-based continual learn- ing (Zhu et al., 2021), WAP cannot be used. However, we can still explore the effectiveness of modeling intra- class variation in this scenario with the other MOCA variants (e.g., DOA and VT). In the proxy-based con- tinual learning, PASS (Zhu et al., 2021) proposed to augment the old-class prototype by adding Gaussian noise, which is conceptually similar to our Gaussian MOCA. Therefore, PASS can be viewed as special case of Gaussian MOCA. Table 4 shows that both DOA and VT perform better than PASS, further validating our conclusion that model-based MOCA works better than model-agnostic MOCA.
CIPAR-100
MiniImageNet
Method
T=5
T=10
T-20 T=5 T=10 T T-20
PASS (Zhu et sl, 2021)
64.39
57.36
58.09
48
46.54
12.09
PASS w/ DOA
66.82
63.30
62.62
47.92
47.55
47.11
PASS w/ VT
67.75
63.64 63.09
18.35
17.90
47.33
Table 4: Proxy-based continual learning CIFAR- R-100 and MinilmageNet. Final accuracy (%) on the full testing set is given. Results are averaged with 3 random seeds.
Performance over continual tasks. We also plot the average testing accuracy of currently seen tasks when learning different continual tasks in the offline setting. We perform the experiments on CIFAR-100 (5 tasks with 20 classes per task) and TinyInageNet (10 lasks with 20 classes per task) with buffer size 500. From Figure 10, we can observe that all the MOCA variants perform better than the ER baseline by a considerable margin and WAP again works the best across different training phases. While achieving better performance than baseline, DOA-old does not perform well as DOA-new. We suspect that the variation created by Dropout on the old data is less diverse and less informative than that on the new data.
Clusiifcatio Assunay (5)
Gennsian
NM
55
DOA-cM
Gancon
MF
30
DO
50
30
8
Task ID in CIFAR-100
Task Tinplmage
Figure 10: Average testing accuracy (%) over continual tasks.
5.5 Comparison to Gradient and Representation Diversification
Besides methods in continual learning, we also compare MOCA to some popu- lar methods that can diversify gradients
CIFAR-10
CIFAR-100
Method
k=200
k=500
2=00
k=0
k=5000 k=2000
ER (Itsemer et al., 2018)
49.07
61.58
76.89
21.71
28.12
43.10
+ Re-weighting (Kang et al., 2019)
53.02
66.54
77.92
24.58
30.12
44.31
and representations. Specifically, we con- sider loss balancing methods such as Re- weighting (Kang et al., 2019) and Focal Loss (Lin et al., 2017), and representation augmentation methods such as Manifold
+ Focal Loss (Lin et al., 2017)
46.07
60.97
77.26
22.43
27.19
43.37
+ Manifold Mixup (Verma et al., 2019)
55.21
67.02
77.54
23.97
29.33
45.21
Model-based MOCA (WAP)
63.12
72.07
80.38
30.16
40.24
52.92
Table 5: Comparisons of the proposed approaches with existing classical loss noighigh methods. The best results are marked in bold.
12

---

Published in Transactions on Machine Learning Research (01/2023)
Mixup (Verma et al., 2019). We apply these methods (with the best-performing hyperparameters) to ER and compare them with our best-perfone best-performing MOCA variant (WAP). Results in Table 5 show that WAP can outperform all these methods on both CIFAR-10 and CIFAR-100 under three different buffer sizes (200, 500 and 2000). The experiments also support our argument that gradient diversity for old classes is of great importance to continual learning.
6 Concluding Remarks
In this work, we study the problem of memory- based continual learning. Due few old-class data samples, we observe that there exists a scrious lack of diversity in the representation space for old classes. This behavior causes represenlation collapse for old classes and an intra-class variation gap between old classes and new classes. This representation collapse further causes gradient collapse which prevents the model to acquire effective information for remembering old classes and leads to catastrophic forgetting. To address this, we propase the MOCA framework to model the intra-class variation and improve continual lcarning. We propose several variants of model-agnostic MOCA and model-based MOCA under this framework. In all continual learning settings, we show that all the MOCA variants can serve a plug-and-play compouent to effortlessly improve a number of existing continual learning methods, demonstrating the effectiveness of MOCA.
Acknowledgements
"WL and LH share the corresponding authorship. WL acknowledges support from the Seabbbiddg-Tübbingee PhD fellowship, the German Federal Ministry of Education and Research (BMBF): Tübingen AI Center, FKZ: 011S18039A, 011S18039B; and by the Machine Learning Cluster of Excellence, EXC number 2064/1 Project number 390727645. AW acknowledges support from a Turing AI Fellowship under EPSRC grant EP/ /P/O22527//, The Alan Turing Institute, and the Leverhulme Trust via CFI. We gratefully acknowledge the support of MindSpore, CANN (Compute Architecture for Neural Networks) and Ascend Al Processor used for this rescarch.
References
Hongjoon Ahn, Jihwan Kwak, Subin Lim, Hyeonsu Bang, Hyojun Kim, and Taesup Moon. Ss-il: Separated softmax for incremental learning. In ICCV, 2021.
Rahaf Aljundi, Francesca Babiloni, Mohamed Elhoseiny, Marcus Rohrbach, and Timne Tuytelaars. Memory aware synapses: Learning what (not) to forget. In ECCV, 2018.
Rahaf Aljundi, Klaas Kelchtermans, and Timne Tuytelaars. Task-free continual learning. In CVPR, 2019a.
Rahaf Aljundi, Min Lin, Baptiste Goujaud, and Yoshua Bengio. Gradient based sample selection for online continual learning. In NewrlPS, volume 32, 2019b.
Frederik Benzing. Unilying importance based regularisation methods for continual learning. In ATSTATS, 2022.
Andrew Brock, Jeff Donahue, and Karen Simonyan. Large scale gan training for high fidelity natural image synthesis. arXiv preprint 100.16,09.1196,, 2018.
Pietro Buzzega, Matteo Boschini, Angelo Porrello, Davide Abati, and Simone Calderara. Dark experience for general continual learning: strong, simple baseline. In NewrIPS, 2020.
Lucas Caccia, Rahaf Aljundi, Nader Asadi, Tinne Tuytelaars, Joelle Pineau, and Eugene Belilovsky. Reducing representation drift in online continual learning. ar.iiv preprint arXiv:2104. 05025, 2021.
Xinyuan Cao, Weiyang Liu, and Santosh Vempala. Provable lifelong learning of representations. In AISTATS, 2022.
Arslan Chaudhry, Mare'Aurell Ranzato, Marcus Rohrbach, and Mohamed Elhoseiny. Efficient lifelong learning with a-gem. In ICLR, 2018.
13

---

Published in Transactions on Machine Learning Research (01/2023)
Beidi Chen, Weiyang Liu, Zhiding Yu, Jan Kautz, Anshumali Shrivastava, Animesh Garg, and Animashree Anandkumar. Angular visual hardness. In International Conference on Machine Learning (ICMT.), 2020.
Tim Davidson, Luca Falorsi, Nicola De Cao, Thomas Kipf, and Jakub M Tomezak. Hyperspherical variational auto-cncoders. In UAI, 2018.
Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A largo-scale hicrarchical image database. In CVPR, 2009.
Jiankang Deng, Jia Guo, Niannan Xue, and Stefanos Zafeiriou. Areface: Additive angular margin loss for deep face recognition. In CVPR, 2019.
Gregory Ditzler, Manuel Roveri, Cesare Alippi, and Robi Polikar. Learning in nonstationary environments: A survey, IEEE Computational Intelligence Magazine, 10(4):12-25, 2015.
Arthur Douillard, Matthicu Cord, Charles Ollion, Thomas Robert, and Eduardo Valle. Podnet: Pooled outputs distillation for small-tasks incremental learning. In ECCV, 2020.
Mehrdad Farajtabar, Navid Azizan, Alex Mott, and Ang Li. Orthogonal gradient descent for continual learning. In AISTATS, 2020.
Robert M French. Catastrophic forgetting in conncctionist networks. Trends in cognitive sciences, 3(4): 128 135, 1999.
Tianyu Gao, Xingcheng Yao, and Danqi Chen. Simcse: Simple contrastive learning of sentence embeddings. In EMNLP, 2021.
Tan Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In NIPS, 2014a.
Ian Goodfellow, Jonathon Shlens, and Christian Szegody. Explaining and harnessing adversarial examples. arxiv preprinl Xrx:::142..66 2014b.
Stephen Grossberg. How does brain build cognitive code? In Studies of mind and brain, pp. 1 1-52. Springer, 1982.
Stephen Grossberg, Krishna Srihasam, and Daniel Bullock. Neural dynamics of saccadic and smooth pursuit eye movement coordination during visual tracking of unpredictably moving targets. Neural Networks, 27: 1-20, 2012.
Demis Hassabis, Dharshan Kumaran, Christopher Summerfield, and Matthew Botvinick. deuroscience-inspiree artificial intelligence. Neuron, 95(2):245 258, 2017.
Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016.
Geoffrey Hinton, Oriol Vinyals, Jeff Dean, al. Distilling the knowledge in neural network. arXiv preprint wwXiv:1503.02541 2(7), 2015.
Sepp Hochreiter and Jürgen Schmidhuber. Flat minima. Neural computation, 9(1):1-42, 1997.
Saihui Hou, Xinyu Pan, Chen Change Loy, Zilei Wang, and Dahua Lin. Learning unified classifier incrementally via rebalancing. In CVPR, 2019.
Ching-Yr Yi Hung, Cheng-Hao Tu, Cheng-En Wu, Chien-Hung Chen, Yi-Ming Chan, and Chu-Song Chen. Compacting, picking and growing for unforgetting continual learning. In NewrIPS, 2019.
Bingyi Kang, Saining Xie, Marcus Rohrbach, Zhicheng Yan, Albert Gordo, Jiashi Feng, and Yannis Kalantidis. Decoupling representation and classifier for loig-tailed recognition. arXiv preprint 19100:1910000 090117, 2019.
14

---

Published in Transactions on Machine Learning Research (01/2023)
James Kirkpatrick, Razvan Pascanu, Neil Rabinowitz, Joel Veness, Guillaume Desjardins, Andrei A Rusu, Kieran Milan, John Quan, Tiago Ramalho, Agnieszka Grabska-Barwinnt et al. Overcoming catastrophic forgetting in neural networks. Proceedings of the national academy of sciences,
2017.
Alex Krizhevsky, Nya Sutskever, and Geoffrey E Hinton. Imagenct classification with deep convolutional neural networks. In NIPS, 2012.
Alex Krizhevsky et al. Learning multiple layers of features from tiny images. Technical Report, 2009.
Zhizhong Li and Derek Hoiem. Learning without forgetting. TPAMI, 40(12)22935 2947, 2017.
Rongmei Lin, Weiyang Liu, Zhen Liu, Chen Feng, Zhiding Yu, James M Rehgg Li Xiong, and Le Song. Regularizing neural networks via minimizing hyperspherical energy. In CVPR, 2020.
Tsung-Y Yi Lin, Priya Goyal, Ross Girshick, Kaiming He, and Piotr Dollár. Focal loss for dense object detection. In CVPR, 2017.
Fangyu Läu, Ivan Vulié, Anna Korhonen, and Nigel Collier. Fast, effective, and self-supervise:: Transforming masked language models into universal lexical and sentence encoders. arxiv preprint wxXi:2104.00022, 2021a.
Weiyang Liu, Yandong Wen, Zhiding Yu, and Meng Yang. Large-margin softmax loss for convolutional neural networks. In ICML, 2016.
Weiyang Liu, Yandong Wen, Zhiding Yu, Ming Li, Bhiksha Raj, and Le Song. Sphereface: Deep hypersphere embedding for face recognition. In CVPR, 2017a.
Weiyang Liu, Yan-Ming Zhang, Xingguo Li, Zhiding Yu, Bo Dai, Tuo Zhao, and Le Song, Deep hyperspherical learning. In NIPS, 2017b.
Weiyang Liu, Rongmei Lin, Zhen Liu, Lixin Liu, Zhiding Yu, Bo Dai, and Le Song. Learning towards minimum hyperspherical energy. In NewrIPS, 2018a.
Weiyang Liu, Zhen Liu, Zhiding Yu, Bo Dai, Rongmei Lin, Yisen Wang, James M Rehgg, and Le Song. Decoupled networks. In CVPR, 2018b.
Weiyang Liu, Rongmei Lin, Zhen Liu, James M Rebg, Liam Paull, Li Xiong, Le Song, and Adrian Weller. Orthogonal over- per-parameterized training. In CVPR, 2021b.
Weiyang Liu, Rongmei Lin, Zhen Liu, Li Xiong, Bernhard Schölkopf, and Adrian Weller. Learning with hyperspherical uniformity. In AISTATS, 2021c
Weiyang Liu, Yandong Wen, Bhiksha Raj, Rita Singh, and Adrian Weller, Sphereface revived: Unifying hyperspherical face recognition. TPAMI, 2022.
Yaoyao Liu, Yuting Su, An-An Liu, Bernt Schiele, and Qianru Sun. Mnemonics training: Multi-class incremental learning without forgetting. In CVPR, 2020.
David Lopez-Paz and Marc' Aurelio Ranzato. Gradient episodic memory for continual learning, In NIPS, 2017.
Jianfeng Tu and Stefan Steinerberger. Neural collapse under cross-entropy loss. Applied and Computational Harmonic Analysis, 59:224 241, 2022.
James L McClelland, Bruce L McNauugton, and Randall C O'Reilly. Why there are complementary learning systems in the hippocampus and neocortex: insights from the successes and failures of connectionist models learning and memory. Psychological review, 102(3):419, 1995.
Seyed Iman Mirzadeh, Mehrdad Farajtabar, Razvan Pascanu, and Hassan Ghasemzadeh. Understanding the role of training regimes in continual learning. 2020.
15

---

Published in Transactions on Machine Learning Research (01/2023)
Seyed Iman Mirzadeh, Arslan Chaudhry, Dong Yin, Timothy Nguyen, Razvan Pascanu, Dilan Gorur, and Mehrdad Farajtabar. Architecture matters in continual learning. arXiv preprint arXiv:220. 2022.
Randall O'Reilly and Kenneth A Norman. Hippocampal and neocortical contributions memory: Advances in the complementary learning systems framework. Trends in cognitive sciences, 6(12):505-510, 2002.
Randall C O'Reilly, Rajan Bhattacharyya, Michael D Howard, and Nicholas Ketz. Complementary learning systems. Cognitive science, 38(6):1229-1244 2014.
Vardan Papyan, XY Han, and David L Donoho. Prevalence of neural collapse during the terminal phase of deep learning training. Proceedings of the National Academy of Sciences, 117(40):24652 -46663, 2020.
Jathushan Rajasegaran, Munawar Hayat, Salman H Khan, Fahad Shahbaz Khan, and Ling Shao. Random path selection for continual learning. In NewrIPS, 2019.
Sylvestre Rebuffi, Alexander Kolesnikov, Georg Sperl, and Christoph H Lampert. icarl: Incremental classifier and representation learning. In CVPR, 2017.
Matthew Riemer, Ignacio Cases, Robert Ajemian, Miao Liu, Irina Rish, Yuhai Tu, and Gerald Tesauro. Learning to learn without forgetting by maximizing transfer and minimizing interference. arXiv preprint arXiv:1810.110 2018.
Alvin E Roth. The Shapley value: essays in honor of Lloyd S. Shapley. Cambridge University Press, 1988.
Andrei Rusu, Neil C Rabinowitz, Guillaume Desjardins, Hubert Soyer, James Kirkpatrick, Koray Kavukcuoglu, Razvan Pascanu, and Raia Hadsell. Progressive neural networks. arXiv preprint arXiv:1606.04677 2016.
Gobinda Saha, Isha Garg, and Kaushik Roy. Gradient projection memory for continual learning. arXiv preprint XrXi::2103.099 09762, 2021.
Bernhard Schölkopf, Francesco Locatello, Stefan Bauer, Nan Rosemary Kc, Nal Kalehbrenner, Anirudh Goyal, and Yoshua Bengio. Toward causal represenlation learning. Proceedings of the IEEE, 109(5):612 634, 2021.
Joan Serra, Didac Suris, Marius Miron, and Alexandros Karatzoglou. Overcoming catastrophic forgetting with hard attention to the task. In ICML, 2018.
Dongsub Shim, Zheda Mai, Jihwan Jeong, Scott Sanner, Hyunwoo Kim, and Jongseong Jang, Online class-incremental continual lcarning with adversarial shapley value. In AAAT, 2021.
Hanul Shin, Jung Kwon Lee, Jaehong Kim, and Jiwon Kim. Continual learning with deep generative replay. In NIPS, 2017.
David Silver, Aja Huang, Chris J Maddison, Arthur Guez, Laurent Sifre, George Van Den Dricssche, Julian Schrittwieser, Ioannis Antonoglou, Veda Panneershelvam, Mare Lanctot, et al. Mastering the game of go with deep neural networks and tree search. nature, 529(7587):484-489, 2016.
Jake Snell, Kevin Swersky, and Richard Zemel. Prototypical networks for few-shot learning. 2017.
Nitish Srivastava, Geoffrey Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: a simple way to prevent noural networks from overfitting. JMLR, (5(1):1929-1955 2014.
Christian Szegedy, Wojciech Zaremba, Llya Sutskever, Joan Bruna, Dumitru Erhan, lan Goodfellow, and Rob Fergus. Intriguing properties of neural networks. arXiv preprint ar Xrx::13122.614 2013.
Rishabh Tiwari, Krishnateja Killamsetty, Rishabh Iyer, and Pradeep Shenoy. Ger: Gradient coreset based replay buffer selection for continual learning. In CVPR, 2022.
Gary Ulrich. Computer generation of distributions on the m-sphere. Journal of the Royal Statistical Society: Series C (Applied Statistics), 33(2):158 113,1166-166, 1984.
16

---

Published in Transactions on Machine Learning Research (01/2023)
Aaron Van Den Oord, Oriol Vinyals, et al. Neural discrete representation learning. In NIPS, 2017.
Vikas Verma, Alex Lamb, Christopher Beckham, Amir Najafi, Ioannis Mitliagkas, David Lopez-Pazz Pazz,PPaz, and Yoshua Bengio. Manifold mixup: Better representations by interpolating hidden states. In ICML, 2019.
Johannes von Oswald, Christian Henning, Benjamin F Grewe, and João Sacramento. Continual learning with hypernetworks. In ICLR, 2020.
Feng Wang, Weiyang Liu, Haijun Liu, and Jian Cheng. Additive margin softmax for face verification. arXiv preprint Xio: 150,:9999. 2018a.
Hao Wang, Yitong Wang, Zheng Zhou, Xing Ji, Dihong Gong, Jingchao Zhou, Zhifeng Li, and Wei Liu. Cosface: Large margin cosine loss for deep face recognition. In CVPR, 2018b.
Liyuan Wang, Xingxing Zhang, Kuo Yang, Longhui Yu, Chongxuan Li, Lanqing Hong, Shifeng Zhang, Zhenguo Li, Yi Zhong, and Jun Zhu. Memory replay with data compression for continual learning. arXiv preprinl ar Xiv:2200. 22020202.0650,, 2022.
Shipeng Wang, Xiaorong Li, Jian Sun, and Zongben Xu. Training networks in null space of feature covariance for continual learning. In CVPR, 2021.
Tongzhou Wang and Phillip Isola. Understanding contrastive representation learning through alignment and uniformity on the hypersphere. In JCML, 2020.
Yulin Wang, Xuran Pan, Shiji Song, Hong Zhang, Gao Huang, and Cheng Wu. Implicit semantic data augmentation for deep networks. In NewrIPS, 2019.
Max Welling, Herding dynamical weights to learn. In ICML, 2009.
Yandong Wen, Kaipeng Zhang, Zhifeng Li, and Yu Qiao. A comprehensive study center loss for deep face recognition. IJCV, 127(6))668-666 683, 2019.
Dongxian Wu, Shu-Tao Xia, and Yisen Wang. Adversarial weight perturbation helps robust generalization. In NewrIPS, 2020.
Yue Wu, Yinpeng Chen, Lijuan Wang, Yuancheng Ye, Zichong Liu, Yandong Guo, and Yun Fu. Large seale incremental learning. CVPR, 2019.
Shipeng Yan, Jiangwei Xie, and Xuming Hc. Der: Dynamically expandable represcntation for class incremental learning. In CVPR, 2021.
Lu Yu, Bartlomiej Twardowski, Xialei Liu, Luis Herranz, Kai Wang, Yongmei Cheng, Shangling Jui, and Joost van de Weijer. Semantic drift compensation for class incrementlt learning. In CVPR, 2020.
Friedemann Zenke, Ben Poole, and Surya Ganguli. Continual learning through synaptic intelligence. In ICML, 2017.
Yaowei Zheng, Richong Zhang, and Yongyi Mao. Regularizing neural networks via adversarial model perturbation. In CVPR, 2021.
Fei Zhu, Xu- Yao Zhang, Chuang Wang, Fei Yin, and Cheng-Lin Liu. Prototype augmentation and self- supervision for incremental learning. In CVPR, 2021.
17

---

Published in Transactions on Machine Learning Research (01/2023)
Appendix
Table of Contents
A Implementation Details
19
B MOCA as Implicit Data Augmentation
20
Connection Large-margin Softmax
D Additional Experimental Results and Discussions
22
D.1 MOCA Diversifies the Collapsed Gradient
22
D.2 Variation Towards New- Class Important for Continual Learning
................................
22
D.3 MOCA is Robust to Memory Size
23
DA Convergence Stability of WAP
23
D.5 Hyperspherical Classifier vs. Normal Classifier
23
D.6 Perturbing Weight Perturbing Feature in WAP? ................................
24
D.7 MOCA Different Continual Learning Settings
................................
24
D.8 Computational Cost Different MOCA Variants
D.9 Why Does Approximating Joint Training Help?
24
D.10 How to Chose the Perturbation Magnitude À for MOCA
25
D.11 Comparison between vMF Distribution and Gaussian Distribution
25
18

---

Published in Transactions on Machine Learning Research (01/2023)
A Implementation Details
Compared Baseline. For offline continual learning, we include several classical approaches: GEM (Lopez- Paz & Ranzato, 2017) is the gradient projection method; GSS (Aljundi et al., 2019b) considers the variance of the memory buffer; and iCARI. (Rebuffi et al., 2017) uses the previous model for distillation regularization. For online continual learning, the compared approaches include: A-GEM (Chaudhry et al., 2018), an online version of GEM, MIR (Aljundi et. al., 2019a), buller selection method considering the sample influence to performance and SS-IL (Ahn et al., 2021), a method separating the old-class and new-class in softmax are considered. For both the offline and online settings, we plug our method into several classical and comparative methods, ER (Riemer et al., 2018), randomly selecting bufler for replay, D (Buzzega et al., 2020), using the dark knowledge of previous logits for a better distillation regularization, ER-ACE: (Caccia et al., 2021), a new method preventing the overwhelming negative gradient for old-class. For proxy- based continual learning, we follow PASS (Zhu et al., 2021) and add our proposed approaches on PASS.
Evaluation Metrics and proposed approaches. We the 18 (He al., 2016) as the backbone and use the test classification accuracy of the final continual task as the metric. Although all the various approaches we proposed, Gaussian, DOA-old, DOA-new, VT, and WAP have achieved considerable performance gains, we use the WAP as our final approach to compare with existing methods. The detailed implementation of WAP shows in Algorithm 1. In our experiments, we set the inner learning rate Ç as 10 and the inner iteration number as 1.
Offline continual learning. For offline continual learning, we implement our MOCA based on the code of DER (Buzzega et al., 2020). For all the MOCA approaches, the perturbation magnitude À is set 2.0, which shows the best empirical performance. For DOA-old and DOA-new, the dropout rate is set as 0.5. For WAP, we update the proxy model 0, in each iteration, and the proxy loss weight is set as 10. After producing the perturbed feature, the proxy model will be reloaded as the original model. For both the compared baselines and proposed approaches, the training epoch is set as 50. The batch size is set as 32 and the initial learning rate est as 0.1. All the other settings are the same as the DER (Buzzega et al., 2020).
Online continual learning. For proxy-based continual learning, we implement our MOCA based on the code of ER-ACE (Caccia et al., 2021). Since learning efficiency is also important for online continual learning, for all the MOCA approaches, the perturbation magnitude À is set as 0.8. The batch size is set as 10. The initial learning rate is est as 0.1. All the other settings are the same as the ER-ACE (Caccia et al., 2021).
Brsxy-based continual learning. For proxy-based continual learning, we implement our MOCA based on the code of PASS (Zhu et al., 2021). The perturbation magnitude À is set as 1.0. The other hyper-parameter and continual lcarning settings follow PASS.
For the complete implementation details and settings, please refer to our official PyTorch implementation at https://githut. htttp://ggituub..oo////ggggg// womm/yllonguu//MO.C
19

---

Published in Transactions on Machine Learning Research (01/2023)
Algorithm Weight-Adversane Perturbation
Require: New task training set D {x (x*")")"""") y" New data batch size Old task buffer set M [xxodd (
), Old data batch size m, Loss function E, Initial model parameter Go. Imitial proxy model
parameter Oadu, Outer learning rate Inner learning rate ç, Inner itcration number T, L2 norm ball
radius
while 0g converged do Update itcration: 1 < k
Sample B.. {( yy, )m from buffer set M
4: Initialize proxy model: Oado < 02
5: Initialize perturbation: AB.. + 0
6: for t < 1 to T do
7: Select m random new labels: yadv = {3, new tm
Compute gradient:
VJADV,B... + -
mh Vena. laolid yadu Ondv + AB. m/m
Update perturbation: ABm ABm. -VVJADV.E
10:
if ||A ll2 > then
11:
Normalize perturbation: AB.. t cBBm / end if
12:
13:
end for
14:
Update proxy model: Oadv + Oudo + ABm.
15:
Compute gradient:
f= (xo Ps (Ps (ho, (modd)) + A Pg (ho... (wokd))
VJWAP,B. +- 2i
Vo, (gor (fi), yi 0s)/m
16:
Sample Bn {(xpew p from training set D
17:
Compute gradient:
VJWAP,B. < Ei= Vo, l( yeeu 0x)/n
18:
Update parameter: 0x+1 f- O2 (VVJAA...... + (.WAP.8.))
19:
end while
B MOCA Implicit Data Augmentation
As illustrated in Section 3.3, MOCA can be seen a kind of implicit data augmentation. ISDA (Wang et al., 2019) has proposed framework to show the semantic changes and map the features back to the pixel space. The visualization framework proposed in ISDA is shown in Figure 11. In the first step, we load the pre-trained BigGAN (Brock et al., 2018) for the generator and fixed. Then we minimize the discrepancy between real image, and generated image g(z) to optimize the prior distribution 2. In the second step, we force the feature of generated image h(g(z)) and the augmented feature f to close. By doing this, we can further optimize z and show fake image g(2) corresponding to the augmented feature explicitly. More details can be found in ISDA (Wang al., 2019).
Fake Image
g(x)
(()(2))
Generator (Fixed)
Neural Network (Fixed)
match
f(x
A
Real Image
Figure 11: visualization framework used MOCA.
20

---

Published in Transactions on Machine Learning Research (01/2023)
C Connection to Large-margin Softmax
We denote the feature as 3ú, its label as yi, the i-th classifier as wi, and the angle between æ; and wy as 0j.
Then we can write the marge-margin cross-entropy loss (Liu et al., 2016) as
exp (1wwv:ll | cos(O + +00)
Marginn
(13)
E, exp (||w)) | (0 + ] = y:) A0)
where have that A (m 1)0. There many other possible forms for A in practice (Liu et al., 2022).
For the cross-entropy loss with MOCA, we have the following form:
CMOCA = Σ exp (1/w,,))) || c0s(00, + A0g;))
(14)
E3 exp (1|0g|) ||=:||| cos(0) + A02))
where adding perturbation the feature results in series of angular deviations A0j, Vj. From the that the difference mostly lies in the A0j, Vjj * ys. For the large-margin loss, we have that A0; 0, vjj * yi- Let AO = A0g, and we will easily have that (assuming all perturbed angles are within [0, π and 20j 2 0, Vj)
loss formulations above,
CaaggeMarry LMOCA
(15)
If A0j < 0, Vj, we have that
Large--Magiin LMOCA.
(16)
The perturbation in MOCA happens in Adg. and the rest A8,, Vj * ys are simply the consequence this perturbation. Therefore, y0 2 |0 Vj # yi always holds. Then can be approximately viewed that Margen LMOCA under some cases.
21

---

Published in Transactions on Machine Learning Research (01/2023)
D Additional Experimental Results and Discussions
D.1 MOCA Diversifies the Collapsed Gradient
In this work, as expounded in the section 1, a serious problem in continual learning causing catastrophic forgetting is that the training gradients are not diversified and collapse in some directions and this lack- of-diversity problem causes poor performance. As shown in Figure 12, all of our proposed approaches can diversify the gradient direction the same extent. DOA-new is better than DOA-old in terms of improving gradient diversity. VT, DOA-new, and WAP all consider the new-class information and have better gradient diversity approximation to the joint training method, which also validates motivation modeling the intra-class variation by the model-conditioned data manifold and considcring the new-class information can better resist forgetting and approximate the gradient to the joint training.
-2
-3
Log Singular Value
-5
ER
Gaussian
VMF
DOA-ncM
WAP
40
60
80
100
Dimension
Figure 12: singular value the training gradients different methods. We show the 2-contimual learning task CIFAR-100, where 50 classes are old-classes, and the other 50 classes are new-classes. All the VT, DOA-new, and WAP consider the new-class information.
D.2 Variation Towards is Important for Continual Learning
Original (Minus)
Method
Perturbed
Original
Accuracy
Perturbed (Minus)
Baseline
72.51
29.94
Minus New Feature
90.12
70.91
27.35
Original (Add)
Add New Feature
71.34
77.58
$2.60
New Feature
Table Adding perturbations in different directions: To- wards the new-class feature opposite the new-class feature.
Figure 13: Different changes of the angle between old-class and new-class features diversifying the feature towards opposite the new-class manifold.
Although an Isotropic Gaussian Noise can help improve the variance of representation space of old-class and the empirical performance, the direction of perturbation is also the key to resisting forgetting. We naively add minus the feature of new classes to that of old classes, which means making the old feature towards the new-class manifold direction or away from the new-class manifold direction. Both of them increase the variance the old-class training feature and reduce the variance gap compared to the new classcs. However, as shown in Table 6, only the variation towards new-class manifold improves the performance. Adding the new-class feature to the original feature causes the perturbed feature closer the new-class feature manifold and produces more informative gradient to force the original feature far away from the new-class feature. This leads to more discriminativeness between old-class features and new-class features. On the opposite, minus the new-class feature from the original feature would cause the final perturbed feature far way from
22

---

Published in Transactions on Machine Learning Research (01/2023)
the new-class feature and causes the gradient to be less informative. This fails to take the old-class feature to be overlapped with the new-class feature. Table 6 shows that adding the new-class feature causes the better original feature to form a large angle to the new-class feature, while minus the new-class feature results in the opposile. This experiment also shows that the variation direction is important in continual learning, and we empirically verify that the perturbation direction towards the new-class feature manifold more useful compared to the opposite direction.
D.3 MOCA is Robust to Memory Size
There are a few memory buffer settings available in Table 2 and Table 3. To better evaluate the impact of memory size, we compare
Method
A-50
CIFAR-100
200
6-2000
A-20000
RR (Riemer et al., 2018)
19.94
22.14
43.54
66.39
the E. baseline and our method in wider range of memory buffer sizes. As can be seen in Table 7, both model-agnostic and model-based MOCA consistently improve the baseline under wide range of memory buffer sizes. MOCA achieves the largest performance gain when the memory size is between 200 and 2000.
+ Gaussian
23.56
27.51
49.61
67.34
+ WAP
25.12
30.16
52.92
67.95
Table 7: Effect of memory buffer size to MOCA
with Caussian or WAP.
The effectiveness of MOCA will be affected when the memory buffer extremely small or large. Small memory buffer is unable cover representative features in the latent space, making the perturbation produced by MOCA less effective. On the other hand, the case of large memory buffer size resembles joint training, which will naturally reduce the effectiveness of MOCA. However, even in these two extreme cases, MOCA can still produce considerable performance gain.
D.4 Convergence Stability of WAP
We discuss the convergence stability of WAP here. For all three continual learning settings in our paper, use the same set of hyperparameters. There are two hyperparameters introduced by WAP. One is the number of updating iterations T of the proxy model, and the other is the magnitude of the perturbation Ç. In the implementation, we fixed the updating iteration as T = to reduce the additional training overhead, but a larger number of iterations could lead to better results. For example, if we run 2 iterations in the inner optimization, the performance of ER-WAP is 30.92%, as compared to 30.16% for the 1 inner iteration. The ablation of the hyperparameter & is shown in Table 8. According to the table, WAP exhibits better performance than ER (22.14%) in large range of hyperparameters (e.g., from 0.1 to 50).
Method
Ç-0.1 (-5
<-10
(-50
ER w/ WAP 24.52
27.51
30.16
28.14
Table 8: Effect of the updating perturbation magnitude for WAP.
D.5 Hyperspherical Classifier vs. Normal Classifier
CIFAR-100
MOCA without Hyperspherical Classifier. In this pa- per, we the hyperspherical classifier for both the baseline methods and proposed methods. However, MOCA can also work without based classifiers The experimental results can be found in Table 9, which shows MOCA's 's effectiveness with normal classifier. However, without the normalization function provided by the angle-based classifiers, the feature norm would somelimes grow without control, which would occasionally cause some training instability. Moreover, the perturbation to the feature norm does not introduce uscful information and only affects the learning rate, we resort to the anglc-based classifiers to eliminate the elfect of feature norm perturbation.
Method
k=200
k=500
ER.
22.14
31.02
WAP (normal classifier)
29.33
39.25
WAP (kyperspherical classifier)
30.16
40.24
Table 9: Effect of hyperspherical classifiers for WAP.
Effect of Hyperspherical Classifier for ER. The choice of classifier has little inffuence on the perfor- mance of baseline The comparison between stan- dard un-normalized classifiers and angle-based classifier is shown in Table 10. In LUCIR (Hou et al., 2019), the hyperspherical classifier is motivated by the following observation: the norm of the old classifier weight in the linear classifier is smaller than the norm of the new
CIFAR-10
CIFAR-100
Method
k=200
k=500
k==200
k=
ER (normal classifler)
49.54
61.97
21.92
30.14
ER (hyperspherical classifler)
49.07
61.58
22.14
31.02
Table 10: Rffect of hyperspherical classifier for the baseline method ER.
23

---

Published in Transactions on Machine Learning Research (01/2023)
classifier weight. Then LUCIR uses the hypersphere classifier to balance the classifier norm and reduce the bias in the classifier. In MOCA, the hypersphere classifiers do not have a large influence on the performance and are mostly used to stabilize the training.
D.6 Perturbing Weight or Perturbing Feature in WAP?
CIFA R-000
WAP aims to find the closest decision boundary between the old and new classes by perturbing the weights. This serves as a good feature augmentation to prevent systematic bias towards the new class (due to extreme data imbalance). Al- ternatively, one may think "why not adversarially perturbing the features?". However, this does not work, because adver- sarial perturbation on fcatures only considers the last-layer linear classifier and can not produce meaningful and informative augmentation for the feature encoder. In contrast, if we generate the augmentation by perturbing the weights of the feature encoder, the augmentation will take the feature manifold into consideration. To verify our intuition, we also conduct an experiment in Table 11 to demonstrate the effectiveness of adversarially perturbing the neural network weights instead of the features. To adversarially perturb the features, we use the fast gradient sign method (FGSM) (Goodfellow et al., 2014b). One can observe that adversarial perturbation on features actually hurts the performance.
Method
k==00
k=500
ER
22.14
31.02
FGSM (Coodfellow al., 2014bb)
21.34
29.87
+ WAP
30.16
40.24
Table 11: The comparison of weight perturb method WAP and classical feature perturb method FGSM.
D.7 MOCA in Different Continual Learning Settings
In the offline and online continual learning sctting, the model-based MOCA variant WAP, which considers an adversarial perturbation and introdeees the dependency on the model into the generation of perturbations, is empirically the perforrmfn method. However, in the proxy-based continual learning setting, the lack of old-class samples hinders the usage of WAP. In this casc, another proposed MOCA variant VT, which considers the new-class representation structure, is the best-performing one.
D.8 Computational Cost of Different MOCA Variants
Metrics
We have recorded the running time (second) for the baseline and two MOCA variants, Gaussian and WAP on CIFAR- 100 with 200 buffer sizc. Experiments in Table 12 show that MOCA can improve performance by a large margin with small training overhead. We also note that even if we use ER and train the neural network longer (with a time cost similar to ER-WAP), its performance still around 22%. Therefore, it is generally desirable in practice that such a small training overhead is able introduce a large gain.
Method
Training time (s)
Performance (%)
ER
5562
22.14
+ Gaussian
6147
27.51
+ WAP
7109
30.16
Table 12: Training costs and final testing accuracy CIFAR-100 for two MOCA variants (Gaussian and WAP)
D.9 Why Does Approximating Joint Training Help?
Catastrophic forgetting is a well-known phenomenon that happens in continual learning, and in contrast, catastrophic forgetting does not exist in i.i.d. training. Such a comparison motivates us to look into what could be the gap that causes such a difference. To start with, we look into how the representation and gradient look like in continual learning (see Figure 1, Figure and Figure 3), and then identify the representation and gradient collapse problem (í.e., lack of variation for the memory buffer in the representation space). This is one of the most important molivations that drive us to diversily the intra-class variation to prevent the representation and gradient collapse. To well model the intra-class variation, we also draw inspiration from the joint training gradient in the design of our MOCA variants. Based on the derived dependency of the gradient, we develop both model-agnostic MOCA and model-based MOCA. Our extensive experiments on popular continual learning benchmarks verify the effectiveness of MOCA.
However, there are definitely better ways to approximate i.i.d. training and derive better continual learning methods. Our paper only demonstrates few simple ways to approximate i..d. training, and we hope our method can be good inspiration for future study.
24

---

Published in Transactions on Machine Learning Research (01/2023)
D.10 How to Chose the Perturbation Magnitude À for MOCA
The Perturbation Magnitude À decides the degree of intra-class representation diversification in the MOCA framework. It's influence has been shown in Figure 8. In this section, we em- phasize that appropriate À can not only achieve an approving performance improvements, but also benefits the learned represcntations. We evaluate the learned feature reprosentations in terms of angular fisher score. A lower angular fisher score means better discriminability of learned representations. Our two variants Gaussian and WAP of Moca show the best representation with À = 2, while too small would make MOCA hard take effect, and too large would also cause poor performance due to the damage the model convergence.
Method
A=0
A=1
A=2
A=3
A=4
ER w/ Gaussian
1.48
1.29
1.07
1.08
1.38
ER w/ WAP
1.48
1.09
1.08
2.54
Nan
Table 13: The angular fisher score of learned fea- ture in different perturbation magnitude À for MOCA variants, Caussian and WAP. À means the baseline method ER.
D.11 Comparison between vMF Distribution and Gaussian Distribution
According to Table I, vMF performs worse than Gaussian in the online continual learning setting, comparable to Gaussian in the proxy-based continual learning setting, and better than Gaussian in the offline continual learning setting. In fact, vMF can directly produce perturbation on the hypersphere, which makes the magnitude of perturbation easier to control. Moreover, we have varied the hyperparameters for vMF and Gaussian in Figure 8. As one see from Figure the best performance achieved by vMF is consistently better than the best performance achieved by Gaussian. This is due to the fact that vMF distribution can easily produce effective perturbation on the hypersphere. By adjusting the concent ration scale of the vMF noise, one can control the produced noise on the hypersphere. This property of vMF makes it much casier to find the best hyperparameters for MOCA.
25


Reviews:
[{"review_id": "KayJsOvuRV", "reviewer": "Reviewer_ft7X", "summary": "", "questions": "", "limitations": "", "rating": null, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "I found the paper to be overall interesting, well written and easy to follow, for which I congratulate the authors.\n\nStrengths:\n\n+ This paper is well motivated and the proposal of MOCA starts from a clearly-exposed problem affecting the dynamics of learning. For this reason, the exposition of the model is easy to follow and understand.\n+ I find the proposed approach to be rather unique in the landscape of current CL methods, in that it acts as an open-ended regularizer in function space that not only pushes representations to be coherent with the past (a la LwF/iCaRL), but also endows them with desirable a-priori properties by comparing the representation-space behavior of different models.\n+ The presented ablation studies are quite interesting and successfully highlight the effectiveness of the proposed MOCA\n\nWeaknesses:\n\n+ The authors are not clear on the impact on memory of the proposed methods. What is the memory impact of training with MOCA compared with the baseline methods?\n+ The authors provide a clear indication as to what version of MOCA performs best, i.e. WAP. However, given its adversarial nature, I would like there to be more clarity on details of its training procedure and whether its training is stable and converges easily.\n+ Some of the presented information might are not clearly motivated and might need further details, some examples:\n    + on page 9 (5 - experimental setting) the authors write that they provide angle-based classifiers for all evaluated method. Does this choice have any consequence on competitors that are not originally designed to work under this assumption?\n    + on page 9 (top) wap is said to perturb the network weight adversarially, making it good at preventing catastrophic forgetting. This is not really an obvious consequence of adversarial training. How are these two facts related?\n+ The experiments on the online setting show several competitor methods (SS-IL, iCaRL) outperforming some WAP-enhanced baselines. Could the authors try and combine MOCA with SS-IL or iCaRL? Is MOCA effective when applied on top of these methods?\n+ The choice of the hypersphere classifier might be somewhat related with the deign choice applied in LUCIR and other methods: a reader could find it beneficial to discuss the similarities and differences with this approach.\n+ I believe that the use of the term *prototypes* to indicate examples in the replay buffer is not correct. Prototype generally indicates points in representation space that are a model for other latent point of the same class.", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "Yes", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "paper_topic_and_main_contributions": "", "excitement": null, "reproducibility": null, "ethical_concerns": "", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "", "summary_of_contributions": "The authors investigate the evolution of representation in continual and offline learning models and find a major difference in the way features organize. On this basis, they propose a set of methods aimed at ensuring that representations for past classes do not collapse by taking intra-class variation as a key objective in learning. The authors show that their proposed approach is rather effective when combined on top of SOTA approaches on a variety of benchmarks and highlight interesting properties of their proposal by means of additional ablation studies.", "claims_and_evidence_yn": "Yes", "claims_explanation": "", "audience_yn": "Yes", "audience_explanation": "", "requested_changes": "I suggest the following changes:\n\n+ introducing a discussion on the memory impact of training with the different MOCA versions;\n+ detail whether WAP is particularly hard to train or not;\n+ motivate whether the choice of adopting an angle-based classifier has an impact on accuracy of the evaluated models and how this choice is related to LUCIR and/or other CL literature.", "broader_impact_concerns": "None", "additional_comments": "", "extra_scores": {}, "extra_text": {}}, {"review_id": "Ipg7OHhlNk", "reviewer": "Reviewer_13be", "summary": "", "questions": "", "limitations": "", "rating": null, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "### Strengths\n- Interesting and novel approach to an important problem\n- Orthogonal/compatible with other methods for continual learning\n- Impressive performance improvements when combined with SoTA baselines\n\n### Weaknesses\n- Clarity\n\t- Notation in Section 3.1 alternates between total number of classes $k$ and classes for the $t$-th task $k_t$. Must the total number of classes be known in advance?\n\t- In Section 4.3, model-based MOCA is separated into variants that require prototypes (DOA-old and WAP) and variants that can work with mean representations (DOA-new and VT). However, $h_\\theta(x^{old})$ notation is used throughout, which suggests that all models use $x^{old}$. This notation can be made clearer by emphasizing where $h_\\theta(x^{old})$ is necessary and mean representations $\\bar{f}$ would not work.\n\t- In Section 5.3, the angle between classifiers is used without definition for evaluating classifiers\n- vMF distribution is well-motivated by previous works on modeling intra-class variation on a hypersphere, which the authors cite. However, the performance of model-agnostic MOCA with vMF sampling is worse than with Gaussian sampling. The authors should provide an explanation or support this claim with additional experiments beyond Table 1.\n", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "Yes", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "paper_topic_and_main_contributions": "", "excitement": null, "reproducibility": null, "ethical_concerns": "", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "", "summary_of_contributions": "Continual learning methods must balance between adapting to the new task while maintaining good performance on all previous tasks. This paper proposes MOCA, a classification framework that updates representations of old data to improve intra-class variation on the old classes. This uses data augmentation in representation space to create more prototype representations when training the representation model. For model-agnostic MOCA, perturbed representations are sampled according to a parametric distribution such as Gaussian or von Mises-Fisher (vMF). For model-aware MOCA, perturbations depend on the feature representation $h_\\theta$ model parameters $\\theta$, e.g. dropout or adversarial perturbation. Experimental results show that MOCA improves continual learning compared to several offline/online memory-based methods as well as proxy-based methods.", "claims_and_evidence_yn": "Yes", "claims_explanation": "", "audience_yn": "Yes", "audience_explanation": "", "requested_changes": "### Critical\n- Clarify $k$ vs $k_t$ in Section 3.1\n- Explain poor performance of vMF distribution when compared to Gaussian distribution on model-agnostic MOCA\n- Modify notation throughout Section 4 to clarify where mean representations would not work\n- Summarize empirical findings by outlining which MOCA variant is most appropriate in which learning setting\n\n### Non-critical\n- Compare/discuss computational cost of the different MOCA variants (e.g. running time, memory)\n- Comment on Figure 1: for model-agnostic MOCA intra class variation is actually larger for old classes than for new classes. Does this affect performance?\n- In addition to Section 5.5, mention manifold mixup earlier in the introduction when discussing perturbation in the representation space\n- Justify the assumption for MOCA VT that \"intra-class representation variations for different classes are similar\"\n\n### Typos\n- \"pastly learned parameters\" should be \"previously learned parameters\"\n- \"More additional experiments\" should be \"Additional experiments\"\n", "broader_impact_concerns": "No broader impact concerns.", "additional_comments": "", "extra_scores": {}, "extra_text": {}}, {"review_id": "X57XRDBY4k", "reviewer": "Reviewer_ef5C", "summary": "", "questions": "", "limitations": "", "rating": null, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "I find the paper well written and the theoretical and empirical study very interesting and thorough. Great job! Although I can not judge the novelty of the different variants proposed, I am certain the the TMLR audience will find this paper very valuable. \n\nComments: \nIn CL, all hyperparameter will effect the models performance when trained continually (https://arxiv.org/abs/2202.00275, https://arxiv.org/pdf/2006.06958.pdf).  Can you provide one ablation study how hyperparameters (please provide them in the appendix) \neffect the performance and also the representations? I think this would benefit the paper and give more intuition about how the distribution of the representations change given different hp choices. \nAlso for the related work section, these papers came to mind which also use replay / memory to prevent forgetting on the meta-level. https://arxiv.org/abs/1906.00695, ", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "Yes", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "paper_topic_and_main_contributions": "", "excitement": null, "reproducibility": null, "ethical_concerns": "", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "", "summary_of_contributions": "The authors propose methods to diversify the representations to avoid neural networks from catastrophic forgetting. On top of the thorough analyses and dissections of different variants of their method proposed, the authors provide a thorough and impressive empirical study.", "claims_and_evidence_yn": "Yes", "claims_explanation": "", "audience_yn": "Yes", "audience_explanation": "", "requested_changes": "-", "broader_impact_concerns": "-", "additional_comments": "", "extra_scores": {}, "extra_text": {}}, {"review_id": "IG3J5Hs2Ue", "reviewer": "Reviewer_Rind", "summary": "", "questions": "", "limitations": "", "rating": null, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "### Strengths\n* The motivation of adding intra-class variation to prevent representation/gradient collapse issues is clear, which is also experimentally justified with results in Figure 1, Figure 2, and Figure 3.\n* The authors extensively conduct experiments and analyses for the proposed MOCA on multiple datasets across different continual learning setups.\n* The proposed MOCA, especially the weight-adversarial perturbation version, brings performance improvement, when combined with existing memory-based continual learning methods.\n* This paper is very well-written, and easy-to-follow.\n\n### Weaknesses\n* The motivation on necessity of i.i.d. training for continual learning with its relation to the proposed MOCA is a bit unclear, and this point is also not experimentally justified well.", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "Yes", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "paper_topic_and_main_contributions": "", "excitement": null, "reproducibility": null, "ethical_concerns": "", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "", "summary_of_contributions": "This paper aims to model the intra-class variation for tackling the catastrophic forgetting issue with the memory-based continual learning methods, by diversifying the representation spaces of target classes. In particular, to add variation in the representation space, the authors explore two individual directions: model-agnostic variation where the variation is made by simple parametric distributions; and model-based variation where the variation is made by characteristics of trained neural networks. The authors evaluate the proposed method, named as MOCA, on offline, online, and proxy continual learning setups with CIFAR-10, CIFAR-100, and TinyImageNet datasets, on which the proposed MOCA, which is used along with other memory-based continual learning methods as the plug-and-play component, brings performance improvements.\n", "claims_and_evidence_yn": "Yes", "claims_explanation": "", "audience_yn": "Yes", "audience_explanation": "", "requested_changes": "### Minor suggestions that would strengthen the work in my point of view\n* Why i.i.d. training is necessary for continual learning, and why such the i.i.d. training scheme is achieved by adding diversity in intra-class representations are unclear, which I suggest authors to more clearly describe in the next revision.\n* It would be great, if the authors experimentally justify the necessity of i.i.d. training for continual learning, and its relationship to the proposed MOCA that adds feature variations.\n* I suggest authors to tone-down the claim for results in Figure 9. The authors argue the Gaussian version of the proposed MOCA is more effective in capturing the class discriminativeness, compared to the naive baseline; however, the results between them are similar. ", "broader_impact_concerns": "While there are no explicit sections for the broader impact statement, I do not have concerns about the ethical implications of this work.", "additional_comments": "", "extra_scores": {}, "extra_text": {}}]

Author rebuttal:

Meta-review: This paper models the intra-class variation for tackling the catastrophic forgetting issue with the memory-based continual learning methods, by diversifying the representation spaces of target classes. Given the original submission, the reviewers posted quite some comments, but they are well addressed by the author response and the revised version of their paper. One reviewer suggested that the authors should make one more effort to clarify the missing details on training, such as the convergence and the angle-based classifiers. We believe by making such minor revisions, the paper quality will be further improved.
Decision: Accept (poster)