Year: 2019

Abstract:
We present a large-scale empirical study of catastrophic forgetting (CF) in modern Deep Neural Network (DNN) models that perform sequential (or: incremental) learning. A new experimental protocol is proposed that enforces typical constraints encountered in application scenarios. As the investigation is empirical, we evaluate CF behavior on the hitherto largest number of visual classification datasets, from each of which we construct a representative number of Sequential Learning Tasks (SLTs) in close alignment to previous works on CF. Our results clearly indicate that there is no model that avoids CF for all investigated datasets and SLTs under application conditions. We conclude with a discussion of potential solutions and workarounds to CF, notably for the EWC and IMM models.

heading: 1 INTRODUCTION
text: This article is in the context of sequential or incremental learning in Deep Neural Networks (DNNs). Essentially, this means that a DNN is not trained once, on a single taskD, but successively on two or more sub-tasksD1, . . . , Dn, one after another. Learning tasks of this type, which we term Sequential Learning Tasks (SLTs) (see Fig. 1a), are potentially very common in real-world applications. They occur wherever DNNs need to update their capabilities on-site and over time: gesture recognition, network traffic analysis, or face and object recognition in mobile robots. In such scenarios, neural networks have long been known to suffer from a problem termed “catastrophic forgetting”(CF) (e.g., French (1999)) which denotes the abrupt and near-complete loss of knowledge from previous subtasks D1, . . . , Dk−1 after only a few training iterations on the current sub-task Dk (see Fig. 1b compared to Fig. 1c). We focus on SLTs from the visual domain with two sub-tasks each, as DNNs show pronounced CF behavior even when only two sub-tasks are involved.
trainD1 testD1
sub-taskD1 sub-taskD2 trainD2
testD2 test D1∪D2
0 E 2E
testD1
(a) Training scheme
0 2 epoch
0.0
0.5
1.0
te st
a cc
ur ac
y
D1 D2 D1 D2
training D1 retraining D2
(b) with CF
0 2 epoch
0.0
0.5
1.0
te st
a cc
ur ac
y
D1 D2 D1 D2
training D1 retraining D2
(c) without CF
Figure 1: Scheme of incremental training experiments conducted in this article (a) and representative outcomes with (b) and without CF (c). The sequential learning tasks used in this study only have two sub-tasks: D1 and D2. During training (white background) and re-training (gray background), test accuracy is measured on D1 (blue, M), D2 (green, 2) and D1 ∪ D2 (red, #). The blue curve allows to determine the presence of CF by simple visual inspection: if there is significant degradation w.r.t. the red curve, then CF has occurred.

heading: 1.1 DISCUSSION OF RELATED WORK ON CF
text: The field of incremental learning is large, e.g., Parisi et al. (2018) and Gepperth & Hammer (2016). Recent systematic comparisons between different DNN approaches to avoid CF are performed in, e.g., Serra et al. (2018) or Kemker et al. (2018). Principal recent approaches to avoid CF include ensemble methods (Ren et al., 2017; Fernando et al., 2017), dual-memory systems (Shin et al., 2017; Kemker & Kanan, 2017; Rebuffi et al., 2017; Gepperth & Karaoguz, 2016) and regularization approaches. Whereas Goodfellow et al. (2013) suggest Dropout for alleviating CF, the EWC method (Kirkpatrick et al., 2017) proposes to add a term to the energy function that protects weights that are important for the previous sub-task(s). Importance is determined by approximating the Fisher information matrix of the DNN. A related approach is pursued by the Incremental Moment Matching technique (IMM) (see Lee et al. (2017)), where weights from DNNs trained on a current and a past sub-tasks are “merged” using the Fisher information matrix. Other regularization-oriented approaches are proposed in Aljundi et al. (2018); Srivastava et al. (2013) and Kim et al. (2018) which focus on enforcing sparsity of neural activities by lateral interactions within a layer.
Number of tested datasets In general, most methods referenced here are evaluated only on a few datasets, usually on MNIST (LeCun et al., 1998) and various derivations thereof (permutation, rotation, class separation). Some studies make limited use of CIFAR10, SVHN, the Amazon sentiment analysis problem, and non-visual problems such as data from Q-learning of Atari games. A largescale evaluation on a huge number of qualitatively different datasets is still missing1. Model selection and prescience Model selection (i.e., selecting DNN topology and hyperparameters) is addressed in some approaches (Goodfellow et al., 2013) but on the basis of a “prescient” evaluation where the best model is selected after all tasks have been processed, an approach which is replicated in Kirkpatrick et al. (2017). This amounts to a knowledge of future sub-tasks which is problematic in applications. Most approaches ignore model selection (Lee et al., 2017; Srivastava et al., 2013; Aljundi et al., 2018; Kim et al., 2018), and thus implicitly violate causality. Storage of data from previous sub-tasks From a technical point of view, DNNs can be retrained without storing training data from previous sub-tasks, which is done in Goodfellow et al. (2013) and Srivastava et al. (2013). For regularization approaches, however, there are regularization parameters that control the retention of previous knowledge, and thus must be chosen with care. In Kirkpatrick et al. (2017), this is λ, whereas two such quantities occur in Lee et al. (2017): the “balancing” parameter α and the regularization parameter λ for L2-transfer. The only study where regularization parameters are obtained through cross-validation (which is avoided in other studies) is Aljundi et al. (2018) (for λSNI and λΩ) but this requires to store all previous training data.
This review shows that enormous progress has been made, but that there are shortcomings tied to applied scenarios which need to be addressed. We will formalize this in Sec. 1.2 and propose an evaluation strategy that takes these formal constraints into account when testing CF in DNNs.

heading: 1.2 INCREMENTAL LEARNING IN APPLIED SCENARIOS
text: When training a DNN model on SLTs, first of all the model must be able to be retrained at any time by new classes (class-incremental learning). Secondly, it must exhibit retention, or at least graceful decay, of performance on previously trained classes. Some forgetting is probably unavoidable, but it should be gradual and not immediate, i.e., catastrophic. However, if a DNN is operating in, e.g., embedded devices or autonomous robots, additional conditions may be applicable: Low memory footprint Data from past sub-tasks cannot be stored and used for re-training, or else to determine when to stop re-training. Causality Data from future sub-tasks, which are often known in academic studies but not in applications, must not be utilized in any way, especially not for DNN model selection. This point might seem trivial, but a number of studies such as Kirkpatrick et al. (2017); Goodfellow et al. (2013) and Srivastava et al. (2013) perform model selection in hindsight, after having processed all sub-tasks. Constant update complexity Re-training complexity (time and memory) must not depend on the number of previous sub-tasks, thus more or less excluding replay-based schemes such as Shin et al. (2017). Clearly, even if update complexity is constant w.r.t. the number of previous sub-tasks, it should not be too high in absolute terms either.
1Although the comparisons performed in Aljundi et al. (2018) include many datasets, the experimental protocol is unclear, so it is uncertain how to interpret these results.

heading: 1.3 CONTRIBUTION AND PRINCIPAL CONCLUSIONS
text: The original contributions of our work can be summarized as follows:
• We propose a training and evaluation paradigm for incremental learning in DNNs that enforces typical application constraints, see Sec. 1.2. The importance of such an applicationoriented paradigm is underlined by the fact that taking application constraints into account leads to radically different conclusions about CF than those obtained by other recent studies on CF (see Sec. 1.1).
• We investigate the incremental learning capacity of various DNN approaches (Dropout, LWTA, EWC and IMM) using the largest number of qualitatively different classification datasets so far described. We find that all investigated models are afflicted by catastrophic forgetting, or else in violation of application constraints and discuss potential workarounds.
• We establish that the “permuted” type of SLTs (e.g., “permuted MNIST”) should be used with caution when testing for CF.
• We do not propose a method for avoiding CF in this article. This is because avoiding CF requires a consensus on how to actually measure this effect: our novel contribution is a proposal how to do just that.

heading: 2 METHODS AND DNN MODELS
text: We collect a large number of visual classification datasets, from each of which we construct SLTs according to a common scheme, and compare several recent DNN models using these SLTs. The experimental protocol is such that application constraints, see Sec. 1.2, are enforced. For all tested DNN models (see below), we use a TensorFlow (v1.7) implementation under Python (v3.4 and later). The source code for all processed models, the experiment-generator and evaluation routine can be found on our public available repository 2.
FC A normal, fully-connected (FC) feed-forward DNN with a variable number and size of hidden layers, each followed by ReLU, and a softmax readout layer minimizing cross-entropy. CONV A convolutional neural network (CNN) based on the work of Cirean et al. (2011). It is optimized to perform well on image classification problems like MNIST. We use a fixed topology: two conv-layers with 32 and 64 filters of size 5×5 plus ReLU and 2×2 max-pooling, followed by a fc-layer with 1024 neurons and softmax readout layer minimizing a cross-entropy energy function. EWC The Elastic Weight Consolidation (EWC) model presented by Kirkpatrick et al. (2017). LWTA A fully-connected DNN with a variable number and size of hidden layers, each followed by a Local Winner Takes All (LWTA) transfer function as proposed in Srivastava et al. (2013). IMM The Incremental Moment Matching model as presented by Lee et al. (2017). We examine the weight-transfer techniques in our experiments, using the provided implementation. D-FC and D-CONV Motivated by Goodfellow et al. (2013) we combine the FC and CONV models with Dropout as an approach to solve the CF problem. Only FC and CONV are eligible for this, as EWC and IMM include dropout by default, and LWTA is incompatible with Dropout.

heading: 2.1 HYPER-PARAMETERS AND MODEL SELECTION
text: We perform model selection in all our experiments by a combinatorial hyper-parameter optimization, whose limits are imposed by the computational resources available for this study. In particular, we vary the number of hidden layers L ∈ {2, 3} and their size S ∈ {200, 400, 800} (CNNs excluded), the learning rate 1 ∈ {0.01, 0.001} for sub-task D1, and the re-training learning rate 2 ∈ {0.001, 0.0001, 0.00001} for sub-task D2. The batch size (batchsize) is fixed to 100 for all experiments, and is used for both training and testing. As in other studies, we do not use a fixed number of training iterations, but specify the number of training epochs (i.e., passes through the whole dataset) as E = 10 for each processed dataset (see Sec. 2.2), which allows an approximate comparison of different datasets. The number of training/testing batches per epoch, B, can be calculated from the batch size and the currently used dataset size. The set of all hyper-parameters for
2https://gitlab.informatik.hs-fulda.de/ML-Projects/CF_in_DNNs
a certain model, denoted P , is formed as a Cartesian product from the allowed values of the hyperparameters L, S, 1, 2 and complemented by hyper-parameters that remain fixed (E , batchsize) or are particular to a certain model. For all models that use dropout, the dropout rate for the input layer is fixed to 0.2, and to 0.5 for all hidden layers. For CNNs, the dropout rate is set to 0.5 for both input and hidden layers. All other hyper-parameters for CNNs are fixed, e.g., number and size of layers, the max-pooling and filter sizes and the strides (2 × 2) for each channel. These decisions were made based on the work of Goodfellow et al. (2013). The LWTA block size is fixed to 2, based on the work of Srivastava et al. (2013). The model parameter λ for EWC is set to λ1/ 2 (set but not described in the source code of Kirkpatrick et al. (2017)). For all models except IMM, the momentum parameter for the optimizer is set to µ = 0.99 (Sutskever et al., 2013). For the IMM models, the SGD optimizer is used, and the regularizer value for the L2-regularization is set to 0.01 for L2-transfer and to 0.0 for weight transfer.

heading: 2.2 DATASETS
text: We select the following datasets (see Tab. 1). In order to construct SLTs uniformly across datasets, we choose the 10 best-represented classes (or random classes if balanced) if more are present.
MNIST (LeCun et al., 1998) is the common benchmark for computer vision systems and classification problems. It consist of gray scale images of handwritten digits (0-9). EMNIST (Cohen et al., 2017) is an extended version of MNIST with additional classes of handwritten letters. There are different variations of this dataset: we extract the ten best-represented classes from the By Class variation containing 62 classes. Fruits 360 (Murean & Oltean, 2017) is a dataset comprising fruit color images from different rotation angles spread over 75 classes, from which we extract the ten best-represented ones. Devanagari (Acharya et al., 2015) contains gray scale images of Devanagari handwritten letters. From the 46 character classes (1.700 images per class) we extract 10 random classes. FashionMNIST (Xiao et al., 2017) consists of images of clothes in 10 classes and is structured like the MNIST dataset. We use this dataset for our investigations because it is a “more challenging classification task than the simple MNIST digits data (Xiao et al., 2017)”. SVHN (Netzer et al., 2011) is a 10-class dataset based on photos of house numbers (0-9). We use the cropped digit format, where the number is centered in the color image. CIFAR10 (Krizhevsky, 2009) contains color images of real-world objects e.g, dogs, airplanes etc. NotMNIST (Bulatov Yaroslav) contains grayscale images of the 10 letter classes from “A” to “J”, taken from different publicly available fonts. MADBase (Abdelazeem Sherif & El-Sherif Ezzat) is a modified version of the “Arabic Digits dataBase”, containing grayscale images of handwritten digits written by 700 different persons.

heading: 2.3 SEQUENTIAL LEARNING TASKS (SLTS)
text: As described in Sec. 1, each SLT consists of two sub-tasks D1 and D2. For each dataset (see Sec. 2.2), these are defined by either applying different spatial permutations to all image data (DP10-
10 type SLTs), or by subdividing classes into disjunct groups (see Tab. 2). For the latter case, we include SLTs where the second sub-task adds only 1 class (D9-1 type SLTs) or 5 classes (D5-5 type SLTs), since CF may be tied to how much newness is introduced. We include permutations (DP1010) since we suspected that this type of SLT is somehow much easier than others, and therefore not a good incremental learning benchmark. As there are far more ways to create D5-5 type SLTs than D9-1 type SLTs, we create more of the former (8-vs-3) in order to avoid misleading results due to a particular choice of subdivision, whereas we create only a single permutation-type SLT.

heading: 3 EXPERIMENTS
text: This study presents just one, albeit very large, experiment, whose experimental protocol implements the constraints from Sec. 1.2.
Every DNN model from Sec. 2 is applied to each SLT as defined in Sec. 2.3 while taking into account model selection, see Sec. 2.1. A precise definition of our application-oriented experimental protocol is given in Alg. 1. For a given model m and an SLT (D1 and D2), the first step is to determine the best hyper-parameter vector ~p∗ for sub-task D1 only (see lines 1-4), which determines the model m~p∗ used for re-training. In a second step, m~p∗ (from line 5) is used for re-training on D2, with a different learning rate 2 which is varied separately. We introduce two criteria for determining the ( 2-dependent) quality of a re-training phase (lines 6-10): “best”, defined by the highest test accuracy on D1 ∪D2, and “last”, defined by the test accuracy on D1 ∪D2 at the end of re-training. Although the “best” criterion violates the application constraints of Sec. 1.2 (requires D1), we include it for comparison purposes. Finally, the result is computed as the highest 2-dependent quality (line 11). Independently of the second step, another training of m~p∗ is conducted using D1 ∪D2, resulting in what we term baseline accuracy.
Evaluation for IMM differs slightly: in line 5, a copy of m~p∗ is kept, termed m1~p∗ , and the weights of m~p∗ are re-initialized. After selecting the best re-trained model m2~p∗ as a function of 2, final performance q~p∗ is obtained by ”merging” the models m1~p∗ and m 2 ~p∗ and testing the result.
Algorithm 1: The application-oriented evaluation strategy used in this study. Data: model m, SLT with sub-tasks D1, D2, hyper-parameter value set P Result: incremental learning quality for model with hyper-parameters ~p∗: q~p∗
1 forall ~p ∈ P do // determine accuracy for all hyper-parameters when training on D1 2 for t← 0 to E · B do 3 train(m~p, Dtrain1 , 1) 4 q~p,t ←test(m~p, Dtest1 ,t)
5 m~p∗ ← model m~p,t with maximum q~p,t // find best model with max. accuracy on D1 6 forall 2 do // find best 2 value 7 m~p∗, 2 ← m~p∗ 8 for t← 0 to E · B do 9 train(m~p∗, 2 , D train 2 , 2)
10 q~p∗,t, 2 ←test(m~p∗, 2 , Dtest2 ,t)
11 q~p∗ ← max 2 best/lastt q~p,t, 2 // find parameter set with the best accuracy on D2

heading: 4 FINDINGS
text: The results of the experiment described in Sec. 3 are summarized in Tab. 3, and in Tab. 4 for IMM. They lead us to the following principal conclusions:
Permutation-based SLTs should be used with caution We find that DP10-10, the SLT based on permutation, does not show CF for any model and dataset, which is exemplary visualized for the FC model in Fig. 2 which fails completely for all other SLTs. While we show this only for SLTs with two sub-tasks, and it is unknown how experiments with more sub-tasks would turn out, we nevertheless suggest caution when intepreting results on permutation-based SLTs.
All examined models exhibit CF While this is not surprising for FC and CONV, D-FC as proposed in Goodfellow et al. (2013) performs poorly (see Fig. 3), as does LWTA (Srivastava et al., 2013). For EWC and IMM, the story is slightly more complex and will be discussed below.
EWC is mildly effective against CF for simple SLTs. Our experiments shows that EWC is effective against CF for D9-1 type SLTs, at least when the “best” evaluation criterion is used, which makes use of D1. This, in turn, violates the application requirements of Sec. 1.2. For the “last” criterion not making use of D1, EWC performance, though still significant, is much less impressive. We can see the origins of this difference illustrated in Fig. 4.
EWC is ineffective against CF for more complex problems. Tab. 3 shows that EWC cannot prevent CF for D5-5 type SLTs, see Fig. 5. Apparently, the EWC mechanism cannot protect all the weights relevant for D1 here, which is likely to be connected to the fact that the number of samples in both sub-tasks is similar. This is not the case for D9-1 type tasks where EWC does better and where D2 has about 10% of the samples in D1.
IMM is effective for all SLTs but unfeasible in practice. As we can see from Tab. 4, wtIMM clearly outperforms all other models compared in Tab. 3. Especially for the D5-5 type SLTs, a modest incremental learning quality is attained, which is however quite far away from the baseline accuracy, even for MNIST-derived SLTs. This is in contrast to the results reported in Lee et al. (2017) for MNIST: we attribute this discrepancy to the application-oriented model selection procedure using only D1 that we perform. In contrast, in Lee et al. (2017), a model with 800/800/800 neurons, for which good results on MNIST are well-established, is chosen beforehand, thus arguably making implicit use ofD2. A significant problem of IMM is the determination of the balancing parameter α, exemplarily illustrated in Fig. 6. Our results show that the optimal value cannot simply be guessed from the relative sizes of D1 and D2, as it is done in Lee et al. (2017), but must be determined by cross-validation, thereby requiring knowledge of D1 (violates constraints). Apart from these conceptual issues, we find that the repeated calculation of the Fisher matrices is quite time and memory-consuming (>4h and >8GB), to the point that the treatment of SLTs from certain datasets becomes impossible even on high-end machine/GPU combinations when using complex models. This is why we can evaluate IMM only for a few datasets. It is possible that this is an artifact of the TensorFlow implementation, but in the present state IMM nevertheless violates not one but two application constraints from Sec. 1.2. Fig. 7 and Fig. 8 give a visual impression of training an IMM model on D9-1 and D5-5 type SLTs, again illustrating basic feasibility, but also the variability of the “tuning curves” we use to determine the optimal balancing parameter α.

heading: 5 CONCLUSIONS
text: The primary conclusion from the results in Sec. 4 is that CF still represents a major problem when training DNNs. This is particularly true if DNN training happens under application constraints as outlined in Sec. 1.2. Some of these constraints may be relaxed depending on the concrete application: if some prior knowledge about future sub-task exists, it can be used to simplify model selection
and improve results. If sufficient resources are available, a subset of previously seen data may be kept in memory and thus allow a “best” type evaluation/stopping criterion for re-training, see Alg. 1.
Our evaluation approach is similar to Kemker et al. (2018), and we adopt some measures for CF proposed there. A difference is the setting of up to 10 sub-tasks, whereas we consider only two of them since we focus less on the degree but mainly on presence or absence of CF. Although comparable both in the number of tested models and benchmarks, Serra et al. (2018) uses a different evaluation methodology imposing softer constraints than ours, which is strongly focused on application scenarios. This is, to our mind, the reason why those results differ significantly from ours and underscores the need for a consensus of how to measure CF.
In general application scenarios without prior knowledge or extra resources, however, an essential conclusion we draw from Sec. 4 is that model selection must form an integral part of training a DNN on SLTs. Thus, a wrong choice of hyper-parameters based on D1 can be disastrous for the remaining sub-tasks, which is why application scenarios require DNN variants that do not have extreme dependencies on hyper-parameters such as layer number and layer sizes.
Lastly, our findings indicate workarounds that would make EWC or IMM practicable in at least some application scenarios. If model selection is addressed, a small subset of D1 may be kept in memory for both methods: to determine optimal values of α for IMM and to determine when to stop re-training for EWC. Fig. 6 shows that small changes to α do not dramatically impact final accuracy for IMM, and Fig. 4 indicates that accuracy loss as a function of re-training time is gradual in most cases for EWC. The inaccuracies introduced by using only a subset of D1 would therefore not be very large for both algorithms.
To conclude, this study shows that the consideration of applied scenarios significantly changes the procedures to determine CF behavior, as well as the conclusions as to its presence in latestgeneration DNN models. We propose and implement such a procedure, and as a consequence claim that CF is still very much of a problem for DNNs. More research, either on generic solutions, or on workarounds for specific situations, needs to be conducted before the CF problem can be said to be solved. A minor but important conclusion is that results obtained on permutation-type SLTs should be treated with caution in future studies on CF.

heading: ACKNOWLEDGMENTS
text: We gratefully acknowledge the support of NVIDIA Corporation with the donation of the Titan Xp GPU used for this research.

heading: A ADDITIONAL EVALUATION METRICS

heading: B SELECTED EXPERIMENTAL RESULTS AS 2D PLOTS
text: Here, we present the best results of all algorithms on the MNIST, EMNIST and Devanagari datasets (according to the “best” criterion) for the D9-1b SLT, and the best EWC results on the D5-5d SLT (qualitatively identical to the other D5-5 type SLTs). Such 2D representations of some experimental results, to be just as Fig. 4, may give more clear insights into the details of each experiment.
Here we can observe CF behavior for all algorithms except EWC and IMM for D9-1b. We can infer that there was no discernible dependency between the occurrence of CF and particular hyperparameter settings (number and size of layers, in particular) since these are already the best experiments for each algorithm and dataset: if these show CF, this means that non of the settings we sampled were able to prevent CF. EWC shows clear CF for the Devanagari dataset, but might conceivably do better on EMNIST given a little more time for learning D2 (this will be investigated). For D5-5d, clear CF occurs even for EWC. IMM does not exhibit CF for D9-1b (at enormous computations cost, though), and we observe that the value for the balancing parameter cannot simply be set to 0.9 respectively 0.1, as it has its argmax elsewhere.
FC D9-1b EMNIST FC D9-1b MNIST FC D9-1b Devanagari
0 2 4 6 8 10 12 14 16 18 20 epoch
0.0
0.2
0.4
0.6
0.8
1.0
te st
a cc
ur ac
y
baseline max test:D1 test:D2 test:D1 D2
0 2 4 6 8 10 12 14 16 18 20 epoch
0.0
0.2
0.4
0.6
0.8
1.0
te st
a cc
ur ac
y
baseline max test:D1 test:D2 test:D1 D2
0 2 4 6 8 10 12 14 16 18 20 epoch
0.0
0.2
0.4
0.6
0.8
1.0
te st
a cc
ur ac
y
baseline max test:D1 test:D2 test:D1 D2
D-FC D9-1b EMNIST D-FC D9-1b MNIST D-FC D9-1b Devanagari
0 2 4 6 8 10 12 14 16 18 20 epoch
0.0
0.2
0.4
0.6
0.8
1.0
te st
a cc
ur ac
y
baseline max test:D1 test:D2 test:D1 D2
0 2 4 6 8 10 12 14 16 18 20 epoch
0.0
0.2
0.4
0.6
0.8
1.0
te st
a cc
ur ac
y
baseline max test:D1 test:D2 test:D1 D2
0 2 4 6 8 10 12 14 16 18 20 epoch
0.0
0.2
0.4
0.6
0.8 1.0 te st a cc ur ac y
baseline max test:D1 test:D2 test:D1 D2
CONV D9-1b EMNIST CONV D9-1b MNIST CONV D9-1b Devanagari
0 2 4 6 8 10 12 14 16 18 20 epoch
0.0
0.2
0.4
0.6
0.8
1.0
te st
a cc
ur ac
y
baseline max test:D1 test:D2 test:D1 D2
0 2 4 6 8 10 12 14 16 18 20 epoch
0.0
0.2
0.4
0.6
0.8
1.0
te st
a cc
ur ac
y
baseline max test:D1 test:D2 test:D1 D2
0 2 4 6 8 10 12 14 16 18 20 epoch
0.0
0.2
0.4
0.6
0.8
1.0
te st
a cc
ur ac
y
baseline max test:D1 test:D2 test:D1 D2
D-CONV D9-1b EMNIST D-CONV D9-1b MNIST D-CONV D9-1b Devanagari
0 2 4 6 8 10 12 14 16 18 20 epoch
0.0
0.2
0.4
0.6
0.8
1.0
te st
a cc
ur ac
y
baseline max test:D1 test:D2 test:D1 D2
0 2 4 6 8 10 12 14 16 18 20 epoch
0.0
0.2
0.4
0.6
0.8
1.0
te st
a cc
ur ac
y
baseline max test:D1 test:D2 test:D1 D2
0 2 4 6 8 10 12 14 16 18 20 epoch
0.0
0.2
0.4
0.6
0.8
1.0
te st
a cc
ur ac
y
baseline max test:D1 test:D2 test:D1 D2
LWTA D9-1b EMNIST LWTA D9-1b MNIST LWTA D9-1b Devanagari
0 2 4 6 8 10 12 14 16 18 20 epoch
0.0
0.2
0.4
0.6
0.8
1.0
te st
a cc
ur ac
y
baseline max test:D1 test:D2 test:D1 D2
0 2 4 6 8 10 12 14 16 18 20 epoch
0.0
0.2
0.4
0.6
0.8
1.0
te st
a cc
ur ac
y
baseline max test:D1 test:D2 test:D1 D2
0 2 4 6 8 10 12 14 16 18 20 epoch
0.0
0.2
0.4
0.6
0.8
1.0
te st
a cc
ur ac
y
baseline max test:D1 test:D2 test:D1 D2
EWC D9-1b EMNIST EWC D9-1b MNIST EWC D9-1b Devanagari
0 2 4 6 8 10 12 14 16 18 20 epoch
0.0
0.2
0.4
0.6
0.8
1.0
te st
a cc
ur ac
y
baseline max test:D1 test:D2 test:D1 D2
0 2 4 6 8 10 12 14 16 18 20 epoch
0.0
0.2
0.4
0.6
0.8
1.0
te st
a cc
ur ac y baseline max test:D1 test:D2 test:D1 D2
0 2 4 6 8 10 12 14 16 18 20 epoch
0.0
0.2
0.4
0.6
0.8
1.0
te st
a cc
ur ac
y
baseline max test:D1 test:D2 test:D1 D2
EWC D5-5d EMNIST EWC D5-5d MNIST EWC D5-5d Devanagari
0 2 4 6 8 10 12 14 16 18 20 epoch
0.0
0.2
0.4
0.6
0.8
1.0
te st
a cc
ur ac
y
baseline max test:D1 test:D2 test:D1 D2
0 2 4 6 8 10 12 14 16 18 20 epoch
0.0
0.2
0.4
0.6
0.8
1.0
te st
a cc
ur ac
y
baseline max test:D1 test:D2 test:D1 D2
0 2 4 6 8 10 12 14 16 18 20 epoch
0.0
0.2
0.4
0.6
0.8
1.0
te st
a cc
ur ac
y
baseline max test:D1 test:D2 test:D1 D2
wtIMM D9-1b Devanagari
0 2 4 6 8 10 12 14 16 18 20 epoch 0.0
0.2
0.4
0.6
0.8
1.0
te st
a cc
ur ac
y
baseline best train:D1;test:D1 train:D2;test:D2
0.0 0.2 0.4 0.6 0.8 1.0 alpha 0.0
0.2
0.4
0.6
0.8
1.0
te st
a cc
ur ac
y
Mean =0.25, max=0.85
Mode =0.75, max=0.85
Mean-IMM;test:All Mode-IMM;test:All
wtIMM D9-1b MNIST
0 2 4 6 8 10 12 14 16 18 20 epoch 0.0
0.2
0.4
0.6
0.8
1.0
te st
a cc
ur ac
y
baseline best train:D1;test:D1 train:D2;test:D2
0.0 0.2 0.4 0.6 0.8 1.0 alpha 0.0
0.2
0.4
0.6
0.8
1.0
te st
a cc
ur ac
y Mean =0.21, max=0.93
Mode =0.18, max=0.88 Mean-IMM;test:All Mode-IMM;test:All

Review summaries:
The paper presents a study of the application of some well known methods on 9 datasets focusing on the issue of catastrophic forgetting when considering a sequential learning task in them.  In general the presentation of concepts and results is a bit problematic and unclear. Comments, such that the paper presents ' a novel training and model selection paradigm for incremental learning in DNNs ' is not justified.  A better description of the results, e.g., in Table 3 should be presented, as well a better linking with the findings; a better structure of the latter would also be required to improve consistency of them. Improving these could make the paper candidate for a poster presentation.