Introduction

Learning a sequence of tasks incrementally, called continual learning, has attracted a great deal of attention recently (Chen & Liu, 2018). In the supervised learning context, each task consists of a set of concepts or classes to be learned. It is assumed that all tasks are learned in one neural network, which results in the key challenge of catastrophic forgetting (CF) because when learning a new task, the system has to modify the network parameters learned from old tasks in order to learn the new task, which may cause performance degradation for the old tasks (McCloskey & Cohen, 1989). Two continual learning settings have been popularly studied: task incremental learning (TIL) (van de Ven & Tolias, 2019) and class incremental learning (CIL).

In TIL, each task is an independent classification problem and has a separate model (the tasks may overlap). At test time, the task-id of each test instance is provided to locate the task-specific model to classify the test instance. Definition 1.1 (Task Incremental Learning (TIL)). TIL learns a sequence of tasks, 1, 2, ..., T . The training set of task k is

, where n k is the number of samples in task k ∈ T = {1, 2, ..., T }, and x i k ∈ X is an input sample and

) is its label. A TIL system learns a function f : X × T → Y to assign a class label y ∈ Y k to (x, k) (a test instance x from task k).

For CIL, a single model is built for all tasks/classes learned thus far (the classes in each task are distinct). At test time, no task-id is provided for a test instance. Definition 1.2 (Class Incremental Learning (CIL)). CIL learns a sequence of tasks, 1, 2, ..., T . The training set of task k is

, where n k is the number of samples in task k ∈ T = {1, 2, ..., T }, and x i k ∈ X is an input sample and

A CIL system learns a function (predictor or classifier) f : X → Y that assigns a class label y to a test instance x.

CIL is a more challenging setting because in addition to CF, it has the inter-task class separation (ICS) (Kim et al., 2022b) problem. ICS refers to the situation that since the learner has no access to the training data of the old tasks when learning a new task, then the learner has no way to establish the decision boundaries between the classes of the old tasks and the classes of the new task, which results in poor classification accuracy. Kim et al. (2022b) showed that a good within-task prediction (WP) and a good out-ofdistribution (OOD) detection for each task are necessary and sufficient conditions for a strong CIL model. Definition 1.3 (out-of-distribution (OOD) detection). Given the training set D = {(x i , y i ) n i=1 }, where n is the number of data samples, x i ∈ X is an input sample and y i ∈ Y is its class label. Y is the set of all classes in D and called the in-distribution (IND) classes. Our goal is to learn a function f : X → Y ∪ {O} that can detect test instances that do not belong to any classes in Y (OOD)), which are assigned to class O, denoting out-of-distribution (OOD).

The intuition of the theory in (Kim et al., 2022b) is that if OOD detection is perfect for each task, then a test instance will be assigned to the correct task model to which the test instance belongs for classification, i.e., within-task prediction (WP). However, (Kim et al., 2022b) does not prove that CIL is learnable. To our knowledge, no existing work has reported a learnability study for CIL (see Sec. 2). This paper performs the CIL learnability study.

The proposed learnability proof requires two assumptions:

(1) OOD detection is learnable. Fortunately, this has been proven in a recent paper (Fang et al., 2022). (2) There is a mechanism that can completely overcome forgetting (CF) for the model of each task. Again, fortunately, there are many existing TIL methods that can eliminate forgetting, e.g., parameter-isolation methods such as HAT (Serrà et al., 2018) and SupSup (Wortsman et al., 2020), which work by learning a sub-network in a shared network for each task. The sub-networks of all old tasks are protected when training a new task. Orthogonal projection methods such as PCP (Kim & Liu, 2020) and CUBER (Lin et al., 2022) can also overcome forgetting in the TIL setting.

CIL can be solved by a combination of [a] a TIL method that is able to protect each task model with no CF, and [b] a normal supervised learning method for WP and [c] an OOD detection method. [b] and [c] can be easily combined either (i) with an OOD detection model since it also learns the IND classes (see Definition 1.3) or (ii) a WP model that can also perform OOD detection. That is, for CIL, we simply replace the classification model built for each task in HAT/SupSup with a combined WP and OOD detection model.

Based on the theory, we propose a new replay-based CIL method that uses the combination of [a] and (ii) (two separate heads for each task, one for WP and the other for OOD detection based on the same feature extractor). This paper thus makes two main contributions:

(1). It performs the first learnability study of CIL. To the best of knowledge, no such a study has been reported so far.

(2). Based on the theory, a new CIL method, called ROW (Replay, OOD, and WP for CIL), is proposed. Experimental results show that it outperforms existing strong baselines.

