CONTINUAL LEARNING IN LOW - COHERENCE SUBSPACE : A STRATEGY TO MITIGATE LEARNING CAPACITY DEGRADATION
Anonymous authors
Paper under double-blind review
A BSTRACT
Methods using gradient orthogonal projection, an efficient strategy in continual learning, have achieved promising success in mitigating catastrophic forgetting.
However, these methods often suffer from the learning capacity degradation problem following the increasing number of tasks.
To address this problem, we propose to learn new tasks in low-coherence subspaces rather than orthogonal subspaces.
Specifically, we construct a unified cost function involving regular DNN parameters and gradient projections on the Oblique manifold.
We finally develop a gradient descent algorithm on a smooth manifold to jointly minimize the cost function and minimize both the inter-task and the intra-task coherence.
Numerical experimental results show that the proposed method has prominent advantages in maintaining the learning capacity when tasks are increased, especially on a large number of tasks, compared with baselines.
Li & Lin (2018)
I NTRODUCTION
D eep N eural N etworks (DNNs) have achieved promising performance on many tasks.
However, they lack the ability for continual learning, i.e., they suffer from catastrophic forgetting French (1999) when learning sequential tasks, where catastrophic forgetting is a phenomenon of new knowledge interfering with old knowledge.
Research on continual learning, also known as incremental learning
Aljundi et al.
(2018a)
; Chaudhry et al.
(2018a)
; Chen & Liu (2018); Aljundi et al.
(2017), and sequential learning Aljundi et al.
(2018b)
; McCloskey & Cohen (1989), aims to find effective algorithms that enable DNNs to simultaneously achieve plasticity and stability, i.e., to achieve both high learning capacity and high memory capacity.
Various methods have been proposed to avoid or mitigate the catastrophic forgetting De Lange et al.
(2019), either by replaying training samples Rolnick et al.
(2019); Ayub & Wagner (2020)
; Saha et al.
(2021), or reducing mutual interference of model parameters, features or model architectures between different tasks Zenke et al.
; Mallya & Lazebnik (2018); Wang et al.
Among these methods, G radient O rthogonal P rojection (GOP) Chaudhry et al.
; Zeng et al.
Farajtabar et al.
; Li et al.
(2021) is an efficient continual learning strategy that advocates projecting gradients with the orthogonal projector to prevent the knowledge interference between tasks.
GOP-based methods have achieved encouraging results in mitigating catastrophic forgetting.
However, from Fig. 1, we observe that these methods suffer from the learning capacity degradation problem: their learning capacity is gradually degraded as the number of tasks increases and eventually becomes unlearnable.
Specifically, when learning multiple tasks, e.g., more than 30 tasks in Fig.
1, their performance on new tasks dramatically decreases.
These results suggest that the GOP-based methods focus on the stability and somewhat ignore the plasticity.
Ignoring the plasticity may limit the task learning capacity of models, i.e., the number of tasks that a model can learn without forgetting.
To address this issue, we propose to learn new tasks in low-coherence subspaces rather than orthogonal subspaces.
Specifically, Low-coherence projectors are utilized for each layer to project features and gradients into low-coherence subspaces.
To achieve this, we construct a unified cost function to find projectors and develop a gradient descent algorithm on the Oblique manifold to jointly minimize inter-task coherence and intra-task coherence.
Minimizing the inter-task coherence can reduce the mutual interference between tasks, and minimizing the intra-task coherence can enhance the model’s expressive power.
Restricting projectors on the Oblique manifold can avoid the scale ambiguity
Aharon et al.
; Wei et al.
(2017), i.e., preventing the parameters of the projector from being extremely large or extremely small.
The main contributions of this work are summarized as follows.
First, to address the learning capacity degradation problem of GOP, we propose a novel method, namely, L ow-
c oherence S ubspace
P rojection (LcSP), that replaces the orthogonal projectors with the low-coherence gradient projectors, allowing the DNN to maintain both plasticity and stability.
Additionally, our work observes that the
GOP models with B atch N ormalization (BN) Ioffe & Szegedy (2015) layers could cause catastrophic forgetting.
This paper proposes two strategies in LcSP to solve this problem, i.e., replacing BN with
G roup N ormalization (GN)
Wu & He (2018) or learning specific BN for each task.
R ELATED W ORK
In this section, we briefly review some existing works of continual learning and the GOP based methods.
Replay-based Strategy The basic idea of this type of approach is to use limited memory to store small amounts of data (e.g., raw samples) from previous tasks, called episodic memory, and to replay them when training a new task.
Some of the existing works focused on selecting a subset of raw samples from the previous tasks Rolnick et al.
(2019); Isele & Cosgun (2018); Chaudhry et al.
Zhang et al.
In contrast, others concentrated on training a generative model to synthesize new data that can substitute for the old data Shin et al.
(2017); Van de Ven & Tolias (2018);
Lavda et al.
; Ramapuram et al.
Regularization-based Strategy
This strategy prevents catastrophic forgetting by introducing a regularization term in the loss function to penalize the changes in the network parameters.
Existing works can be divided into data-focused, and prior-focused methods De Lange et al.
The
Data-focused methods take the previous model as the teacher and the current model as the student, transferring the knowledge from the teacher model to the student model through knowledge distillation.
Typical methods include LwF Li & Hoiem (2017), LFL Jung et al.
(2016), EBLL Rannen et al.
DMC Zhang et al.
and GD-WILD Lee et al.
The prior-focused methods estimate a distribution over the model parameters, assigning an importance score to each parameter and penalizing the changes in significant parameters during learning.
Relevant works include SI Zenke et al.
(2017), EWC Kirkpatrick et al.
RWalk Chaudhry et al.
(2018a),
AGS-CL Jung
et al.
(2020) and IMM Lee et al.
Parameter Isolation-based Strategy
This strategy considers dynamically modifying the network architecture by pruning, parameter mask, or expansion to greatly or even completely reduce catastrophic forgetting.
Existing works can be roughly divided into two categories.
One is dedicated to isolating separate sub-networks for each task from a large network through pruning techniques and parameter mask, including PackNet Mallya & Lazebnik (2018), PathNet Fernando et al.
(2017), HAT
Serra et al.
and Piggyback Mallya et al.
Another class of methods dynamically expands the network architecture, increasing the number of neurons or sub-network branches, to break the limits of expressive capacity (Rusu et al., 2016;
Aljundi et al., 2017; Xu & Zhu, 2018; Rosenfeld &
Tsotsos, 2018).
However, as the number of tasks growing, this approach also complicates the network architecture and increases the computation and memory consumption.
Gradient Orthogonal Projection-based Strategy Methods based on GOP strategies, which reduce catastrophic forgetting by projecting gradient or features with orthogonal projectors, have been shown to be effective in continual learning with encouraging results Farajtabar et al.
Zeng et al.
; Saha et al.
; Wang et al.
; Chaudhry et al.
According to the different ways of finding the projector, we can further divide the existing works into C ontext
O rthogonal
P rojection (COP) and S ubspace O rthogonal P rojection (SOP).
Methods based on COP, such as OWM
Zeng et al.
Adam-NSCL Wang et al.
(2021), and GPM Saha et al.
(2021), always rely on the context of previous tasks to build projectors.
In contrast to COP, SOP-based methods such as
ORTHOG-SUBSPACE Chaudhry et al.
(2020) use hand-crafted, task-specific orthogonal projectors and yield competitive results.
This paper proposes a novel approach to continual learning called LcSP.
Compared with other methods based on GOP, LcSP trains the network on the low-coherence subspaces to balance plasticity and stability and overcomes the learning capacity degradation problem, which significantly decreases the performance of GOP methods with the increasing number of tasks.
C ONTINUAL L EARNING S ETUP
This work adopts the Task-Incremental Learning (TIL) setting, where multiple tasks are learned sequentially.
Let us assume that there are T tasks, denoted by T t for t = 1 , . .
, T with its training data D t = { ( x i , y i , τ t ) N t
i =1 } .
Here, the data ( x i , y i ) ∈
X × Y t is assumed to be drawn from some independently and identically distributed random variable, and τ t ∈ T denotes the task identifier.
In the TIL setting, the data D t can be accessed if and only if task T t arrives.
When episodic memory is adopted, a limited number of data samples drawn from old tasks can be stored in the replay buffer M so that D t ∪ M can be used for training when task T t arrives.
Assuming that a network f parameterized with Φ = { θ, φ } consists of two parts, where θ denotes the parameters of the backbone network and φ denotes the parameters of the classifier.
Let f ( x ; θ ) :
X × T → H denote the backbone network parameterized with θ = { W l } Ll =1 , which encodes the data samples x into feature vector.
Let f ( x ; φ ) :
H → Y denote the classifier parameterized with φ = w which returns the classification result of the feature vector obtained by f ( x ; θ ) .
The goal of
TIL is to learn T tasks sequentially with the network f and finally achieve the optimal loss on all tasks.
Evaluation Metrics Once the training on all tasks is finished, we evaluate the performance of algorithm by calculating the average accuracy A and forgetting F Chaudhry et al.
(2020) of the network on the T tasks {T 1 , ..., T T } .
Suppose all tasks come sequentially, let Acc i,j denote the test accuracy of the network on task T i after learning task T j , where i ≤ j .
The average accuracy is defined as
[Equation]
and the forgetting is defined as
[Equation]
C ONTINUAL L EARNING IN L OW - COHERENCE S UBSPACES
In this section, we first introduce how to find task-specific, low-coherence projectors for LcSP on the
Oblique manifold.
We then describe how to use it in a specific DNN architecture to project features and gradients.
Finally, we analyze the factors that enable LcSP to maintain plasticity and stability.
4. C ONSTRUCTING LOW - COHERENCE P ROJECTORS ON O BLIQUE M ANIFOLD
Here, we first introduce the concept of coherence metric.
The coherence metric is usually used in compressed sensing and sparse signal recovery to describe the correlation of the columns of a measurement matrix Candes et al.
(2011); Candes & Romberg (2007).
Formally, the coherence of a matrix M is defined as
[Equation]
where M j and M k denote the column vectors of matrix M .
Without causing confusion, we use µ ( M ) denote µ ( M , M ) .
To measure the coherence between different projectors, we introduce the Babel function Li & Lin (2018), measuring the maximum total coherence between a fixed atom and a collection of other atoms in a dictionary, which can be described as follows.
[Equation]
With the concept of a coherence metric in mind, we then introduce the main optimization objective in finding projectors.
Specifically, suppose that the DNN has learned the task T 1 , T 2 , ..., T t − 1 in the subspace S 1 , S 2 , ..., S t − 1 , respectively, and P 1 , P 2 , .., P t − 1 denote the projectors of all previous tasks.
When learning task T t , we project features and gradients into a d t -dimensional low-coherence subspace S t with projector P t so that the LcSP can prevent catastrophic forgetting.
The projector P t can be found by optimizing
[Equation]
Two considerations need to be taken in solving Eq.
(5), i.e., considering the rank constraint and avoiding the entries of P t being extremely large or extremely small.
With these considerations in mind, we can rephrase the rank and scale constrained problem as a problem on the Riemannian manifold, more specifically on the Oblique manifold OM ( m, d t ) , by setting P t =
O t O ⊤ t and normalizing the columns of O t , i.e, diag( O ⊤ t O t )
=
I n , where diag( · ) represents the diagonal matrix and I n is the n × n identity matrix.
With these settings, the new cost function J ( · ) and optimization problem can be described as follows:
[Equation]
In the cost function J ( O t ) , we further divided the optimization objective into inter-task B ( O t O ⊤ t ) and intra-task µ ( O t O ⊤ t ) , and utilize parameters λ and γ to provide a trade-off between them.
Here, intra-task coherence is optimized to maintain the full rank of O t .
Meeting the full-rank constraint helps to balance plasticity and stability in the case of increasing tasks.
Relevant ablation studies and numerical analyses are given in the appendix.
Optimization on the Oblique manifold, i.e., the solution lies on the Oblique manifold, is a wellestablished area of research Absil et al.
Absil & Gallivan (2006); Selvan et al. (2012).
Here, we briefly summarize the main steps of the optimization process.
Formally, the Oblique manifold
OM ( n, p ) is defined as
[Equation]
representing the set of all n × p matrices with normalized columns.
OM can also be considered as an embedded Riemannian manifold of R n × p , endowed with the canonical inner product
[Equation]
where trace( · ) represents the sum of the diagonal elements of the given matrix.
For a given point X on OM , the tangent space at X , denoted by T X OM , is defined as
[Equation]
Further, the tangent space projector P X at X which projects H ∈ R n × p into T X OM , is represented as
[Equation]
10) where ddiag sets all off-diagonal entries of a matrix to zero.
When optimizing on OM , the k th iterate X k must move along a descent curve on OM for the cost function, such that the next iterate
X k +1 will be fixed on the manifold.
This is achieved by the retraction
[Equation]
where normalize scales each column of the input matrix to have unit length.
Finally, with this knowledge, we can extend the gradient descent algorithm to solve any unconstrained optimization problems on OM , which can be summarized as
[Equation]
where ∇ X k J denotes the Euclidean gradient at the k th iterate and α is the step size.
Finally, our algorithm for finding O t in OM to task T t is summarized in Algorithm 1. Algorithm 1 Construct the O t on OM for Task T t
[Table]
4. T HE A PPLICATION OF L OW - COHERENCE P ROJECTORS IN DNN S
With the LcSP at hand, the following introduces some technical details of applying LcSP in DNNs.
When learning task T t , LcSP first constructs task-specific projector P lt for each layer before training, and freezes them during training.
These projectors are used to project the features and gradients, ensuring that the DNN learns in the low-coherence subspace.
Specifically, suppose that a network f with L linear layers is used as DNN architecture, let W lt , x lt , z lt , σ l , and P lt denote the model parameters, the input features, the output features, the activation function, and the introduced lowcoherence projector in layer l ∈ { 1 , ..., L } , respectively.
LcSP introduces P lt immediately after W lt such that the pre-activation features are projected into the subspace, i.e.,
[Equation]
According to the chain rule of derivation, the gradients at W lt will also be multiplied with P tl in backpropagation, as follows
[Equation]
where ( W lt ) ( i, :) represents the i th row of W lt and ( x lt ) i is the i th element of x lt .
In C onvolutional
N eural N etworks (CNNs), the input and the output typically represent the image features and have more than two dimensions, e.g., input channel, output channel, height, and width.
In this case, we reshape z l ∈ R c out × ( c in · h · w ) to z l ∈ R ( c in · h · w ) × c out and align the dimension of projector with the output channel so that P lt ∈ R c out × c out .
After the projection, we recover the shape of z lt so that it can be used as input for the next layer.
Overcoming the Catastrophic Forgetting in BN based models BN is a widely used module in
DNNs to make training of DNNs faster and more stable through normalization of the layers’ features by re-centering and re-scaling Ioffe & Szegedy (2015).
However, re-centering and re-scaling of the layers’ features changes the data distribution (e.g., the mean and the variance) of features of previous tasks, which often leads to the catastrophic forgetting of LcSP.
For example, when learning the new task T t , W lt may not work for T t due to the change in data distribution caused by BN.
To solve this problem, we propose two strategies in LcSP: the strategy (1) learning specific BN for each task, or the strategy (2) using GN instead of BN.
We verify the effectiveness of these two strategies in experiments and compare their performance in § 5.
4. M ETHOD A NALYSIS
In this section, we provide analysis on plasticity and stability of LcSP.
Stability Analysis Let θ =
{ W lt } Ll =1 denote the parameter set of f ; ∆ θ = { ∆ W 1 t , . . .
, ∆ W Lt } denote set of variation values of parameters after learning task T t ; P t = { P lt } Ll =1 denote the projectors set obtained by Algorithm 1; x lq,t and z lq,t denote the input and ouput when feeding the data of task
T q ( q ≤ t ) into the network f , which has been optimized in learning task T t .
Lemma 1.
Assume that f is fed the data of task T t ( q < t ) , then f can effectively overcomes catastrophic forgetting if
[Equation]
holds for l ∈ { 1 , 2 , ..., L } .
Lemma 1 suggests that f can overcome catastrophic forgetting if the output of f to previous tasks is invariant.
In the following, we prove that LcSP achieves approximate invariance to the output of previous tasks.
Proof.
Suppose q = t − 1 .
When l = 1 , x lq,t = x lq,q .
Then
[Equation]
Let g lt denote the gradient when training the network on task T t .
In backpropagation, ∆ W lt = g lt P lt .
Then x lq,t ∆ W lt P lq = x lq,t g lt P lt P lq .
If the inter-task coherence µ ( P lt , P lq ) ≈ 0 , then P lt P lq ≈ 0 .
Projectors satisfying this condition can be found by Algorithm 1.
We can prove that z lq,q ≈ z lq,t holds for all layers by repeating the above process.
This proof can also be generalized to any previous task
T q .
Plasticity Analysis Let ˜ g lt = g lt P lt denote the projected gradient at W lt .
f can achieve optimal loss on task T t if ⟨ g lt , ˜ g lt ⟩ > 0 holds for each l ∈ { 1 , . . .
, L } , where ⟨· , ·⟩ represents the inner product.
Here, we prove that ⟨ g lt , ˜ g lt ⟩ > 0 holds for each l ∈ { 1 , . . .
, L } .
Proof.
Let ˜ g lt = g lt P lt denote the projected gradient, we have
[Equation]
Note that ∥ g lt O lt ∥ is always positive unless g lt O lt is 0 .
This result is easy to generalize to each layer.
E XPERIMENTS
In this section, we evaluate our approach on several popular continual learning benchmarks and compare LcSP with previous state-of-the-art methods.
The result of accuracy and forgetting demonstrate the effectiveness of our LcSP, especially when the number of tasks is large.
5. B ENCHMARKS
Benchmarks for Learning 20 Tasks We conducted this experiment on four image classification datasets: Permuted MNIST, Rotated MNIST, Split CIFAR100 and Split miniImageNet.
Permuted
MNIST is constructed by randomly rearranging MNIST LeCun (1998) image pixels, using different seeds for different tasks.
Rotated MNIST is constructed by rotating the MNIST image at a certain [Table] angle.
The rotation angle is a random value between [0 , π ] and arbitrary selection for different tasks.
In this experimental setup, both of the above MNIST datasets contain 20 tasks, each task containing 10,000 samples from 10 classes.
Split CIFAR is constructed by splitting CIFAR100 into multiple tasks, where each task contains the data pertaining to five random classes (without replacement) out of the total 100 classes.
Split miniImageNet Vinyals et al.
(2016) is a subset of ImageNet.
In Split miniImageNet, each task contains the data from five random classes (without replacement) out of 100 classes.
Both CIFAR100 and miniImageNet contain 20 tasks, each contains 250 samples from each of the five classes.
Benchmarks for Learning 150 Tasks and 64 Tasks
This experiment was conducted on two image classification datasets: Permuted MNIST and Permuted CIFAR10.
Both Permuted MNIST and
Permuted CIFAR10 are obtained by randomly rearranging image pixels.
In this experimental setup,
Permuted MNIST contains 150 tasks, and Permuted CIFAR10 contains 64 tasks, each containing 10,000 samples from 10 classes.
5. B ASELINES
We compare the proposed method with SOTA based on GOP.
As aforementioned, we generalize
GOP into COP and SOP.
For methods based on the COP strategy, we compare proposed method with
OWM Zeng et al.
Adam-NSCL Wang et al.
and GPM Saha et al.
For methods based on the SOP strategy, we compare the proposed method with ORTHOG-SUBSPACE Chaudhry et al.
Moreover, we also compare our method with HAT Serra et al.
(2018), EWC Kirkpatrick et al.
(2017), ER-Ring Chaudhry et al.
(2019), AGEM Chaudhry et al.
(2018b)
and K ernel C ontinual
L earning (KCL) Derakhshani et al.
[Figure]
[Figure]
5. I MPLEMENTATION D ETAILS
Learning 20 Tasks For experiments on Permuted MNIST and Rotated MNIST, all methods use a fully connected network with two hidden layers, each with 256 neurons, using ReLU activations.
For experiments on CIFAR and miniImageNet, all methods use standard ResNet18 architecture except
OWM, HAT, and GPM which use AlexNet Krizhevsky et al.
As described in § 4.2, the proposed LcSP makes two changes to the BN layer in standard ResNet18: (1) learning specific BN for each task and (2) replacing BN with GN.
We also apply these strategies to ORTHOG-SUBSPACE for additional comparison.
For experiments on MNIST, all tasks share the same classifier.
For experiments on CIFAR and miniImageNet, each task requires a task-specific classifier.
For all experiments, LcSP does not use episodic memory to store data samples for data replay.
For all methods, We use S tochastic G radient D escent (SGD) uniformly.
The learning rate is set to 0 .
01 for experiments on MNIST and 0 .
003 for experiments on CIFAR and ImageNet.
Both λ and γ in Eq.
( ?? ) are set to 1 .
All experiments were run five times with five different random seeds, with the batch size besing 10 .
Learning 150 Tasks and 64 Tasks For experiments on Permuted
CIFAR10, LcSP uses ResNet architecture and applies the strategy (1) to change BN in ResNet18.
To compare the performance of different GOP strategies, we did not use episodic memory for ORTHOG-SUBSPACE.
Except for these changes, other experimental settings are the same as described above.
5. E XPERIMENTAL R ESULTS
Comparisons of Learning 20 Tasks Table 1 compares the average accuracy and forgetting results of the proposed LcSP and its variants ( LcSP-BN and LcSP-GN ) with baselines on the four continual learning benchmarks.
Therein, LcSP-BN and LcSP-GN adopt strategy (1) and (2) described in § 4.2, respectively.
First, as shown in Table 1, the proposed methods outperform all baselines on
MNIST and miniImageNet.
On Permuted MNIST and Rotated MNIST, the average accuracy of
LcSP surpasses the baselines by 23 .
8% ∼ 5 .
6% and 43% ∼ 4 .
8% , respectively.
On miniImageNet, the average accuracy of LcSP-BN surpasses the baselines by 44 .
9% ∼ 4 .
On CIFAR100, the proposed LcSP-BN achieved a competitive performance with the second highest average accuracy, 3.25% lower than Adam-NSCL, and a forgetting rate of 0.
The average accuracy of LcSP-GN also outperforms most baselines, being lower than Adam-NSCL, HAT and GPM on CIFAR but higher than compared methods on miniImageNet.
These results suggest that minimizing the inter-task and intra-task coherence with low-coherence projectors is an effective strategy for solving catastrophic forgetting.
Secondly, results on CIFAR100 and miniImageNet also show that BN in
ORTHOG-SUBSPACE Chaudhry et al.
and LcSP may change previous tasks’ data distribution and lead to catastrophic forgetting.
Both strategies (1) and (2) described in § 4.2 can effectively solve this problem.
Comparisons of Learning 150 Tasks and 64 Tasks
In order to demonstrate the high advantage of proposed methods in learning a long sequence of tasks, the following experiments compare the results with 64 tasks and 150 tasks.
Note that, in Fig.
1, LcSP (orthogonal) and LcSP-BN (orthogonal) use orthogonal projectors as comprisons while LcSP (low-coherence) and
LcSP-BN (low-coherence) use low-coherence projectors.
Fig.
1(a) and 1(b) report the average accuracy and forgetting of lasttasks, with learning 150 tasks on Permuted MNIST.
Fig.
1(c) and 1(d) report the average accuracy and forgetting of last 5 tasks with learning 64 tasks on Permuted CIFAR10.
The average accuracy of all methods, except the proposed LcSP-BN (low-coherence), dramatically degrades or is consistently low as the number of tasks increases.
Furthermore, it can be seen from 1(d) that all methods except ORTHOG-SUBSPACE have almost no forgetting.
This result indicates that methods using orthogonal projectors gradually lose their learning capacity with increasing number of tasks.
The proposed method uses the low-coherence projector to relax the orthogonal restriction, effectively solving this problem.
Fig.
2 gives the ablation study and shows the performance of our method with different λ and γ .
When λ equals γ , the result of average accuracy on Permuted MNIST reached the highest.
Results reach the worst when either λ or γ equals zero.
These results indicate that both inter-task and intra-task coherence should be minimized to solve the plasticity and stability dilemma.
C ONCLUSION
This paper proposed a novel gradient projection approach for continual learning to address gradient orthogonal projection’s learning capacity degradation problem.
Instead of learning in orthogonal subspace, we propose projecting features and gradients via low-coherence projectors to minimize inter-task and intra-task coherence.
Additionally, two strategies have been proposed to mitigate the catastrophic forgetting caused by the BN layer, i.e., replacing BN with GN or learning specific BN for each task.
Extensive experiments show that our approach works well in alleviating forgetting and has a significant advantage in maintaining learning capacity, especially in learning long sequence tasks.
A A PPENDIX
In this section we give the implementation details about the experiments on Permuted MNIST and
Permuted CIFAR to help readers reproduce these experiments.
Additionally, more ablation studies and experimental results are provided here to further support the conclusions and contributions
A. I MPLEMENTATION DETAILS
The main hyperparameter settings are listed in Table 2 and 3.
For the baselines, we adopt the default settings provided in their code to bring out the proper performance.
For fair comprision, we use the uniform Batch size for all methods.
[Table] [Table]
[Figure]
A. ABLATION STUDIES AND ADDITIONAL RESULTS
Additional results on Permuted MNIST and Permuted CIFAR10 Readers may wonder whether our conclusion holds if we evaluate the average performance with more tasks (e
[Figure]
g., the average accuracy and forgetting on the last 20 tasks).
As shown in Fig.3, LcSP still outperforms all baselines with a significant advantage.
However, the phenomenon of learning capacity degradation in baselines becomes more imperceptible, e
[Figure]
g., the average accuracy of OWM on Permuted CIFAR10 is consistently low, rather than significantly decreasing.
To further investigate the learning capacity degradation problem, we give the accuracy of baselines for the last task on Permuted MNIST and
Permuted CIFAR10.
As shown in Fig.7, all baselines, except LcSP, suffer from this problem with different degrees and show some decrease in accuracy compared to the initial ( 66 .
16% ∼ 24 .
63% on Permuted MNIST and 24 .
8% ∼ 3 .
48% on Permuted CIFAR10).
These results suggest that this
[Figure] [Figure]
problem is the critical factor that results in degrading the performance of GOP-based methods in the case of a large number of tasks.
Ablation studies and experiments for rank and scale constraints Further ablation studies and experiments are conducted to investigate the effects of the rank and scale constraints on the expressive power (plasticity) and stability of DNNs.
The result in Fig.5(a) suggests that projecting features or gradients into subspaces with low dimensions (e.g., lower than 5 in Fig.5(a) ) will decrease the expressive power of DNN.
GOP methods and LcSP rely on the projectors to project the features or gradients (or both) into a d -dimensional subspace, which can also be considered as a form of dimension reduction.
The dimension reduction is motivated by a consensus in the high-dimensional data analysis community, i.e., the data can be summarized in a low-dimensional space embedded in a high-dimensional space, such as a nonlinear manifold
Levina & Bickel (2004).
The dimension of this low-dimensional space is also known as the intrinsic dimension D Carreira-Perpin´an (1997).
If the d is too small, e.g., d ≪ D , important data features will be ”collapsed” onto the same dimension.
From the perspective of training a DNN, if the gradients are projected into a subspace with a dimension lower than D , the DNN cannot activate sufficient parameters to learn the presentation of this task.
Due to the unknown number of tasks to be learned, the limited dimensions of the features, and the strict orthogonality constraint between projectors, the orthogonal projector cannot be constrained to a fixed-rank manifold.
As shown in Fig.5(b), the rank of the orthogonal projector decreases as the number of tasks increases.
Therefore, methods using orthogonal projectors usually ignore the intrinsic dimension of data (features or gradients) and finally lead to suffering from the learning capacity degradation problem.
In contrast to GOP methods, LcSP relaxes the orthogonality constraint
[Figure]
and meets the rank constraint by optimizing intra-task coherence on the Oblique manifold and thus does not suffer from this problem.
Finally, Fig.6 gives an ablation study for scale constraints on the projector’s columns.
In Fig.6, when the columns of the projector have unit length, the average accuracy reaches the highest.
Result gets worse when the length of the projector’s columns is too small or too large.
[Table]
[Figure]
[Table]
Based on the RTX3060 12G, we tested the efficiency of LcSP and compared methods on Permuted
CIFAR10 (which contains 64 tasks, and each image’s size is 3 × 32 × 32 ), using AlexNet for OWM and GPM, and resnet18 for the other methods.
We provide 4 metrics to assess the efficiency of the method: floating point operations FLOPs , time spent per epoch during training Time (s) , the number of epochs needed to train to convergence Epochs , and the average time spent on inference
Mean inference time (ms) .
The detailed results are listed in Table.4.
[Figure]
All methods use the low-coherence projector.
A. M ETHOD ANALYSIS
The mechanism of low-coherence learning and the difference with orthogonal learning Recall the Lemma 1 described in Section 4.3.
Lemma 1.
Assume that f is fed the data of task T t ( q < t ) , then f can effectively overcomes catastrophic forgetting if
[Equation]
Here, z lq,t denotes the output feature of l -th layer when data from task T q are fed into the DNN that has been trained on task T t .
Let us consider the case where there are only two tasks, i.e., q = t − 1 .
By appling the LcSP’s projection strategy, we have
[Equation]
Here, g lt , x lq,t and P lt denote the gradient, input data, and projection matrix (which is a symmetric matrix) of task T t in l -th layer, respectively.
The term x lq,t g lt P lt P lq can be thought of as the forgetting, which changes the output of DNN to previous data.
Since we cannot change x lq,t and g lt , the key to reduce x lq,t g lt P lt P lq is to minimize P lt P lq .
If P lt is orthogonal to P lq , the forgetting is equal to 0.
Let us consider reducing forgetting when P lt cannot be orthogonal to P lq (e.g., the number of tasks is large and the dimensionality of the space is limited).
If we optimize P lt P lq directly, we may get
P lt = 0 , or the column scale of P lt is too small.
To find a useful P lt , LcSP constrains the length of the column vector to be 1, i.e., to find P lt on the Oblique manifold ( OM ).
To reduce forgetting, we optimize the inter-task coherence µ ( P lt , P lq ) on OM so that the maximum entry of P lt P lq is minimized.
In the worst case, we may obtain P lt consisting of only one column vector (i.e., P lt with rank 1).
To avoid this situation, we optimize the intra-task coherence µ ( P lt ) along with inter-task coherence, forcing the projector to satisfy the rank constraint in order to maintain the learning capacity of DNN (as shown in Fig. 5(a), the rank of projector affects the plasticity of DNN).
In general, low-coherence projection, which can be seen as a relaxed orthogonal constraint, aims to balance plasticity and stability better, motivated by our observation that orthogonal projections reduce the plasticity of the model and make the DNN unable to adapt to new environments.