It is interesting to note that our theory, including our earlier work in (Kim et al., 2022b), in fact, unifies OOD detection and continual learning as it covers both (Kim et al., 2023). Additionally, the theory is also applicable to open world learning because OOD detection and class incremental learning are two critical components of an open world learning system (Liu et al., 2023).

Related Work

To our knowledge, we are not aware of any paper that studies the learnability of CIL. Below, we survey the existing CL literature on both the theoretical and empirical sides.

On the theoretical side. Pentina & Lampert (2014) proposes a PAC-Bayesian framework to provide a learning bound on expected error by the average loss on the observed tasks. However, this work is not about CIL but about TIL. It focuses on knowledge transfer and assumes that all the tasks have the same input space and the same label space and the tasks are very similar. However, in CIL, every task has a distinct set of class labels. Furthermore, this work is not concerned with CF as earlier research in lifelong learning builds a separate model for each task. Lee et al. (2021) studied the generalization error by task similarity. It is again about TIL. Bennani et al. (2020) showed that a specific method called orthogonal gradient descent (OGD) gives a tighter generalization bound than SGD. As noted in Sec. 1, empirically, the CF problem for TIL has been solved (Serrà et al., 2018;Kim et al., 2022b). Several techniques have also been proposed to carry out knowledge transfer (Ke et al., 2020;2021;Lin et al., 2022). Our work is entirely different as we study the learnability of CIL, which is a more challenging setting than TIL because of the additional difficulty of ICS (Kim et al., 2022b) in CIL. In this work, we are not concerned with knowledge transfer, which is mainly studied for the TIL setting. Recently, Kim et al. (2022b) showed that a good within-task prediction (WP) and a good OOD detection for each task are necessary and sufficient conditions for a strong CIL model. However, Kim et al. (2022b) did not show that CIL is learnable. This paper performs this study. It also proposes a new CIL algorithm.

On the empirical side, a large number of algorithms have been proposed. They belong to several families. (1). Regularization-based methods mitigate CF by restricting the learned parameters for old tasks from being updated significantly in a new task learning using regularizations (Kirkpatrick et al., 2017;Zenke et al., 2017) or knowledge distillation (Li & Hoiem, 2016;Zhu et al., 2021). Many existing approaches have used similar approaches (Ritter et al., 2018;Schwarz et al., 2018;Xu & Zhu, 2018;Castro et al., 2018;Dhar et al., 2019;Lee et al., 2019;Ahn et al., 2019;Liu et al., 2020a). (2). Replay-based methods alleviate CF by saving a small amount of training data from old tasks in a memory buffer and jointly train the model using the current data and the saved buffer data (Rusu et al., 2016;Lopez-Paz & Ranzato, 2017;Chaudhry et al., 2019a;Hou et al., 2019;Wu et al., 2019;Rolnick et al., 2019;Buzzega et al., 2020;Rajasegaran et al., 2020a;Liu et al., 2021;Cha et al., 2021;Yan et al., 2021;Wang et al., 2022b;Guo et al., 2022;Kim et al., 2022a). Some methods in this family also study which samples in memory should be used in replay (Aljundi et al., 2019) or which samples in the training data should be saved (Rebuffi et al., 2017;Liu et al., 2020b). (3). Pseudoreplay methods generate pseudo replay data for old tasks to serve as the replay data (Kamra et al., 2017;Shin et al., 2017;Wu et al., 2018;Seff et al., 2017;Kemker & Kanan, 2018;Hu et al., 2019;Rostami et al., 2019;Ostapenko et al., 2019). (Zhu et al., 2021) generates features instead of raw data. (4). Parameter-isolation methods train and protect a sub-network for each task (Mallya & Lazebnik, 2017;Abati et al., 2020;von Oswald et al., 2020;Rajasegaran et al., 2020b;Hung et al., 2019;Henning et al., 2021). Several systems, e.g., HAT (Serrà et al., 2018) and SupSup (Wortsman et al., 2020), have largely eliminated CF. A limitation is that the task-id of each test instance must be provided. These methods are thus mainly used for TIL. (5). Orthogonal projection methods learn each task in an orthogonal space to other tasks to reduce task interference or CF (Zeng et al., 2019;Kim & Liu, 2020;Chaudhry et al., 2020;Lin et al., 2022).

Our empirical part of the work is related to but also very different from the above methods. We use the replay data as OOD training data to fine-tune an OOD detection head for each task based on the features learned for the WP head and uses the TIL method HAT to overcome CF. Some existing methods have used a TIL method for CIL with an additional task-id prediction technique. iTAML (Rajasegaran et al., 2020b)'s task-id prediction needs the test data come in batches and each batch must be from the same task, which is unrealistic as the test sample usually comes one after another. CCG (Abati et al., 2020), Expert Gate (Aljundi et al., 2017), HyperNet (von Oswald et al., 2020) and PR-Ent (Henning et al., 2021) either build a separate network or use entropy to predict the task-id. LMC (Ostapenko et al., 2021) learns task specific knowledge via local modules capable of task-id prediction. However, they all perform poorly because none of the systems deal with the ICS problem, which is the key and is what our OOD detection is trying to tackle. In this line of work, the most closely related work to ours is MORE (Kim et al., 2022a), which builds a model for each task treating the replay data as OOD data. However, in inference, it considers only the IND classes of each task, but not OOD detector. Our method is more principled and outperforms MORE. The methods in (Kim et al., 2022b) do not use replay data and perform worse.

Learnability of CIL

Before going to the learnability analysis, we first describe the intuition behind. Kim et al. (2022b) showed that given a test sample, the CIL prediction probability for each class in a task is the product of two prediction probabilities: withintask prediction (WP) and task-id prediction (TP),

where X k,j is the domain of task k and class j of the task and x is an instance. The first probability on the right-handside (RHS) is WP and the second probability on the RHS is TP. However, as mentioned earlier, Kim et al. (2022b) did not study whether CIL is learnable. We also note that (Kim et al., 2022b) proved that TP and OOD are correlated and only differ by a constant factor. Based on the definition of OOD detection (Definition 1.3), the OOD detection model can also perform WP. In the recent work in (Fang et al., 2022), it is proven that OOD detection is learnable.

We show that if the learning of each task does not cause catastrophic forgetting (CF) for previous tasks, then CIL is learnable.foot_0 Fortunately, CF can be prevented for each task as several existing task incremental learning (TIL) methods including but not limited to HAT (Serrà et al., 2018) and SupSup (Wortsman et al., 2020) in the parameter-isolation family and PCP (Kim & Liu, 2020) and CUBER (Lin et al., 2022) in the orthogonal projection family can ensure no CF (Kim et al., 2022b). HAT/SupSup basically trains a subnetwork as the model for each task. In learning each new task, all the sub-networks for the previous tasks are protected with masks so that their parameters will not be modified in backpropagation. Thus, in this section, we assume that all tasks are learned without catastrophic forgetting (CF).

We now discuss the learnability of class incremental learning (CIL). The notations for the following discussion are described in Tab. 1. Let X be a feature space, Y a label space, and H a hypothesis function space. Assume H is a ring, because we construct hypothesis functions by addition and multiplication in the proof of Theorem 3.3 and Theorem 3.7. We use

For a series of distributions D (X1,Y1) , . . . , D (X T ,Y T ) , we denote the mixture of the first k distributions as

, where the mixture weights π 1 , . . . , π T > 0

Since continual learning tasks come one by one sequentially, we denote the hypothesis function that is found by an algorithm A after training the k-th task as

and is not well-defined for

Even if some implementation may predict a real value by h k (x ′ ), we regard it as non-sense at time k and only make sense until time k ′ .

For the risk function, we will meet

where z i,j k is the score function of the j-th class of the i-th task. The score function is any function that indicates which class the sample belongs to. For example, the score function could be the predicted logit of each class for a classification algorithm. We calculate

When we write R D α (h) with D α = (1-α)D +αO (where O denotes OOD and α ∈ [0, 1)), we require h to predict one additional OOD class as

where z o k is the score function of the OOD class. Definition 3.1 (Fully-Observable Separated-Task Closed-World Learnability). Given a set of distributions D, a hypothesis function space H, we say CIL is learnable if there exists an algorithm A and a sequence

We use ϵ to represent the error rate, where the index n of ϵ n represents the total number of samples. The equation lim n→+∞ ϵ n = 0 means that the error rate decreases to 0 as n goes to +∞. Definition 3.1, the risk function is calculated over D [1:k] at task k, which means the data of all the past tasks and the current task are observable for optimization. It is a desirable property for CIL to take expectation over D [1:k] as it constructs a model that is equivalent to the model built with the full training data of all tasks. Generally, when an algorithm satisfies Definition 3.1, the system is already learnable because this is just the traditional supervised learning which can see/observe all the training data of all tasks and there is no OOD data involved (which means the closed-world). However, when we apply the algorithm A to solve for A(S) in practice, we usually cannot access all samples in S, which is partially-observable instead of fully-observable. That is the case for continual learning as it assumes that in learning the new/current task, the training data of the previous/past tasks is not accessible, at least a major part of it.

Due to the lack of full observations, we have to define A r k recursively. For any

The algorithm depends on implementation. In the following discussion, we assume that learning a new task does not interrupt the error bound of previous tasks. This is a valid assumption as existing algorithms (Serrà et al., 2018;Wortsman et al., 2020) achieve little or no forgetting. The version of Definition 3.1 for partial observations is as follows.

Definition 3.2 (Partially-Observable Separated-Task Closed-World Learnability). Given a set of distributions D, a hypothesis function space H, we say CIL is learnable if there exists an algorithm A and a sequence

In

The proof of Definition 3.4 is guaranteed by previous work (Fang et al., 2022), which studies the learnablity of OOD detection. It's obvious that when Definition 3.4 is satisfied, Definition 3.1 is satisfied, which is shown in Theorem 3.5. The proof is given in Appendix A. When we have no access to samples of past tasks in practice, we define A k recursively as in Eq. 2. The partial observable version of Definition 3.4 is stated below. In Definition 3.6, the risk function is over D k instead of D [1:k] because it's the partial observable case. Definition 3.6 (Partially-Observable Separated-Task Open-World Learnability). Given a set of distributions D, a hypothesis function space H, we say CIL is learnable if there exists an algorithm A and a sequence

where

Note that Fang et al. (2022)

The proof is given in Appendix A. Theorem 3.7 connects Definitions 3.6 to 3.4 and Theorem 3.5 connects Definitions 3.4 to 3.1, which is the desirable property of CIL. When all tasks have the same weight

π [1:k] = T , which is positively correlated with the number of tasks.

Though Theorem 3.7 gives an upper bound to induce Definition 3.4 from Definition 3.6, the hypothesis function that satisfies Definition 3.4 is recursively derived from the previous tasks (see the proof). We can also observe that when tasks have different weights, the multiplier max k=1,...,T k t=1 π [t:T ] π [1:k] depends on the order of tasks. It is undesirable that the hypothesis function depends on the order of tasks. When we can acquire some replay data of past tasks and treat them as OOD data, we have the following corollary that gives an order-free hypothesis function. (h) = 0, and the loss function on all tasks is bounded by summation of the loss functions on every task i.e. Eq. 10 in Appendix, if we treat data of past tasks as OOD data, then Definition 3.4 holds and the upper bound ϵ n is multiplied by max k=1,...,T kπ

The proof is given in Appendix A.

Proposed Method

The learnability in Definition 3.6 is defined over the OOD function of each task. By Definition 1.3 of OOD, an OOD function is capable of classification (i.e., WP) for IND in-stances and rejection for OOD instances (or TP as it can be defined using OOD and such TP differs from OOD by a constant factor (Kim et al., 2022b)). As discussed early, we use the masks in HAT (Serrà et al., 2018) to protect each OOD model to ensure there is no forgetting. Following exactly this theoretical framework, an algorithm can be designed, which works quite well (see ROW (-WP) in Tab. 4). However, it is possible to do better by introducing a WP head so that we can use the OOD head for estimating only TP rather than for handling both WP and TP.

The proposed method ROW is a replay-based method. At each task k, the system receives dataset D k and leverages the replay data saved from previous tasks in the replay memory buffer M as the OOD data of the task to train an OOD detection head and also to fine-tune the WP head. Specifically, the model of each task has two heads: one for OOD (for computing TP) and one for WP. That is, we optimize the set of parameters (Ψ k , θ k , ϕ k ), where Ψ k is the parameter set of the feature extractor f k , θ k is the parameter set of OOD head h k , and ϕ k is the parameter set of the WP head (i.e., classifier) g k . The two task specific heads h k and g k receive feature u from the shared feature extractor f k and produce WP and TP probabilities, respectively. The training consists of three steps: 1) training the feature extractor f k and the OOD head h k using both IND instances in D k and OOD instances in M (i.e., the replay data), 2) fine-tuning a WP head g k for the task using D k based on only the fixed feature extractor f k , and 3) fine-tuning the OOD heads of all tasks that have been learned so far. Training steps 2 and 3 are fast as both are simply fine-tuning the single layer of the classifiers (details below). The outputs from the two heads are used to compute the final CIL prediction probability in Eq. 1. An overview of the training and prediction process is illustrated in Fig. 1.

1)

Training Feature Extractor and OOD Head. This step trains the OOD head h k for task k. Its feature extractor f k is also shared by the WP head (see below). An illustration of the training process is given in Fig. 1(a). Since OOD instances are any instances whose labels do not belong to task k, we leverage the task data D k as IND instances and the saved replay instances of tasks k ′ ̸ = k in the memory buffer M as OOD instances represented by an OOD class (in red) in the OOD head. The network h k •f k is trained to maximize the probability p(y|x, k) = softmaxh k (f (x, k; Ψ k ); θ k ) y for an IND instance x ∈ D k and maximize the probability p(ood|x, k) for OOD instance x ∈ M. Formally, this is achieved by minimizing the sum of cross-entropy losses

where N is the number of instances in D k . We utilize upsampling with the replay instances to achieve an equal number of samples as the current task data D k . The first loss is to discriminate the IND instances while the second loss is introduced to distinguish between IND and OOD instances.

To deal with forgetting, we use the HAT method (Serrà et al., 2018) (see Appendix B).

2) Fine-Tuning the WP Head. Given the feature extractor trained in the first step, we fix the feature extractor and fine-tune the WP head g k (i.e., the WP classifier) using only D k by adjusting the parameters ϕ k . This is achieved by minimizing the cross-entropy loss

WP probabilities for the classes of task k are just the output softmax probabilities.

3) Fine-Tuning the OOD Heads of All Tasks. The OOD head h k built in step 1) is biased because for early tasks, where the instances in M are less diverse, the OOD heads for them will be weaker than the OOD heads of later tasks when the instances in M are more diverse. To mitigate this bias, we fine-tune all OOD heads of all tasks after training each task using only the replay data in M. After training task k, we have M with replay instances of classes from task 1 to k. For each task k ′ ≤ k, reconstruct a new IND data Dk ′ by selecting instances corresponding to task k ′ from M, and a new pseudo memory buffer M after removing the instances in Dk ′ . We then fine-tune every OOD head by minimizing the loss function

where

Although the TP probability can be defined simply using the fine-tuned OOD heads, it can be further improved, which we discuss next.

Distance-Based Coefficient

We can further improve the performance by incorporating a distance-based coefficient defined at the feature level into the output from the OOD head. The intuition is based on the observation that samples identified as OOD using a score function defined at the feature level are not recognized with a score function defined in the output level, and vice versa (Wang et al., 2022a). Their combination usually produces a better OOD detector.

After training task k, compute the means of the feature vectors per class of the task and the variance of the features. Denote the mean of class y by µ y and the variance by Σ k = y Σ y , where Σ y is the variance of features of class y. Using Mahalanobis distance (MD), the coefficient of an instance x for task k is

The coefficient is large if the feature of a test instance x is close to one of the sample means of the task and small otherwise.

We finally define the TP probability for task k as

where Z is the normalizing factor and the maximum is taken over the softmax outputs of the IND classes j obtained by the OOD head h k . The max j operation can also be seen as the maximum softmax probability score (Hendrycks & Gimpel, 2016).

With the WP and TP probabilities, we now make a CIL prediction based on Eq. 1.

Empirical Evaluation

Baselines. We compare the proposed ROWfoot_1 with 12 baselines. Five are exemplar-free (i.e., saving no previous data) methods and seven are replay-based methods. The exemplarfree methods are: HAT (Serrà et al., 2018), OWM (Zeng

We could not make the recent system in (Wu et al., 2022) using a pre-trained model as no code is released. We also do not include the existing parameter isolation methods that deal with CIL problems as they are very weak. Hy-perNet (von Oswald et al., 2020) and PR (Henning et al., 2021) find the task-id via an entropy function and Sup-Sup (Wortsman et al., 2020) finds it via gradient update. They then make a within-task prediction. SupSup, PR, and iTAML (Rajasegaran et al., 2020b) assume the test instances come in batches and all samples in a batch belong to one task. When tested per sample, HyperNet, SupSup, PR and iTAML achieve 22.4, 11.8, 45.2 and 33.5 on 10 tasks of CIFAR100, respectively, which are much lower than 51.4 of iCaRL. CCG (Abati et al., 2020) has no code. The systems in (Kim et al., 2022b) are also not included because they are quite weak as their contrastive learning does not work well with a pre-trained model. The results reported in their paper based on ResNet-18 are also weaker than ROW.

Datasets. We use three popular continual learning benchmark datasets. 1). CIFAR10 (Krizhevsky & Hinton, 2009). This is an image classification dataset consisting of 60,000 color images of size 32x32, among which 50,000 are training data and 10,000 are testing data. It has 10 different classes. 2). CIFAR100 (Krizhevsky & Hinton, 2009). This dataset consists of 50,000 training images and 10,000 testing images with 100 classes. Each image is colored and of size 32x32. 3). Tiny-ImageNet (Le & Yang, 2015). This dataset has 200 classes with 500 training images of size 64x64 per class. The validation data has 50 samples per class. Since no label is provided for the test data, we use the validation set for testing as in (Zhu et al., 2021).

Backbone Architecture and Pre-Training. We use the backbone architecture of transformer DeiT-S/16 (Touvron et al., 2021). As pre-training models or feature extractors are increasingly used in all types of applications, including continual learning (Wang et al., 2022c;Kim et al., 2022a;Wu et al., 2022), we also take this approach. Following (Kim et al., 2022a), to ensure there is no information leak from pretraining to continual learning, the pre-trained model/network is trained using 611 classes of ImageNet after removing 389 classes which are similar or identical to the classes of CIFAR and Tiny-ImageNet. To leverage the strong performance of the pre-trained model while adapting to new knowledge, we fix the feature extractor and append trainable adapter modules of fully-connected networks with one hidden layer at each transformer layer (Houlsby et al., 2019) except SLDA and L2P. 3 The number of neurons in each hidden layer is 64 for CIFAR10 and 128 for other datasets. Note that all baselines and ROW use the same architecture and the same pre-training model for fairness as using a pre-trained model improves the performance (Kim et al., 2022a;Ostapenko et al., 2022).

Note that we do not use the pre-trained models like CLIP (Radford et al., 2021) or others trained using the full ImageNet data due to information leak both in terms of features and class labels because our experiment data have been used in training these pre-trained models. This leakage can seriously affect the results. For example, the L2P system using the pre-training model trained using the full ImageNet data performs extremely well, but after those overlapping classes are removed in pre-training, its performances drop greatly. In Tab. 2, we can see that it is in fact quite weak.

Training Details. For the replay-based methods, we follow the budget sizes of (Rebuffi et al., 2017;Buzzega et al., 2020). For our method, we use the memory budget strategy (Chaudhry et al., 2019b) to save equal number of samples per class. Denote the budget size by |M|.

For CIFAR10, we split the 10 classes into 5 tasks with 2 classes per task. We refer the experiment as C10-5T. The memory budget size |M| is 200.

For CIFAR100, we conduct two experiments. We split the 100 classes into 10 and 20 tasks, where each task has 10 classes and 5 classes, respectively. We refer the experiments as C100-10T and C100-20T. We choose |M| = 2,000.

For Tiny-ImageNet, we conduct two experiments. We split the 200 classes into 5 tasks with 40 classes per task and 10 tasks with 20 classes per task. We refer the experiments as T-5T and T-10T, respectively. We save 2,000 samples in total for both experiments.

Following the random class order protocol of the existing methods (Rebuffi et al., 2017;Lee et al., 2019), we randomly generate 5 different class orders for each experiment and report the average accuracy over the 5 random orders.

For all the experiments of our system, we find a good set of learning rates and the number of epochs via validation data made of 10% of the training data. The hyper-parameters of our system is reported in Appendix C. For the baselines, we use the experiment setups as reported in their official papers. If we could not reproduce the result, we find the hyper-parameters via the validation set. Liu et al., 2020b). This is also referred as backward transfer in other literature (Lopez-Paz & Ranzato, 2017).

Results and Comparison

Average Classification Accuracy. Tab. 2 shows the average classification accuracy after the final task. The last column Average indicates the average performance of each method over the 5 experiments. Our proposed method ROW performs the best consistently. On average, ROW achieves 73.72% while the best replay baseline (MORE) achieves 71.59%. We observe that MORE is significantly better than the other baselines. This is because MORE actually builds an OOD model for each task, which is close to the proposed theory but less principled than ROW.

The baselines SLDA and L2P are proposed to leverage a strong pre-trained feature extractor in the original papers. SLDA freezes the feature extractor and only fine-tunes the classifier. It performs well for the simple experiment C10-5T, but is significantly poorer than ROW on all experiments. This is because the fixed feature extractor does not adapt to new knowledge. Our method updates the feature extractor via adapter modules to new knowledge and it is able to learn more complex problems. L2P trains a set of prompt embeddings. In the original paper, it uses a feature extractor that was pre-trained with ImageNet-21k which already includes the classes of the continual learning (CL) evaluation datasets (information leak). After we remove the classes similar to the datasets used in CL, its performance drops dramatically (60.47% on average over the 5 experiments) and much poorer than our ROW (73.72% on average).

We conduct additional experiments with the size of mem- ory buffer reduced by half to show the effectiveness of our method. The new memory buffer sizes for CIFAR10, CI-FAR100, and Tiny-ImageNet are 100, 1,000, and 1,000, respectively. Tab. 3 shows that our method ROW experiences little reduction in performance whereas the other replaybased baselines suffer from significant performance reduction. On average over the 5 experiments, ROW achieves 72.70% while previously with the original memory buffer, it achieved 73.72. In contrast, the second best baseline DER++ reduces from 66.89 to 62.16. MORE is also robust with small memory sizes, but its average accuracy is 71.44 which is still lower than ROW.

Average Forgetting Rate. We compare the forgetting rate of each system after learning the last task in Fig. 2. The forgetting rates of the proposed method ROW are 7.05, 7.99, and 9.72 on C10-5T, C100-10T and C100-20T, respectively. iCaRL forgets less than ours on C10-5T and C100-20T as it achieves 4.95 and 8.31, respectively. However, iCaRL was not able to adapt to new knowledge effectively as its accuracies are much lower than ROW on the same experiments. The forgetting rate of SLDA on C10-5T 5.74, but a similar observation can be made as iCaRL. The average accuracy over the 5 experiments of ROW is 73.72 while that of iCaRL and SLDA are only 66.12 and 68.02, respectively. According to the forgetting rates, the best baseline (MORE) adapts to the new knowledge well, but it was not able to retain the knowledge as effectively as ROW. Its forgetting rates are 10.30, 22.96, and 22.90 on C10-5T, C100-10T, and C100-20T, respectively, and are much larger than ours. This results in lower performance of MORE than ROW.

It is important to note that our system actually has no forgetting due to the CF prevention by HAT. The 'forgetting' occurs not because it forgets the task knowledge, but because the classification becomes harder with more classes.

Ablation Experiments

We conduct an ablation study to measure the performance after each component is removed from ROW. We consider removing two components: WP head and the distance-based Tab. 4 shows the average classification accuracy. The model after removing WP also works greatly as it already outperforms most of the baselines on C10-5T and outperforms the baselines on C100-10T and 20T. In other words, using OOD head constructed following the theoretical framework is effective. The model is still functional after removing both components (WP and the distance-based coefficient by MD) as shown in the last row of the table (ROW (-WP-MD)).

Conclusion

To the best of our knowledge, there is still no reported study of learnability of class incremental learning (CIL). This paper performed such a study and showed that the CIL is learnable with some practically reasonable assumptions. A new CIL algorithm (called ROW) was also proposed based on the theory. Experimental results demonstrated that ROW outperforms strong baselines.

Proof of Theorem 3.7. Denote the algorithm that satisfies Definition 3.6 as A r k . Given any ϵ n and S ∼ D [1:k] , denote h k = A r k (S). Based on h k , we construct a hk that satisfies Definition 3.4.

For simplicity, we denote π [k:k ′ ] = k ′ i=k π i . For any O (X1,Y1) , . . . , O (X T ,Y T ) ∈ D and any α 1 , . . . , α T ∈ [0, 1), let

and plugging α ′ k and O ′ (X k ,Y k ) into Definition 3.6, we have

Denote h k = arg max{. . . , z j k , . . . ; z o k }, where z j k is the score function of the j-th class of the k-th task, and z o k is the score function of the OOD class of the k-th task. Denote the label of the j-th class of the i-th task as y i,j . Denote the label of OOD class of the i-th task as y i,o . We define

By definition of hk , when hk makes a wrong prediction, there exists a h i ′ , i ′ ≤ k that makes a mistake. We assume that the loss function satisfies the following inequality

l(h t (x), y t,o ) + l(h i (x), y i,j ),

Then we can decompose the risk function of hk ,

With the fact that for any density function p(x) defined on A and any B ⊂ A,

Plugging the above three equations into Eq. 9, we have

By assumption that inf

Therefore, we have max k=1,...,T

Proof of Corollary 3.8. Denote the algorithm that satisfies Definition 3.6 as A r k . Given any ϵ n and S ∼ D [1:k] , denote h k = A r k (S). Based on h k , we construct a hk that satisfies Definition 3.4.

For simplicity, we denote π

i=k π i . Different from proof of Theorem 3.7, when we can acquire replay data and therefore treat them as OOD data, we let

Denote h k = arg max{. . . , z j k , . . . ; z o k }, where z j k is the score function of the j-th class of the k-th task, and z o k is the score function of the OOD class of the k-th task. Denote the label of the j-th class of the i-th task as y i,j . Denote the label of OOD class the the i-th task as y i,o . We define

But when hk makes a wrong prediction, there exists a h i ′ , i ′ ≤ i that makes a mistake. We assume that the loss function satisfies the following inequality

All the same as the proof of Theorem 3.7, we have

B. Hard Attention to the Task (HAT)

In training the network h k • f k using the data of task k and the generated pseudo feature vectors, we employ the hard attention mask (Serrà et al., 2018) to prevent forgetting in the feature extractor.

The hard attention mask a k l is a trainable pseudo binary 0-1 vector at each layer l of task k. It is element-wise multiplied to the output of the layer as a k l ⊗ h l and blocks (for value of 0) or unblocks (for value of 1) the information flow from neurons of adjacent layers. Neurons with value 1 are important for the task and thus need to be protected while neurons with value 0 are not necessary for the task and can be freely modifed without affecting other tasks.

More specifically, we modify the gradients of parameters that are important in performing the previous tasks (1, • • • , k -1) during training task k so the important parameters for previous tasks are unaffected. The gradient of parameter w ij,l at ith row and jth column of layer l is modified as ∇w ′ ij,l = 1 -min a <k i,l , a <k j,l-1

where a <k i,l is an accumulated attentions over previous tasks and is 1 if the hard attention of neuron i at layer l is ever used by any previous task < k (see (Serrà et al., 2018) for details).

To encourage parameter sharing and sparsity in the number of activated masks, a regularization is introduced as L r = l,i a k i,l (1 -a <k i,l ) l,i (1 -a <k i,l ). The final objective to train a comprehensive task network without forgetting is

where L ood is the cross-entropy loss in Eq. 3.

C. Hyper-Parameters

For all the experiments, we use SGD with momentum value of 0.9 with batch size of 64. For C10-5T, we use learning rate 0.005 and train for 20 epochs. For C100-10T and 20T, we train for 40 epochs with learning rate 0.001 and 0.005 for 10T and 20T, respectively. For T-5T and 10T, we use the same learning rate 0.005, but train for 15 and 10 epochs for 5T and 10T, respectively. For fine-tuning WP and OOD head, we use batch size of 32 and use the same learning rate used for training the feature extractor. For fine-tuning WP and TP, we train for 5 epochs and 10 epochs, respectively.

datasets. SLDA fine-tunes only the classifier on top of the fixed pre-trained feature extractor as it does not have a protection mechanism. L2P uses a prompt pool with 23k entries. Since each method requires method-specific elements (e.g., task embedding for HAT), the number of entries required for each method is different. The number of entries for each model is reported in Tab. 5.

Our system saves the covariance matrices for computing the distance-based coefficient in Sec. 4.1. The covariances are saved for each task. Since each covariance is in size 384x384, the total entries for this step are 737.3k, 1.5M, 2.9M, 737.3k, and 1.5M for C10-5T, C100-10T, C100-20T, T-5T, and T-10T, respectively. The numbers are relatively small considering that some of the replay-based methods (e.g., iCaRL, HAL) require a teacher model the same size as the training model for knowledge distillation. More importantly, replay buffer requires the largest memory (e.g., for Tiny-ImageNet, saving 2,000 images of size 64x64x3 requires 24.6M entries). It is highly important that the system is robust to replay buffer size. ROW is shown to remain strong with small replay buffer sizes (see Tab. 3).

Our system ROW saves an additional classifier. WP head is of the same shape as the classifier of the standard baselines (e.g., iCaRL or DER++). OOD (or TP) head requires the same memory as WP with additional parameters for OOD class per task. The required memory is small. For instance, for C10-5T, using OOD head only introduces 5,775 additional entries.

E. Societal Impact and Limitation

We do not see any negative societal impact as we use public domain datasets for the experiments and our algorithm is just like any normal supervised learning in nature. In practical use, if the training data of the application is biased, it could affect the model just like in any other supervised learning. We believe that this can be alleviated by checking any potential bias in the training data.

The current theoretical study is only applicable to offline CIL. In future work, we will extend our study to online CIL, where the task boundary may be blurry.

F. Effect on Underrepresented Minorities

The existence of underrepresented samples in the current task does not affect our theory, but it will affect an actual implementation and give weaker results. The OOD detection method in our paper simply trains the system by considering the samples of the current task as in-distribution and the samples in the replay buffer as OOD of the current task. In case there is a set of underrepresented classes in the current task's dataset, one can use existing techniques proposed for the sample imbalance problem to alleviate the issue. However, this problem is not just relevant to our proposed method, but relevant to all existing OOD and CL methods, or even supervised learning methods.