Eden Belouadah

Adrian Popescu

Ioannis Kanellos

A Comprehensive Study of Class Incremental Learning Algorithms for Visual Tasks

Keywords:

The ability of artificial agents to increment their capabilities when confronted with new data is an open challenge in artificial intelligence. The main challenge faced in such cases is catastrophic forgetting, i.e., the tendency of neural networks to underfit past data when new ones are ingested. A first group of approaches tackles forgetting by increasing deep model capacity to accommodate new knowledge. A second type of approaches fix the deep model size and introduce a mechanism whose objective is to ensure a good compromise between stability and plasticity of the model. While the first type of algorithms were compared thoroughly, this is not the case for methods which exploit a fixed size model. Here, we focus on the latter, place them in a common conceptual and experimental framework and propose the following contributions: (1) define six desirable properties of incremental learning algorithms and analyze them according to these properties, (2) introduce a unified formalization of the class-incremental learning problem, (3) propose a common evaluation framework which is more thorough than existing ones in terms of number of datasets, size of datasets, size of bounded memory and number of incremental states, (4) investigate the usefulness of herding for past exemplars selection, (5) provide experimental evidence that it is possible to obtain competitive performance without the use of knowledge distillation to tackle catastrophic forgetting and (6) facilitate reproducibility by integrating all tested methods in a common open-source repository. The main experimental finding is that none of the existing algorithms achieves the best results in all evaluated settings. Important differences arise notably if a bounded memory of past classes is allowed or not.

Introduction

Artificial agents which evolve in dynamic environments should be able to update their capabilities in order to integrate new data. Depending on the work hypotheses made, names such as continual learning [START_REF] Seff | Continual learning in generative adversarial nets[END_REF][START_REF] Shin | Continual learning with deep generative replay[END_REF], lifelong learning [START_REF] Aljundi | Expert gate: Lifelong learning with a network of experts[END_REF][START_REF] Parisi | Continual lifelong learning with neural networks: A review[END_REF] or incremental learning (IL) [START_REF] Belouadah | Deesil: Deep-shallow incremental learning[END_REF][START_REF] Castro | End-to-end incremental learning[END_REF][START_REF] He | Exemplar-supported generative reproduction for class incremental learning[END_REF][START_REF] Rebuffi | icarl: Incremental classifier and representation learning[END_REF] are used to describe associated works. The challenge faced in all cases is catastrophic forgetting [START_REF] Mccloskey | Catastrophic interference in connectionist networks: The sequential learning problem[END_REF], i.e., the tendency of a neural network to underfit past data when new ones are ingested. The effect of catastrophic forgetting is alleviated either by increasing the model capacity to accommodate new knowledge or by storing exemplars of past classes in a bounded memory and replaying them in each new state. Continual and lifelong learning algorithms usually increase model capacity and are tested in a setting in which a new task is added in each new state of the system. Recent comparative studies [START_REF] Lange | Continual learning: A comparative study on how to defy forgetting in classification tasks[END_REF][START_REF] Parisi | Continual lifelong learning with neural networks: A review[END_REF] provide good coverage of these two types of approaches but give little room to incremental learning algorithms. We focus on class IL algorithms which provide the most interesting results in recent works from literature [START_REF] Belouadah | Il2m: Class incremental learning with dual memory[END_REF][START_REF] Belouadah | Scail: Classifier weights scaling for class incremental learning[END_REF][START_REF] Castro | End-to-end incremental learning[END_REF][START_REF] Hayes | REMIND your neural network to prevent catastrophic forgetting[END_REF][START_REF] Hayes | Lifelong machine learning with deep streaming linear discriminant analysis[END_REF][START_REF] Hou | Learning a unified classifier incrementally via rebalancing[END_REF][START_REF] Rebuffi | icarl: Incremental classifier and representation learning[END_REF][START_REF] Wu | Large scale incremental learning[END_REF]. Their study is interesting because one early example of such work [START_REF] Rebuffi | icarl: Incremental classifier and representation learning[END_REF] is shown to outperform continual learning approaches when tested in a common experimental setting [START_REF] Lange | Continual learning: A comparative study on how to defy forgetting in classification tasks[END_REF]. More recent eden.belouadah@cea.fr (E. Belouadah); adrian.popescu@cea.fr (A. Popescu); ioannis.kanellos@imt-atlantique.fr (I. Kanellos) ORCID(s): 0000-0002-3418-1546 (E. Belouadah); 0000-0002-8099-824X (A. Popescu); 0000-0001-5323-1601 (I. Kanellos) works [START_REF] Belouadah | Il2m: Class incremental learning with dual memory[END_REF][START_REF] Belouadah | Scail: Classifier weights scaling for class incremental learning[END_REF][START_REF] Castro | End-to-end incremental learning[END_REF][START_REF] Hou | Learning a unified classifier incrementally via rebalancing[END_REF][START_REF] Wu | Large scale incremental learning[END_REF] have provided strong improvements compared to [START_REF] Rebuffi | icarl: Incremental classifier and representation learning[END_REF]. We propose a series of contributions to better understand and evaluate existing class IL algorithms as well as interesting combinations of their components.

We first define a common analysis framework made of six desirable properties of incremental learning algorithms. This set of properties builds on the one proposed in [START_REF] Rebuffi | icarl: Incremental classifier and representation learning[END_REF], which already includes three of them (marked with * below):

1. Complexity (C)* -capacity to integrate new information with a minimal change in terms of the model structure. For a deep neural network, only the size of the classification layer should grow. Otherwise, the total number of parameters of the model is likely to increase strongly, especially at large scale. 2. Memory (M)* -ability to work with or without a fixed-size memory of past classes. Naturally, algorithms that do not require past data are preferable, but their performance is likely to be lower, especially if complexity growth is minimized. 3. Accuracy (A)* -performance for past and new classes should approach that of a non-incremental learning process that has access to all data at all times. 4. Timeliness (T) -delay needed between the occurrence of new data and their integration in the incremental models. 5. Plasticity (P) -capacity to deal with new classes that are significantly different from the ones that were learned in the past [START_REF] Tamaazousti | Learning more universal representations for transfer-learning[END_REF]. [START_REF] Belouadah | Deesil: Deep-shallow incremental learning[END_REF]. Scalability (S) -the aptitude to learn a large number of classes, typically up to tens of thousands, and ensure usability in complex real-world applications.

Second, we propose a unified formalization of the class incremental learning problem and use it to analyze algorithms and results. Focus is put on the components which differentiate algorithms one from another in order to facilitate the understanding of advantages and limitations brought by each one of them. Moreover, we introduce promising combinations of components from different algorithms and assess their merits experimentally.

Third, we propose a thorough evaluation framework. Four public datasets designed for different visual tasks are used to test performance variability. Three splits in terms of the number of incremental states and three sizes for past memory are tested to assess performance robustness for these IL parameters, which were previously identified as being the most important [START_REF] Castro | End-to-end incremental learning[END_REF][START_REF] Rebuffi | icarl: Incremental classifier and representation learning[END_REF]. We also propose an evaluation of the case when no past memory is allowed because this setting has a strong influence on algorithm performance.

Fourth, we examine the role of herding-based exemplar selection for past classes. Introduced in [START_REF] Welling | Herding dynamical weights to learn[END_REF] and first used in an IL context by [START_REF] Rebuffi | icarl: Incremental classifier and representation learning[END_REF], its usefulness was questioned in [START_REF] Castro | End-to-end incremental learning[END_REF][START_REF] Javed | Revisiting distillation and incremental classifier learning[END_REF][START_REF] Liu | Mnemonics training: Multi-class incremental learning without forgetting[END_REF] where it was reported to provide only marginal improvement compared to random selection. We run extensive experiments with the two selection algorithms and conclude that herding is useful for all methods tested.

Fifth, we show that it is possible to obtain interesting performance without the widely used knowledge distillation component [START_REF] Castro | End-to-end incremental learning[END_REF][START_REF] Hou | Learning a unified classifier incrementally via rebalancing[END_REF][START_REF] Javed | Revisiting distillation and incremental classifier learning[END_REF][START_REF] Liu | Mnemonics training: Multi-class incremental learning without forgetting[END_REF][START_REF] Rebuffi | icarl: Incremental classifier and representation learning[END_REF][START_REF] Wu | Large scale incremental learning[END_REF]. Instead, we use vanilla fine-tuning as a backbone for class IL with memory and model the problem as a case of imbalanced learning. The well-known thresholding method [START_REF] Buda | A systematic study of the class imbalance problem in convolutional neural networks[END_REF] is used to reduce the classification bias between past and new classes.

Last but not least, we integrate the tested methods into a common open-source repository. We notably modify the implementations to make inputs and outputs uniform. These changes will facilitate future experiments in the existing setting and will allow an easy extension to other datasets.

The main experimental finding here is that none of the existing class IL algorithms is better than the others in all experimental configurations. We find that both memory and incremental state sizes influence the relative performance of algorithms. However, the most significant performance changes appear when testing IL with and without a memory of past classes. These findings indicate that class incremental learning remains an open research problem, and further research efforts should be dedicated to it.

Related work

There is a strong regain of interest for incremental learning due to the proposal of different deep learning based algorithms. We categorize recent approaches in three main groups and map each group to the six IL properties from Section 1 in Table 1. We discuss the advantages and/or challenges related to each group-property pair to facilitate their comparison. We also provide a global assessment with a focus on the application contexts in which each type of approach could be deployed.

Model-Growth (MG) based methods increase the size of deep models to include new knowledge. Wang et al. [START_REF] Wang | Growing a brain: Finetuning by increasing model capacity[END_REF] introduced Growing a Brain, a method based on increasing representational capacity by widening or deepening the network. Progressive Neural Networks [START_REF] Rusu | Progressive neural networks[END_REF] are an alternative approach that exploits several models during training to preserve knowledge from past tasks. Lateral connections between all models are learned to leverage prior knowledge of past features and thus reduce the effect of catastrophic forgetting. Recently, [START_REF] Roy | Tree-cnn: A hierarchical deep convolutional neural network for incremental learning[END_REF] propose an adaptive network that enables self-growth in a tree-like manner. It is based on features hierarchy reorganization whenever new tasks arrive.

Aljundi et al. [START_REF] Aljundi | Expert gate: Lifelong learning with a network of experts[END_REF] present a lifelong learning architecture based on a network of experts. A gating mechanism uses training samples to decide which expert to transfer knowledge from for each task. Deep Adaptation Networks [START_REF] Rosenfeld | Incremental learning through deep adaptation[END_REF] is another model-growth based approach which adds additional parameters for each new task. The architecture is importantly augmented if a large number of new tasks arrives. The approach presented in [START_REF] Rebuffi | Efficient parametrization of multi-domain deep neural networks[END_REF] is based on several neural networks that share the majority of parameters and add modular adapters to connect the networks and specialize each one of them for a specific task.

[41] is based on a pruning technique that identifies redundant parameters and uses them to train the network on new tasks. The approach is not able to learn a large number of tasks since the network can not be strongly compressed without significant performance loss. [START_REF] Mallya | Piggyback: Adapting a single network to multiple tasks by learning to mask weights[END_REF] is a modified version of that exploits network quantization to propose masks for individual weights. It thus learns a large number of tasks with a single base network. The approach increases the model complexity as extra parameters are added to include new tasks. Alternately, Memory Aware Synapses (MAS) [START_REF] Aljundi | Memory aware synapses: Learning what (not) to forget[END_REF] deploys a mechanism that identifies the most important weights in the model by looking at the sensitivity of the output function instead of the loss. When a new task arrives, changes to important weights are penalized. This method is basically designed to work with unlabeled datasets, but was later adapted for usage with unlabeled datasets [START_REF] Aljundi | Task-free continual learning[END_REF]. This use case is very interesting but, for now, limited to specific tasks such as face recognition.

Self-Organizing Maps (SOMs) are online unsupervised learning algorithms that rely on approximate stochastic gradient technique, and can be adapted to Incremental Learning. Neural Gas (NG) networks [START_REF] Martinetz | neural-gas' network for vector quantization and its application to time-series prediction[END_REF] and its growing NG variant [START_REF] Fritzke | A growing neural gas network learns topologies[END_REF] are related to SOMs which are often exploited for incremental learning. PROjection-PREdiction ( ) [START_REF] Gepperth | Incremental learning with selforganizing maps[END_REF] is an incremental learner based on NG and SOMs, which implements an extra supervised read-out layer implemented as a linear regression, as well as a concept drift detection mechanism in order to make the SOM usuable in IL context. Neural Gas with local Principal Component Analysis (

) [START_REF] Aleo | Incremental learning for visual classification using neural gas[END_REF] is an online incremental learner fo-

Model-Growth based

Fixed-Representation based Fine-Tuning based

Complexity

The model evolves by adding parameters and weights to interconnect them [START_REF] Rebuffi | Efficient parametrization of multi-domain deep neural networks[END_REF][START_REF] Rusu | Progressive neural networks[END_REF][START_REF] Wang | Growing a brain: Finetuning by increasing model capacity[END_REF] or small networks [START_REF] Aljundi | Expert gate: Lifelong learning with a network of experts[END_REF] to include new knowledge. The challenge is to optimize the effect of model growth on performance [START_REF] Lange | Continual learning: A comparative study on how to defy forgetting in classification tasks[END_REF][START_REF] Rebuffi | Efficient parametrization of multi-domain deep neural networks[END_REF].

The model is fixed after the first nonincremental step. In a basic setting [START_REF] Belouadah | Deesil: Deep-shallow incremental learning[END_REF][START_REF] Rebuffi | Learning multiple visual domains with residual adapters[END_REF], the only parameters added are those needed for new classes weights. In a more advanced setting [START_REF] Kemker | Fearnet: Brain-inspired model for incremental learning[END_REF], additional parameters are needed to improve past classes performance.

This group of IL methods are designed to work with a fixed structure of the backbone model. The number of parameters is only marginally affected by the modifications of the classification layer designed to reduce imbalance between past and new classes [START_REF] Castro | End-to-end incremental learning[END_REF][START_REF] Hou | Learning a unified classifier incrementally via rebalancing[END_REF][START_REF] Wu | Large scale incremental learning[END_REF].

Memory

The model growth allows for the deployment of these methods without the use of an exemplar memory. Memory is allocated to additional model parameters and weights instead of raw data for past classes, which is a more parsimonious way to store information about past classes [START_REF] Aljundi | Memory aware synapses: Learning what (not) to forget[END_REF][START_REF] Aljundi | Expert gate: Lifelong learning with a network of experts[END_REF][START_REF] Roy | Tree-cnn: A hierarchical deep convolutional neural network for incremental learning[END_REF].

Fixed-representations do not update the model during the incremental learning process and thus have a very low dependency on the memory of past classes [START_REF] Belouadah | Deesil: Deep-shallow incremental learning[END_REF]. Class weights are learned when they are first encountered and can be used throughout all subsequent incremental states.

Performance of these methods is heavily dependent on the size of the past memory. However, storing a large amount of past exemplars is contradictory to IL objectives. Memory needs are reduced by exploiting knowledge distillation [START_REF] Castro | End-to-end incremental learning[END_REF][START_REF] Hou | Learning a unified classifier incrementally via rebalancing[END_REF][START_REF] Javed | Revisiting distillation and incremental classifier learning[END_REF][START_REF] Wu | Large scale incremental learning[END_REF] or by exploiting statistical properties of past states [START_REF] Belouadah | Il2m: Class incremental learning with dual memory[END_REF][START_REF] Belouadah | Scail: Classifier weights scaling for class incremental learning[END_REF].

Accuracy

Performance is correlated to the amount of model growth allowed. If growth is limited, MG-based methods have lower performance compared to that of FTbased ones [START_REF] Lange | Continual learning: A comparative study on how to defy forgetting in classification tasks[END_REF]. If significant growth is allowed significantly [START_REF] Roy | Tree-cnn: A hierarchical deep convolutional neural network for incremental learning[END_REF], performance comes close to that of classical learning, but this is somewhat contradictory to the requirement to keep models complexity close to constant.

Accuracy is lower compared to FTbased methods because the model is not updated incrementally. High performance can be obtained with fixedrepresentations if the initial model is learned with a large dataset [START_REF] Belouadah | Deesil: Deep-shallow incremental learning[END_REF], but the existence of such a dataset is a strong assumption in an incremental setting.

Recent approaches report strong performance gain compared to previous work such as [START_REF] Castro | End-to-end incremental learning[END_REF][START_REF] Javed | Revisiting distillation and incremental classifier learning[END_REF][START_REF] Rebuffi | icarl: Incremental classifier and representation learning[END_REF] either through more sophisticated definitions of knowledge distillation [START_REF] Hou | Learning a unified classifier incrementally via rebalancing[END_REF] or through the casting of IL as an imbalanced learning problem [START_REF] Belouadah | Il2m: Class incremental learning with dual memory[END_REF][START_REF] Belouadah | Scail: Classifier weights scaling for class incremental learning[END_REF] or a combination of both [START_REF] Wu | Large scale incremental learning[END_REF]. The gap with classical learning is narrowed if enough memory of past classes is allowed [START_REF] Hou | Learning a unified classifier incrementally via rebalancing[END_REF][START_REF] Wu | Large scale incremental learning[END_REF].

Timeliness

The complexity of model growth is generally similar to that of FT-based methods since retraining is needed for each incremental update [START_REF] Lange | Continual learning: A comparative study on how to defy forgetting in classification tasks[END_REF].

Only the classifier weights layer needs to be trained and new knowledge is integrated in a timely manner [START_REF] Hayes | Lifelong machine learning with deep streaming linear discriminant analysis[END_REF].

New classes are not recognizable until retraining is finished to include them in the model. If applications are timesensitive, an acceleration of the training process can be envisioned at the expense of result suboptimality.

Plasticity MG-based methods are specifically designed to cope with different visual tasks [START_REF] Aljundi | Memory aware synapses: Learning what (not) to forget[END_REF][START_REF] Mallya | Piggyback: Adapting a single network to multiple tasks by learning to mask weights[END_REF]. The challenge is to minimize the amount of additional parameters needed to accommodate each new task [START_REF] Lange | Continual learning: A comparative study on how to defy forgetting in classification tasks[END_REF].

Plasticity is limited since the representation is learned in the first state and then fixed. Performance drops significantly if the incremental tasks change a lot and the initial representation is not transferable anymore [START_REF] Razavian | CNN features off-the-shelf: An astounding baseline for recognition[END_REF].

The model updates enable adaptation to new data as they are streamed into the system. If no memory is allowed, plasticity is too important and this shift is controlled through knowledge distillation or imbalance handling.

Scalability

These methods scale well to new classes or tasks as long as the systems in which they are deployed have sufficient resources to support the underlying model growth for training and inference phases, as well as for its storage.

The dependence on the bounded memory is limited and FR-based methods can include a very large number of classes. This is possible because class weights are learned in their initial state and reused later.

The size of the bounded memory determines the number of past classes for which exemplars can be stored and which are still recognizable when new ones are integrated. If the memory constraints allow for this, the memory can be increased to keep the number of exemplars per class constant [START_REF] Hou | Learning a unified classifier incrementally via rebalancing[END_REF].

Global assessment

Approaches in this group cope well with new data, are not or weakly dependent on a memory of the past, and are scalable to a large number of classes. However, complexity is a disadvantage since the model has to grow in order to integrate new knowledge. They also require retraining when new classes are added, and timeliness is not optimal. They are usable when: model complexity can grow during the incremental process, streamed data vary a lot between incremental states, no storage is available for past data and immediate use of updated models is not essential.

Fixed-representation methods inherit the advantages and disadvantages of transfer learning schemes. Model complexity is constant and they can be updated in a timely manner since only the classification layer is retrained. They have a low dependency on past memory and can scale up to a large number of classes. However, these algorithms are heavily dependant on the quality of the initial representation and have a low plasticity. They are usable when: model complexity should stay constant, data variability is low, no storage is available for past memory and updates are needed in a timely manner.

Fine-tuning based methods are adequate when we try to optimize the architecture complexity and the plasticity [START_REF] Tamaazousti | Learning more universal representations for transfer-learning[END_REF] of representations. However, since they require network retraining when new classes are added, their timeliness is not optimal. Equally important, the bounded memory constraint makes it hard to scale because the memory will eventually become too small to represent past classes adequately. They are usable when: model complexity should stay constant, streamed data vary a lot between incremental states, storage is available for past data and immediate use of updated models is not essential.

Table 1

Analysis of the main groups of incremental learning algorithms with respect to their desirable properties. A global assessment with recommended use cases is also provided.

cused on robot platform for object manipulation tasks. It modifies the classical NG algorithm to extend nodes to ellipoids to better match the data distribution. Dynamic Online Growing Neural Gas ( ) [START_REF] Beyer | DYNG: dynamic online growing neural gas for stream data classification[END_REF] is an online classification approach that controls the growing speed of the NG network in such a way to speed up learning for new knowledge while slowing down the growth for the already learned knowledge. and are very interesting methods but not directly comparable to the methods evaluated here since they do not exploit deep learning backbones. NG and SOM are growing networks that were widely used for incremental semi-supervised clustering [START_REF] Fritzke | A growing neural gas network learns topologies[END_REF], multiclass online classification problems [START_REF] Belfort | Online incremental supervised growing neural gas[END_REF], and online semisupervised vector quantization learning [START_REF] Shen | Online semisupervised learning with learning vector quantization[END_REF].

We note that SOM and NG are originally designed for unsupervised learning and an adaptation to a supervised scenario is needed for comparability with the approaches which are in focus here. TOpology-Preserving knowledge InCrementer (

) [START_REF] Tao | Few-shot class-incremental learning[END_REF] is a very recent such work which adapts NG to class incremental learning for visual datasets with focus on few-shot learning, with a method named , but experiments are also run for the standard scenario. First, introduces an NG network to learn feature space topologies for knowledge representation. The network grows to learn new classes while also dealing with changes in the feature space due to deep model update. This is achieved using a Min-Max loss that pushes new classes that share the same label to a new NG node, while pulling the new nodes of different labels away from each others. Second, preserves past knowledge by stabilizing the topology of the NG network using an Anchor Loss term. Since focuses on the feature space which encodes more semantic information than the raw classification scores, it is less affected by the bias induced by high new classes' raw scores. A topology-preserving network named is introduced in [START_REF] Tao | Topologypreserving class-incremental learning[END_REF] to handle catastrophic forgetting. The network models the feature space using an Elastic Hebbian Graph, and the topology is maintained using a topology-preserving loss that constrains the neighborhood relationships in the graph when learning new classes. This approach augments the Hebbian graph by inserting vertices for each new class. The addition of nodes in and gradually increases the complexity of the architecture.

Incremental Learning Vector Quantization ( ) [START_REF] Xu | An online incremental learning vector quantization[END_REF] is a prototype-based classifier that does not require prior knowledge of the number of prototypes or their initial value. Instead, it uses a threshold-based insertion scheme, based on training data distribution to determine the number of required prototypes for each class. The main drawback of this approach is the continuously increasing architecture to store the learned patterns in order to function in an IL setting.

Fixed-Representation (FR) based methods do not update the deep representation for each incremental state and are less present in literature. They can be seen as a basic variant of fine-tuning based methods. A fixed-representation method is briefly described in [START_REF] Rebuffi | icarl: Incremental classifier and representation learning[END_REF]. The results reported with it are poor, and this is due to a suboptimal usage of the method. In particular, the classification layer for past classes is needlessly relearned in each incremental state using only the exemplars of each class. Since they rely on a fixed representation, the stronger classifier weights learned initially with all past class data are reusable. Deep Shallow Incremental Learning ( ) [START_REF] Belouadah | Deesil: Deep-shallow incremental learning[END_REF] is a method which applies a simple transfer learning scheme [START_REF] Kornblith | Do better imagenet models transfer better?[END_REF][START_REF] Razavian | CNN features off-the-shelf: An astounding baseline for recognition[END_REF]. The approach makes use of a deep fixed representation to learn the first batch of classes and a battery of Support Vector Machines (SVMs) [START_REF] Boser | A training algorithm for optimal margin classifiers[END_REF] to incrementally learn new classes.

FearNet [START_REF] Kemker | Fearnet: Brain-inspired model for incremental learning[END_REF] is a biologically inspired such method. Separate networks are used for long and short term memories to represent past and new classes. A decision mechanism is implemented to decide which network should be used for each test example.

is interesting, but its memory increases significantly with time since the algorithm needs to store detailed statistics for each class learned.

Deep Streaming Linear Discriminant Analysis ( -) [START_REF] Hayes | Lifelong machine learning with deep streaming linear discriminant analysis[END_REF] is an online approach based on SLDA [START_REF] Pang | Incremental linear discriminant analysis for classification of data streams[END_REF] algorithm. The Network is trained on the first batch of classes and is frozen afterwards. During training, a class-specific running mean vector and a shared covariance matrix are updated, while the prediction is done by assigning the label to the closest Gaussian in feature space defined by the classmean vectors and covariance matrix.

REplay using Memory INDexing ( ) [START_REF] Hayes | REMIND your neural network to prevent catastrophic forgetting[END_REF] is brain inspired by the hippocampal indexing theory. The method is also based on an initial representation which is only partially updated afterwards. The approach uses a vector quantization technique to stores compressed intermediate representations of images, which are more compact than images. The stored vectors are reconstructed and replayed for memory consolidation. Vector quantization is widely used in unsupervised incremental learning [START_REF] Lughofer | Extensions of vector quantization for incremental clustering[END_REF]. Here, the authors combine the Adaptive Resonance Theory (ART) with variant of vector quantization to balance the trade-off between plasticity and stability during incremental online learning. This approach was designed to handle two-and high-dimensional data within image classification framework. We tackle in this paper supervised learning, and this approach is not compatible with our experimental protocol.

Fine-Tuning (FT) based methods form a group which often uses a distillation [START_REF] Hinton | Distilling the knowledge in a neural network[END_REF] term to reduce catastrophic forgetting [START_REF] Mccloskey | Catastrophic interference in connectionist networks: The sequential learning problem[END_REF]. The use of knowledge distillation in an IL context is similar to self-distillation [START_REF] Furlanello | Born-again neural networks[END_REF][START_REF] Yim | A gift from knowledge distillation: Fast optimization, network minimization and transfer learning[END_REF] in that it operates with the same network architecture for the teacher and the student. However, a notable difference arises from the fact that new data are progressively incorporated. Learning without Forgetting ( ) [START_REF] Li | Learning without forgetting[END_REF] is a pioneering work that does not require a memory of past classes. It leverages knowledge distillation [START_REF] Hinton | Distilling the knowledge in a neural network[END_REF] to minimize the discrepancy between representations of past classes from the previous and current IL states.

first performs a warm-up step that freezes the past parameters and trains only the new ones and then jointly trains all network parameters until convergence.

Incremental Classifier and Representation Learning ( ) [START_REF] Rebuffi | icarl: Incremental classifier and representation learning[END_REF] is a popular IL method that combines the use of and of a memory for past class exemplars storage. Classification is performed with a nearest-mean-ofexemplars method instead of the raw scores predicted by the network. This external classifier is deployed to reduce the prediction bias in favor of new classes, which occurs due to data imbalance between past and new classes. An iCaRL analysis [START_REF] Javed | Revisiting distillation and incremental classifier learning[END_REF] concludes that its most important components are the fixed-size memory and the distillation loss. The herding mechanism and the nearest-mean-of-exemplars classification seem to matter less. The authors of [START_REF] Castro | End-to-end incremental learning[END_REF] present an IL algorithm which differs from mainly through the way prediction bias is reduced. The external classifier is replaced by a balanced fine-tuning step, which uses the same number of samples for past and new classes. This component has an important impact on performance and leads to a strong improvement compared to . Sophisticated data augmentation is also used and has a small positive influence on results.

Learning without Memorizing ( ) [START_REF] Dhar | Learning without memorizing[END_REF] is a distillation based approach that does not need memory for past classes. Instead, the authors propose an information preserving penalty using attention distillation loss that captures the changes in the classifier attention maps in order to preserve past knowledge. In [START_REF] Zhang | Class-incremental learning via deep model consolidation[END_REF], another distillation based system is proposed, it trains two separate networks, one for new classes and one for past classes, and then combines them via a double distillation loss. A deep memory consolidation is also performed using unlabeled auxiliary data to replace past class memory.

A part of recent IL approaches focuses on a more sophisticated tackling of catastrophic forgetting. The authors of Multi-model and Multi-level Knowledge Distillation ( 2) [START_REF] Zhou | M2KD: multi-model and multi-level knowledge distillation for incremental learning[END_REF] propose a loss that distills knowledge not only from the previous model but from all the past models where the classes have been learned for the first time. They also propose an additional distillation term that operates on the intermediate layers of the CNN in addition to the last fully connected one. In [START_REF] Xiang | Efficient incremental learning using dynamic correction vector[END_REF], knowledge distillation is also combined with a fixed-size memory of the past. The authors deploy an algorithm to set a dynamic vector which corrects the bias induced by distillation loss among past classes and improves the representativeness of past image features. Hou et al. [START_REF] Hou | Learning a unified classifier incrementally via rebalancing[END_REF] present Learning a Unified Classifier Incrementally via Rebalancing ( ), a method which gains a lot of traction.

is based on three main components: (1) cosine normalization balances the magnitudes of past and new class probabilities, (2) less-forget constraint modifies the usual distillation loss to handle feature vectors instead of raw scores and (3) inter-class separation encourages the network to separate past and new class embeddings and actually implements a theoretical finding from [START_REF] Phuong | Towards understanding knowledge distillation[END_REF]. Note that further improvement of IL with distillation could be obtained by adapting recent theoretical and empirical ad-vances such as those described in [START_REF] Park | Relational knowledge distillation[END_REF] and [START_REF] Phuong | Towards understanding knowledge distillation[END_REF]. Alternately, [START_REF] Douillard | Podnet: Pooled outputs distillation for small-tasks incremental learning[END_REF] relies on a spacial-based distillation loss that constrains the evolution of the model's representation, and multiple proxy vectors to flexibly represent learned classes. This approach is more adequate with long runs of small incremental tasks.

Another recent stream of research focuses on modeling IL as an imbalanced learning problem. Bias Correction (

) [START_REF] Wu | Large scale incremental learning[END_REF] is a recent approach that uses a classical knowledge distillation term and adds a linear layer after the prediction layer of the deep model to reduce the bias in favor of new classes. The layer needs a validation set to learn parameters and is effective as long as the size of the validation set is sufficient. Class Incremental Learning with Dual Memory ( 2 ) [START_REF] Belouadah | Il2m: Class incremental learning with dual memory[END_REF] advocates for the use of vanilla finetuning as a backbone for IL. A very compact memory that stores classification statistics from the initial state of each classifier is added. Its content is leveraged to rectify scores of past classes and make them more comparable to those of new classes. Maintaining Discrimination and Fairness ( ) [START_REF] Zhao | Maintaining discrimination and fairness in class incremental learning[END_REF] is very similar to 2 . The main difference is that keeps the distillation loss to maintain discrimination between past classes. In , the rectification of class scores is done by aligning new class weights to those of past classes by multiplying each new class weight by the mean norm of past class weights and dividing it by the mean norm of new class weights, before to finally compute the prediction scores.

Classifier Weights Scailing for Class Incremental Learning (

) [START_REF] Belouadah | Scail: Classifier weights scaling for class incremental learning[END_REF] is motivated by the same hypothesis as 2 [START_REF] Belouadah | Il2m: Class incremental learning with dual memory[END_REF], [START_REF] Zhao | Maintaining discrimination and fairness in class incremental learning[END_REF] and [START_REF] Wu | Large scale incremental learning[END_REF]. Inspired by fixed-representation methods, bias reduction is achieved by reusing the classifier weights learned initially with all data. The experimental results indicate that, while the model evolves throughout incremental states, initial classifiers are still usable after a scaling operation, which makes them comparable to classifiers learned for new data. Standardization of Initial Weights (SIW) [START_REF] Belouadah | Initial classifier weights replay for memoryless class incremental learning[END_REF] is also based on initial weights replay in a memoryless IL setting. The weights replay is followed by standardization of all class weights to smooth weights distribution in order to tackle catastrophic forgetting.

Mnemonics Training [START_REF] Liu | Mnemonics training: Multi-class incremental learning without forgetting[END_REF] is built on top of herdingbased approaches such as , and to modify the herding procedure by parameterizing exemplars and making them optimizable. The network is then optimized in two manners: model-level and exemplar-level. The memory is thus adjusted incrementally to match the data distribution in an effective way, leading mnemonic exemplars to yield separation between classes. In embedding systems, Semantic Drift Compensation ( ) [START_REF] Yu | Semantic drift compensation for classincremental learning[END_REF] was proposed to estimate the semantic drift of past knowledge while learning new knowledge to compensate for it, to further improve performance. The drift is computed at the class-meanembedding level, which means that this approach is based on NCM classifier that does not need exemplars storage, since the past class-mean embeddings are estimated using new data only. In [START_REF] Singh | Calibrating cnns for lifelong learning[END_REF], authors propose an approach that calibrates activation maps of the CNN in order to accommodate new knowledge. Calibration is done using spatial and channel-wise calibration modules, and only the calibration parameters are trained at each new incremental state. This method does not require a past-class memory. However, the calibration parameters grow instead.

Using Generative Adversarial Networks (GANs) to generate past data holds promise since it reduces the memory footprint of algorithms. However, despite recent progress [START_REF] Ghosh | Multi-agent diverse generative adversarial networks[END_REF], generated images are still sub-optimal for IL. Since additional GAN models need to be created, the complexity in the number of parameters is fair but not optimal. The authors of [START_REF] Wu | Incremental classifier learning with generative adversarial networks[END_REF] use a GAN to create artificial images for past classes. Generated and real examples are mixed to obtain slightly better performance than that of [START_REF] Rebuffi | icarl: Incremental classifier and representation learning[END_REF]. However, the performance significantly drops when relying exclusively on artificially generated images. Alternately, GAN Memory with No Forgetting [START_REF] Cong | GAN memory with no forgetting[END_REF] is based on sequential style modulations to represent the past memory by forming a sequential targeted generative models. Here, the memory itself is designed as a form of lifelong learning.

This paper is focused on a scenario that requires a constant complexity of deep models and investigate the effect of allowing a fixed-size memory or not. Consequently, experiments are conducted with approaches that are fit to work under these conditions, namely those based on fine tuning and fixed representations.

Problem formalization

We propose a formalization of class incremental learning which builds on those introduced in [START_REF] Belouadah | Il2m: Class incremental learning with dual memory[END_REF][START_REF] Belouadah | Scail: Classifier weights scaling for class incremental learning[END_REF][START_REF] Castro | End-to-end incremental learning[END_REF][START_REF] Rebuffi | Learning multiple visual domains with residual adapters[END_REF]. Given an initial non-incremental state S 0 , a model M 0 is trained from scratch on a dataset D 0 = {( 0 , 0 ); = 1, 2, ..., 0 }. 0 and 0 are respectively the set of images and labels for the ℎ class in S 0 , 0 = 0 is the number of classes in the first non-incremental state.

We note the total number of states, including the initial state and -1 incremental states. A new batch of new classes is streamed in each incremental state S and the objective is to learn a model M which recognizes = 0 + 1 + ... + classes. This model is trained using the previous state model M -1 on a dataset D = {( , 0 ); = 1, 2, ..., } ∪ K. Note that all data of the new classes are available with only a bounded exemplar subset K of data from the -1 = 0 + 1 + ... + -1 past classes. An imbalance in favor of new classes appears and grows throughout incremental states since the bounded memory K needs to be allocated to a larger number of past classes each time.

As discussed in Section 2, recent class incremental learning algorithms were implemented using deep convolutional networks (DNNs) as a backbone. While DNNs are end-to-end classification approaches, a part of the IL algorithms use a separate classifier layer. In such cases, the model M includes two main components: a feature extrac-tor F and a classification component C .

The feature extractor F is defined as:

F ∶ → ℝ x ↦ F (x) = x (1)
where x is a -dimensional compact vectorial representation of the image x.

The classifier C is usually defined as:

C ∶ ℝ → ℝ x ↦ C ( x ) = x × + = (2)
where:

• = ( 1 , 2 , ...,
) is the vector of raw scores of size providing the individual prediction scores for each class = 1, 2, ..., .

•

and are the weights matrix and bias vector of the last fully connected layer of size ( , ) and respectively. The size of the feature vector depends on the CNN architecture used.

In an end-to-end DNN [START_REF] He | Deep residual learning for image recognition[END_REF], a softmax function is applied to transform raw scores = ( 1 , 2 , ...,

) to probabilities = ( 1 , 2 , ..., ). This is the case for approaches such as [START_REF] Belouadah | Il2m: Class incremental learning with dual memory[END_REF][START_REF] Castro | End-to-end incremental learning[END_REF][START_REF] Hou | Learning a unified classifier incrementally via rebalancing[END_REF]. C can also be implemented using an external classifier. For instance, [START_REF] Rebuffi | icarl: Incremental classifier and representation learning[END_REF] and a variant of [START_REF] Hou | Learning a unified classifier incrementally via rebalancing[END_REF] use a Nearest-Class-Mean (NCM) as a classifier to compute class prediction based on the similarity of each test image to the average class feature computed from the available images in each state. Yet another choice [START_REF] Belouadah | Deesil: Deep-shallow incremental learning[END_REF] is to exploit a fixed deep representation to extract features for all incremental states and a battery of linear SVMs to implement C.

Loss function

A majority of existing IL algorithms [START_REF] Castro | End-to-end incremental learning[END_REF][START_REF] Hou | Learning a unified classifier incrementally via rebalancing[END_REF][START_REF] Javed | Revisiting distillation and incremental classifier learning[END_REF][START_REF] Wu | Large scale incremental learning[END_REF] alleviate the effects of catastrophic forgetting [START_REF] Mccloskey | Catastrophic interference in connectionist networks: The sequential learning problem[END_REF] by introducing a distillation term in the loss function [START_REF] Castro | End-to-end incremental learning[END_REF][START_REF] Rebuffi | icarl: Incremental classifier and representation learning[END_REF]. In general, this function takes the following form:

L = × L + (1 -) × L (3)
where L and L are classical cross-entropy and distillation terms, respectively.

∈ [0, 1] is a hyper-parameter that provides the weight of each loss term.

Cross-Entropy Loss in the state S is computed for all past and new classes and is given by :

L (x) = ∑ (x, ) ∈ D ∪K ∑ =1 -= [ (x)] (4)
where is the indicator function.

Distillation Loss in the state S is computed for past classes and is given by:

L (x) = ∑ (x, ) ∈ D ∪K -1 ∑ =1 -Φ -1 (x) [Φ (x)] ( 5
)
where Φ is the softened softmax applied on the raw scores predicted by the network. The softened score of the ℎ class in state S is:

Φ (x) = (x)∕T ∑ =1 (x)∕T ( 6
)
where T is a temperature scalar. L was originally introduced to improve performance when no memory of past classes is available [START_REF] Li | Learning without forgetting[END_REF]. The authors of [START_REF] Rebuffi | Learning multiple visual domains with residual adapters[END_REF] adapted it for the case when a bounded memory K is allowed. Different flavors of distillation were later proposed in [START_REF] Castro | End-to-end incremental learning[END_REF][START_REF] Hou | Learning a unified classifier incrementally via rebalancing[END_REF][START_REF] Javed | Revisiting distillation and incremental classifier learning[END_REF][START_REF] Wu | Large scale incremental learning[END_REF].

Score bias correction

Recent works [START_REF] Belouadah | Il2m: Class incremental learning with dual memory[END_REF][START_REF] Belouadah | Scail: Classifier weights scaling for class incremental learning[END_REF][START_REF] Wu | Large scale incremental learning[END_REF] hypothesize that due to the limited memory of the past, IL is akin to imbalanced learning where the network is trained with enough images for the new classes but only a few ones for past classes.

These works handle catastrophic forgetting as an imbalance issue and thus make use of an additional bias removal layer R at the end of the model M . The layer takes the raw scores predicted by the classifier C and multiply those of new classes by a reducing factor to make them more comparable to those of past classes, giving a chance to the latter to be selected during inference.

R ∶ ℝ → ℝ ↦ R ( ) = [ ( 1 ), .., ( ), .., ( )] (7)
where:

( ) = if 1 ≤ ≤ -1 + if -1 < ≤ (8)
and are scaling factors. They differ from an approach to another.

[75] learns them using a validation set after fine-tuning the model.

2 [START_REF] Belouadah | Il2m: Class incremental learning with dual memory[END_REF] uses past classes' statistics to set the value of while zeroing , and the rectification aims to increase past classes' scores instead of decreasing those of new classes.

[84] aligns new classes' weights with those of past classes by setting to the mean norm of past class weights divided by the mean norm of new class weights. Finally, [START_REF] Belouadah | Scail: Classifier weights scaling for class incremental learning[END_REF] normalizes the weights matrix of C leading to an implicit change in the values of the scores .

Past memory management

The bounded memory K, which stores a partial view of past classes, is a central component of existing IL algorithms. Regardless of the state S , the same number of images |K | = |K|∕ is kept for each class . Because the memory capacity is bounded, the number of images for each past class is reduced at the end of each state to accommodate images from new classes. The representation of past classes is thus degraded since the number of images per class is progressively reduced. Consequently, the model is biased toward new classes and underfits past classes, a well-known effect of catastrophic forgetting [START_REF] Mccloskey | Catastrophic interference in connectionist networks: The sequential learning problem[END_REF].

The role of exemplar selection techniques is debated in literature [START_REF] Castro | End-to-end incremental learning[END_REF][START_REF] Liu | Mnemonics training: Multi-class incremental learning without forgetting[END_REF][START_REF] Rebuffi | Learning multiple visual domains with residual adapters[END_REF][START_REF] Wu | Large scale incremental learning[END_REF]. Notably, the authors of [START_REF] Castro | End-to-end incremental learning[END_REF][START_REF] Liu | Mnemonics training: Multi-class incremental learning without forgetting[END_REF] report similar results with herding-based and random selection of exemplars. We run extensive experiments with both methods and reach a different conclusion. This is a result of a different interpretation of herding definition. Both [START_REF] Castro | End-to-end incremental learning[END_REF] and [START_REF] Liu | Mnemonics training: Multi-class incremental learning without forgetting[END_REF] select exemplars statically using their similarity to the mean embedding of the class. We follow the original definition from [START_REF] Welling | Herding dynamical weights to learn[END_REF], also exploited in [START_REF] Rebuffi | icarl: Incremental classifier and representation learning[END_REF], and select each exemplar based on a dynamic mean computed at each step based on the exemplars which were already selected. The advantage of the original definition is that it provides a better approximation of the actual class center compared to a static selection. It consists in taking, for each class, the set of images having the closest mean to the real class mean. Exemplar means are computed on feature vectors extracted from the penultimate layer of the CNN. We also tried exemplar selection techniques inspired from active learning approaches such as: entropy [START_REF] Shannon | A mathematical theory of communication[END_REF], min margin [START_REF] Settles | Active learning literature survey[END_REF], coreset [START_REF] Sener | Active learning for convolutional neural networks: A core-set approach[END_REF], k-means [START_REF] Bodó | Active learning with clustering[END_REF]. Initial experiments showed that none of these techniques provide better performance than herding. Consequently, we do not report such results.

Fine-Tuning based IL algorithms

We compare recent class incremental algorithms and also adaptations of them, which combine components from different algorithms. An overview of the tested algorithms and of their characteristics is presented in Table 2. The model update for each incremental state is widely used in existing approaches. Distillation is also used by a majority of algorithms from literature to counter the effect of catastrophic forgetting. Bias removal aims at balancing predictions for past and new classes. It is deployed either as a complement to distillation [START_REF] Castro | End-to-end incremental learning[END_REF][START_REF] Rebuffi | icarl: Incremental classifier and representation learning[END_REF][START_REF] Wu | Large scale incremental learning[END_REF] or to replace it [START_REF] Belouadah | Il2m: Class incremental learning with dual memory[END_REF][START_REF] Belouadah | Scail: Classifier weights scaling for class incremental learning[END_REF]. Memory usage is compulsory for methods that rely heavily on exemplars of past classes. The dominant approach is based on model updating via fine-tuning to integrate new knowledge [START_REF] Belouadah | Il2m: Class incremental learning with dual memory[END_REF][START_REF] Belouadah | Scail: Classifier weights scaling for class incremental learning[END_REF][START_REF] Castro | End-to-end incremental learning[END_REF][START_REF] Hou | Learning a unified classifier incrementally via rebalancing[END_REF][START_REF] Wu | Large scale incremental learning[END_REF]. The performance of these algorithms depends heavily on the existence of a bounded memory of the past. We also present results with fixedrepresentation based algorithms [START_REF] Belouadah | Deesil: Deep-shallow incremental learning[END_REF][START_REF] Hayes | REMIND your neural network to prevent catastrophic forgetting[END_REF][START_REF] Hayes | Lifelong machine learning with deep streaming linear discriminant analysis[END_REF][START_REF] Rebuffi | icarl: Incremental classifier and representation learning[END_REF], which do not update the model but are also less dependent on memory.

LwF [START_REF] Li | Learning without forgetting[END_REF] uses distillation loss to encourage the model M to predict the same scores for past classes in the current state S than in the previous one. was designed to work without a memory of past classes. LwF constitutes the inspiration for all class IL algorithms [START_REF] Castro | End-to-end incremental learning[END_REF][START_REF] Hou | Learning a unified classifier incrementally via rebalancing[END_REF][START_REF] Javed | Revisiting distillation and incremental classifier learning[END_REF][START_REF] Wu | Large scale incremental learning[END_REF].

✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓ × × × × Distillation ✓ ✓ ✓ ✓ × × × ✓ × × × × × × × × Bias removal × ✓ ✓ ✓ × ✓ ✓ ✓ ✓ ✓ ✓ ✓ × × × × Memory usage NC NC C NC NC C C C C C C NC NC NC NC NC
iCaRL [START_REF] Rebuffi | icarl: Incremental classifier and representation learning[END_REF] exploits fine-tuning with distillation loss L to prevent catastrophic forgetting and a variant of Nearest-Class-Mean [START_REF] Mensink | Distancebased image classification: Generalizing to new classes at near-zero cost[END_REF] to counter imbalance between past and new classes. The main difference with is the introduction of a bounded memory to enable efficient replay.

LUCIR [START_REF] Hou | Learning a unified classifier incrementally via rebalancing[END_REF] is based on fine-tuning with an integrated objective function. Authors propose the following contributions: (1) cosine normalization to balance magnitudes of past and new classifiers (2) less forget constraint to preserve the geometry of past classes and (3) inter-class separation to maximize the distances between past and new classes. The combination of these contributions constitutes a more sophisticated take at countering catastrophic forgetting compared to the use of knowledge distillation from [START_REF] Castro | End-to-end incremental learning[END_REF][START_REF] Javed | Revisiting distillation and incremental classifier learning[END_REF][START_REF] Rebuffi | icarl: Incremental classifier and representation learning[END_REF]. We experiment with two versions of this approach:

•

-the original definition proposed by the authors where a Nearest-Class-Mean classifier is used. This version is functional in presence of a memory only, due to the need for exemplars to compute past class-mean..

•

-the network outputs are used for classification. This version can be deployed with or without a memory for the past.

FT [START_REF] Belouadah | Il2m: Class incremental learning with dual memory[END_REF][START_REF] Belouadah | Scail: Classifier weights scaling for class incremental learning[END_REF][START_REF] Rebuffi | icarl: Incremental classifier and representation learning[END_REF] is the plain use of vanilla fine-tuning. The model M is initialized with the weights of the previous model M -1 and only the cross-entropy loss L is used. constitutes the simplest way to update models in incremental learning. It is heavily affected by catastrophic forgetting if a bounded memory is not available [START_REF] Rebuffi | icarl: Incremental classifier and representation learning[END_REF] but becomes an interesting baseline if a memory is available [START_REF] Belouadah | Il2m: Class incremental learning with dual memory[END_REF].

FT [START_REF] Belouadah | Il2m: Class incremental learning with dual memory[END_REF][START_REF] Belouadah | Scail: Classifier weights scaling for class incremental learning[END_REF] is a version of which replaces the classifier C by a NEM classifier from [START_REF] Rebuffi | icarl: Incremental classifier and representation learning[END_REF]. is a modified version of in which the distillation loss L is ablated. FT can only be deployed if a bounded memory is allowed to alleviate catastrophic forgetting. FT [START_REF] Belouadah | Il2m: Class incremental learning with dual memory[END_REF][START_REF] Belouadah | Scail: Classifier weights scaling for class incremental learning[END_REF] is inspired by [START_REF] Castro | End-to-end incremental learning[END_REF]. A vanilla is first performed, followed by a balanced . This second step aims to reduce bias between past and new classes by training on a version of D , which stores the same number of images for past and new classes to obtain similar magnitudes for them. FT is also tributary to the fixed memory K because past exemplars are needed for the balancing step. In the absence of memory, this approach becomes equivalent to and is heavily affected by catastrophic forgetting.

BiC [START_REF] Wu | Large scale incremental learning[END_REF] adds a linear layer for bias removal which is trained separately from the rest of the model learned with cross-entropy and distillation losses. The objective of the supplementary layer is to reduce the magnitudes of predictions for new classes to make them more comparable to those of past classes. Since a validation set is needed to optimize the bias removal layer, BiC can only function if a memory K is available. We note that K needs to be large enough to obtain reliable parameter estimations.

ScaIL [START_REF] Belouadah | Scail: Classifier weights scaling for class incremental learning[END_REF] hypothesizes that the classification layer C learned when classes were first streamed and learned with all data can be reused later. The main challenge is that deep models M are updated between incremental states. Normalization of the initial C is proposed to mitigate the effect of model updates and make past and new classes' predictions comparable. ScaIL needs a bounded memory to keep trace of past classes in the embeddings. IL2M [START_REF] Belouadah | Il2m: Class incremental learning with dual memory[END_REF] uses past classes' statistics to reduce the prediction bias in favor of new classes. Past classes' scores are modified using the ratio between their mean classification score when learned initially in the state S and in the current state S . Furthermore, the ratio between the mean classification score over all classes in S and S is also used. This approach is also prone to catastrophic forgetting if no memory is allowed.

FT ℎ , inspired by imbalanced learning [START_REF] Buda | A systematic study of the class imbalance problem in convolutional neural networks[END_REF], it implements fine tuning followed by threshold calibration (also known as threshold moving or post scaling). Thresholding adjusts the decision threshold of the model by adding a calibration layer at the end of the model during inference to compensate the prediction bias in favor of new classes: and |D | is the total number of training examples in the state S . A memory of the past is needed to rectify past classes' scores. This method is also heavily dependant on the bounded memory.

FT

[8], FT 2 [START_REF] Belouadah | Scail: Classifier weights scaling for class incremental learning[END_REF], FT 2+ [START_REF] Belouadah | Scail: Classifier weights scaling for class incremental learning[END_REF][START_REF] Belouadah | Initial classifier weights replay for memoryless class incremental learning[END_REF], FT + [START_REF] Belouadah | Initial classifier weights replay for memoryless class incremental learning[END_REF], LwF [START_REF] Belouadah | Initial classifier weights replay for memoryless class incremental learning[END_REF], LwF 2 [START_REF] Belouadah | Initial classifier weights replay for memoryless class incremental learning[END_REF], and LwF [START_REF] Belouadah | Initial classifier weights replay for memoryless class incremental learning[END_REF], are methods built on top of and , in order to reduce the bias of the network towards new classes, where:

• -replaces the weights of past classes in the current state with their initial weights learned in the initial state with all available data.

• 2 -normalization that makes classifier weights more comparable across states.

• -standardization of last layer weights, in order to make them comparable.

•

-state mean calibration defined as:

′ = × (M ) (M ) (10)
(M ) and (M ) -means of top-1 predictions of models learned in the current state and the initial state of the ℎ class computed over their training sets.

The four components can be combined together, where first is applied, followed either by 2 or normalization, and finally followed by the state mean calibration . These methods are mostly interesting for IL without memory because they do not require the use of a past exemplars memory.

Fixed-Representation based IL algorithms

Fixed-Representation (FR) [START_REF] Rebuffi | icarl: Incremental classifier and representation learning[END_REF] exploits the initial model M 0 trained on the classes of S 0 and freezes all its layers except the classification one in later incremental states. The frozen model is a limitation but also an advantage in that it allows the reuse of initial classifier layers, learned with all images, throughout the entire incremental process. Unfortunately, the reuse of initial layers, is not done in [START_REF] Rebuffi | icarl: Incremental classifier and representation learning[END_REF] and results are suboptimal. The method does not need a bounded memory for the update.

DeeSIL [START_REF] Belouadah | Deesil: Deep-shallow incremental learning[END_REF] is a variant of in which the classification layer of DNNs is replaced by linear SVMs. DeeSIL is a straightforward application of a transfer learning [START_REF] Kornblith | Do better imagenet models transfer better?[END_REF][START_REF] Razavian | CNN features off-the-shelf: An astounding baseline for recognition[END_REF] scheme in an incremental context. The use of external classifiers is proposed because they are faster to optimize compared to an end-to-end . Deep-SLDA [START_REF] Hayes | Lifelong machine learning with deep streaming linear discriminant analysis[END_REF] defines the model as M ≡ ( (⋅)) where is the fixed upper part of the network and (⋅) is the output layer. Only (⋅) is trained across incremental states in a streaming manner, while (⋅) serves as a feature extractor. At each incremental state, -updates a class-specific running mean vector and a running shared covariance matrix among classes. During inference, it assigns an image to the closest Gaussian in feature space defined by the class mean vectors and the covariance matrix.

does not need to store past class data and it is thus functional in absence of memory.

REMIND [START_REF] Hayes | REMIND your neural network to prevent catastrophic forgetting[END_REF] shares the same definition of M as -, where (⋅) is the first fifteen convolutional and three down sampling layers, and (⋅) is the remaining two convolutional and one fully connected layers of a ResNet-18 [START_REF] He | Deep residual learning for image recognition[END_REF].

relies on Product Quantizer (PQ) [START_REF] Jégou | Product quantization for nearest neighbor search[END_REF] algorithm to store intermediate representations of images as compressed vectors for fast learning. The compact vectors are then reconstructed and replayed for memory consolidation. Note that compact vectors allow us to save much more past data than with raw images (for instance, all ILSVRC can fit in the memory when |K| = 20000).

Experimental setup

Experiments are done with all IL approaches presented in Sections 4 and 5. We also provide results with , a classical non-incremental training from scratch where all classes are learned with all their data. This algorithm is the upper bound for all class incremental approaches.

Datasets

Four datasets designed for object, face, and landmark recognition are used here. The choice of significantly different tasks is important to study the adaptability and robustness of the tested methods. The main dataset statistics are provided in Table 3.

• ILSVRC [START_REF] Russakovsky | Imagenet large scale visual recognition challenge[END_REF] is a subset of 1000 classes used in the challenges. It is constituted of leaves of the hierarchy which most often depicts specific visual concepts.

• VGGFACE2 [START_REF] Cao | Vggface2: A dataset for recognising faces across pose and age[END_REF] is designed for face recognition.

We selected 1000 classes having the largest number of associated images. Face cropping is done with MTCNN [START_REF] Zhang | Joint face detection and alignment using multitask cascaded convolutional networks[END_REF] before further processing.

• Google Landmarks [START_REF] Noh | Large-scale image retrieval with attentive deep local features[END_REF] (LANDMARKS below) is built for landmark recognition, and we selected 1000 classes having the largest number of associated images.

• CIFAR100 [START_REF] Krizhevsky | Learning multiple layers of features from tiny images[END_REF] is designed for object recognition and includes 100 basic level classes [START_REF] Rosch | Basic objects in natural categories[END_REF].

Experimental protocol

The experimental protocol is inspired by the one proposed in [START_REF] Rebuffi | icarl: Incremental classifier and representation learning[END_REF]. The most important parameters in IL are the number of states , and the size of the memory K, and we test three values for each one of them. First, we fix the number of states = 10 and vary the memory to include approximately 2%, 1%, 0.5% of the full training

Table 3

Main statistics for the evaluation datasets, is the mean number of images per class; and is the standard deviation of the distribution of the number of images per class.

sets. Memory sizes are thus |K| = {20000, 10000, 5000} for ILSVRC, |K| = {10000, 5000, 2500} for VGGFACE2, |K| = {8000, 4000, 2000} for LANDMARKS and |K| = {1000, 500, 250} for CIFAR100. Second, we fix the memory size |K| to include 0.5% of the full training sets and vary the number of states = {20, 50}. Here, we chose the smallest memory size because it represents the most challenging case when a memory is allowed. This is also the most interesting in practice since it requires a reduced resource to store past data. We report results with |K| = 0 separately since the absence of memory renders some of the algorithms completely inoperable while others are still working.

Implementation details

A ResNet-18 architecture [START_REF] He | Deep residual learning for image recognition[END_REF] with an SGD optimizer is used as a backbone for all the methods.

[23], - [START_REF] Hayes | Lifelong machine learning with deep streaming linear discriminant analysis[END_REF], [START_REF] Wu | Large scale incremental learning[END_REF] and [START_REF] Hou | Learning a unified classifier incrementally via rebalancing[END_REF] are run using the optimal parameters of the public implementations provided in the original papers.

[56] is run using the code from [START_REF] Hou | Learning a unified classifier incrementally via rebalancing[END_REF] since it provides better performance than the original implementation.

[36] is run using the code from [START_REF] Rebuffi | icarl: Incremental classifier and representation learning[END_REF], The SVMs in [START_REF] Belouadah | Deesil: Deep-shallow incremental learning[END_REF] are implemented using LinearSVC solver from Scikit-Learn toolbox [START_REF] Pedregosa | Scikit-learn: Machine learning in python[END_REF]. The SVMs were optimized using classical grid search as described in the original paper.

and its derivatives are based on the same fine-tuning backbone and are implemented in Pytorch [START_REF] Paszke | Automatic differentiation in pytorch[END_REF]. Training images are processed using randomly resized 224 × 224 crops, horizontal flipping, and are normalized afterward. Given the difference in scale and the number of images between CIFAR100 and the other datasets, we found that a different parametrization was needed for this dataset. Note that the parameters' values presented below are largely inspired by the original ones given in [START_REF] He | Deep residual learning for image recognition[END_REF].

For CIFAR100, the first non-incremental state and are run for 300 epochs with ℎ = 128, = 0.9 and ℎ = 0.0005. The is set to 0.1 and is divided by 10 when the error plateaus for 60 consecutive epochs. The incremental states of and are trained for 70 epochs with ℎ = 128, = 0.9 and ℎ = 0.0005. The learning rate is set to = 0.1∕ at the beginning of each incremental state S and is divided by 10 when the error plateaus for 15 consecutive epochs.

For ILSVRC, VGGFACE2 and LANDMARKS, the first non-incremental state and are run for 120 epochs with ℎ = 256, = 0.9 and ℎ = 0.0001. The is set to 0.1 and is divided by 10 when the error plateaus for 10 consecutive epochs. The incremental states of and are trained for 35 epochs with ℎ = 256, = 0.9 and ℎ = 0.0001. The learning rate is set to = 0.1∕ at the beginning of each incremental state S and is divided by 10 when the error plateaus for 5 consecutive epochs.

Dataset details and the code of all tested approaches and their adaptations are publicly available to facilitate reproducibility. 1

Evaluation measures

The main evaluation measure used here is the popular top-5 accuracy [START_REF] Russakovsky | Imagenet large scale visual recognition challenge[END_REF]. Following [START_REF] Castro | End-to-end incremental learning[END_REF], accuracy is averaged only for incremental states (i.e., excluding the initial, nonincremental state), which is not of interest from an IL perspective. The sizes of the past memory K and the number of states are varied to evaluate the robustness of algorithms.

Since a relatively large number of configurations is tested, it is convenient also to use a global measure. We use the incremental learning gap measure ( ) [START_REF] Belouadah | Scail: Classifier weights scaling for class incremental learning[END_REF], which computes the average performance gap between a classical learning and each IL configuration for each algorithm. is defined as:

= 1 × ∑ =1 - - (11)
where: is the number of tested configurations; is the top-5 score for each configuration;

is the upperbound accuracy of the dataset ( accuracy); is the maximum theoretical value obtainable for the measure ( = 100 here). Following [START_REF] Tamaazousti | Learning more universal representations for transfer-learning[END_REF], the denominator is introduced in order to ensure that no individual configuration has an exaggerated influence on the global score. Note that is related to the forgetting rate proposed in [START_REF] Liu | Mnemonics training: Multi-class incremental learning without forgetting[END_REF], which is actually the numerator of individual configurations from Equation 11.

Results and discussion

Incremental learning with memory

Table 4 presents the performance of all algorithms tested in all experimental configurations when using herding for exemplar selection. Both the number of incremental states and the bounded memory size |K| have a strong influence on results. The easiest configurations for all visual tasks are those including a large memory (|K| = 2%) and a small number of states ( = 10). Inversely, the most difficult configuration combines a low memory (|K| = 0.5%) and a large number of states ( = 50). This finding is intuitive insofar more exemplars for past classes enhance the quality of the replay for them, and a larger number of states makes IL more prone to catastrophic forgetting. However, the performance drop is more marked for the object recognition tasks (ILSVRC and CIFAR100) compared to face and landmark recognition (VGGFACE2 and LANDMARKS).

For instance, with = 10, the ILSVRC's accuracy drop for is of 5.8 points when moving from |K| = 2% to |K| = 0.5% while the corresponding drop for VGGFACE2 is only of 1.6 points and the one for LANDMARKS is only of 1.3 points. The latter two tasks are simpler, and a smaller amount of exemplars can thus represent past classes.

The increase of , the number of incremental states, also has a detrimental effect on performance. For fine-tuning based methods, the performance drop is explained by the fact that a larger number of retraining steps causes more information loss, and the effect of catastrophic forgetting is increased. Also important, for methods like , which need a validation set, the size of the latter becomes insufficient when increases. This insufficiency is clearly illustrated by results for |K| = 0.5% and = 50. In this configuration, performance drops more significantly than that of competing methods. The loss is most striking for CIFAR100, the smallest of all datasets tested, where a performance of only 19.6% is obtained compared to 50.5% for |K| = 0.5% and = 20. For fixed-representation methods, larger values of decrease performance because the size of the first non-incremental state becomes smaller. Consequently, the fixed representation obtained from this state has lower generalization power and is less transferable to later states.

None of the methods is best in all configurations tested. On aggregate, the best results are obtained with ℎ , with a = -3.62 points loss compared to , the classical learning upper-bound. The other methods with strong performance were all proposed recently:

[8] ( = -3.7),

[75] ( = -4.03) and [28] ( = -4.13). The analysis of individual configurations shows that has good performance in many of them. This method is best or second-best for the largest memory tested (|K| = 2%) and the smallest number of incremental states ( = 10). However, its performance drops faster for the other values of |K| and . This is explained by its dependency on a validation set whose size becomes insufficient when |K| is low, and is high.

The two variants have similar overall performance, with being globally better than . This result confirms the original findings reported in [START_REF] Hou | Learning a unified classifier incrementally via rebalancing[END_REF]. The implementation from the same paper [START_REF] Hou | Learning a unified classifier incrementally via rebalancing[END_REF] has significantly lower performance than the two versions of . The positive influence of inter-class separation and cosine normalization introduced in addition to standard knowledge distillation is thus confirmed.

Vanilla has lower performance than more recent methods but still much better than , contrary to the comparison presented in [START_REF] Rebuffi | icarl: Incremental classifier and representation learning[END_REF]. However, the original comparison in that paper was biased since used mem-ory while their version of was implemented without memory. All bias reduction methods applied to are beneficial, with ℎ being the best one followed closely by . , which exploits the external classifier from [START_REF] Rebuffi | icarl: Incremental classifier and representation learning[END_REF] also has interesting performance and outperforms and 2 . The lower performance of the last two methods is an effect of the fact that they are the most sensitive to memory reduction (|K| = 0.5%) and the growth of the number of states ( = 50). and , the fixed-representation based methods, behave worse than most -based approaches, with the only exception being that is globally better than . However, it is interesting to note that and have a low dependency on memory size, and their performance becomes competitive for |K| = 0.5%. In this latter setting, fine-tuning based methods suffer more from catastrophic forgetting since memory becomes insufficient for an efficient replay of past classes. Globally, has a better behavior compared to , especially for large scale datasets, and this confirms that the optimization of an external classifier is easier than that of the classification layer of a deep model. performs better than and for large datasets and has a better global score ( = -6.02 VS. = -7.62 and = -6.92 respectively). However, its performance drops significantly compared to when the number of states is increased from = 10 to = 20 and = 50.

For

Role of exemplar selection

As we mentioned, there is an ongoing debate concerning the effectiveness of herding-based versus random exemplar selection in IL [START_REF] Belouadah | Scail: Classifier weights scaling for class incremental learning[END_REF][START_REF] Castro | End-to-end incremental learning[END_REF][START_REF] Liu | Mnemonics training: Multi-class incremental learning without forgetting[END_REF]. We compare the two selection methods by providing results with random selection for the main algorithms evaluated here in Table 5. The obtained results indicate that herding has a positive effect on performance for most of algorithms, albeit with a variable difference with respect to random selection. The best results in Table 5 are obtained with , and which have very close performance. Among finetuning based methods, and are the methods which are least affected by the switch from herding to random exemplar selection. Both of these methods implement an end-to-end IL approach.

has a more significant performance drop because it makes use of a external classifier. This is a consequence of the fact that the classifiers are computed directly on the randomly selected exemplars.

Vanilla is more affected by the use of random selection than and . The use of distillation for past data partly compensates a poorer class representation with random exemplars. Since vanilla has a lower performance, algorithms which build on it are also negatively affected. Among them, is the least affected because it exploits the initial classifiers of past classes.

ℎ performance falls behind that of , , and with random exemplar selection because exemplars have a more prominent role for learning past classes' representations. Thresholding with prior class probabilities is less efficient on poorer past class models.

The use of random selection has a small effect on and because the exemplars are only used as negatives when new classifiers are trained. Their presence has a positive effect in that it allows a slightly better separation between new and past classes across IL states. According to the authors of , many herding strategies were deployed based on distance from current example, number of times a sample has been replayed, and the time since it was last replayed, but all of the tested methods performed nearly the same as random selection, with higher computational time.

Incremental learning without memory

In many applications, no memory of past classes is available. For instance, in medical data processing [START_REF] Venkatesan | A strategy for an uncompromising incremental learner[END_REF], this is often due to privacy issues. We study the behavior of the main algorithms which can be deployed in the absence of memory here. The following algorithms cannot be deployed: (1) all variants which exploit an external classifier since exemplars are not available to build the classifiers for past classes; [START_REF] Aljundi | Memory aware synapses: Learning what (not) to forget[END_REF] because it requires a validation set; [START_REF] Aljundi | Expert gate: Lifelong learning with a network of experts[END_REF] because it requires past exemplars for normalization; [START_REF] Aljundi | Task-free continual learning[END_REF] 2 because the mean scores of past classes cannot be computed in the current state.

Without memory, becomes , the method which inspired more recent works using distillation in IL.

, 2 , and test if the basic hypothesis of regarding the reuse of initial classifier weights applies to a method which integrates distillation. This use of initial weight leads to a 3 points gain compared to classical . Further 2 normalization in 2 is not efficient. However, standardization of weights in improves the results of with 3.9 points. implements a more sophisticated scheme to counter catastrophic forgetting by adding cosine normalization and interclass separation on top of knowledge distillation. The two additional components have a significant decisive role since they provide a 10 points gain compared to . Vanilla has no component to counter catastrophic forgetting and it has the worst overall performance. The use of initial classifiers of past classes in provides a very consequent gain over simple . The application of is much more efficient for compared to and even gives nearly the same results than , the best variant of . The [START_REF] Belouadah | Initial classifier weights replay for memoryless class incremental learning[END_REF]. This approach outperforms the other methods with a large margin.

Overall, the best results are obtained with the fixedrepresentation methods because their dependence on past exemplars is much lower compared to fine-tuning based methods. In order, the best global score is obtained by , -, and . As we mentioned, is easier to optimize compared to and has a comparable accuracy variation with -for most tested configurations. However, provides the best performance when no memory is allowed. The performance of fixed-representation methods drops when the number of incremental states increases because the initial state includes a lower number of classes. This is notably the case for CIFAR100, the smallest dataset tested, where the fixed-representations have lower performance compared to all variants of for all tested values. However, , , -and have consequently better performance for ILSVRC, VGGFACE2, and LANDMARKS where their initial representations are trained with at least 20 classes.

The analysis of individual datasets shows that variants have a strong performance for CIFAR100, the smallest one among the four tested.

scales worse than , which is better for the three larger datasets. The performance inversion is probably explained by the handling of inter-class separation in . This indicates that knowledge distillation alone does not scale well because when the number of past classes increases, the confusions between them hamper the performance of the method. Further analysis of this point is provided in Subsection 7.4.

Role of knowledge distillation

In [START_REF] He | Deep residual learning for image recognition[END_REF], authors hypothesize that distillation is useful when the teacher model is trained with a large and balanced dataset. This is not the case in IL due to the fact that the dataset progressively includes knowledge about more classes and that there is an imbalance between past and new classes. In spite of this observation, knowledge distillation is commonly used to tackle catastrophic forgetting [START_REF] Castro | End-to-end incremental learning[END_REF][START_REF] He | Exemplar-supported generative reproduction for class incremental learning[END_REF][START_REF] Javed | Revisiting distillation and incremental classifier learning[END_REF][START_REF] Kim | Incremental learning with maximum entropy regularization: Rethinking forgetting and intransigence[END_REF][START_REF] Parisi | Continual lifelong learning with neural networks: A review[END_REF][START_REF] Rebuffi | Learning multiple visual domains with residual adapters[END_REF][START_REF] Zhou | M2KD: multi-model and multi-level knowledge distillation for incremental learning[END_REF]. Its use in IL with memory was encouraged by the experimental results presented in the influential paper [START_REF] Rebuffi | Learning multiple visual domains with residual adapters[END_REF]. There, the original comparison between and was not fair since the first method is implemented without memory, while the second exploits a memory of the past. The results reported in Table 4 for vanilla and methods built on top of it challenge the assumption that distillation loss L is necessary in IL with memory. These experiments show that is globally better since the score is over 2 points smaller than that of . is more effective for ILSVRC and VGGFACE2 datasets only for a small number of incremental states ( = 10) and the smallest memory (|K| = {1%, 0.5%}).

is a version of without distillation. The results from Table 4 show that the use of the NEM classification layer further improves performance compared to vanilla fine-tuning.

When no memory is allowed for past classes, the experiments reported in Table 6 confirm those presented in [START_REF] Rebuffi | icarl: Incremental classifier and representation learning[END_REF]. There, is clearly better than vanilla , and the usefulness of distillation is confirmed. Even without memory, the reuse of the weights of past classes from their initial states in is better than the sole use of knowledge distillation in [START_REF] Li | Learning without forgetting[END_REF]. Only a more sophisticated scheme which combines distillation and an inter-class separation component in [START_REF] Hou | Learning a unified classifier incrementally via rebalancing[END_REF] outperforms , but stays way below + that does not need distillation. Instead, it makes use of initial weights combined with standardization of all weights and mean state calibration. In Table 7, we present the distribution of correct and erroneous predictions across incremental states to have a better understanding of the behavior of distillation in IL. Results are given for [START_REF] Li | Learning without forgetting[END_REF], [START_REF] Hou | Learning a unified classifier incrementally via rebalancing[END_REF] and of past classes increases. If an error is made while training the model M 1 using the activations of M 0 as soft targets, it will be passed on to all the subsequent incremental states. Consequently, the percentage of ( , ) errors in Table 7 increases in later incremental states. However, the percentage of ( , ) errors is smaller for and compared to 2 indicating that distillation has a positive effect of past classes. The addition of the interclass separation in removes a part of ( , ), and the overall increases significantly ( ), the number of correct predictions for past classes. We note that, since distillation operates on past class scores, the bias in favor of new classes is not handled by and . Consequently, ( , ) is the main type of error for the distillation-based methods. This is explained in [START_REF] Belouadah | Il2m: Class incremental learning with dual memory[END_REF][START_REF] Belouadah | Scail: Classifier weights scaling for class incremental learning[END_REF][START_REF] Wu | Large scale incremental learning[END_REF] by the fact that the model is biased towards new classes, leading to predict past images as belonging to new classes. This bias is caused by the fact that new classes are well learned with all their data.

In Table 6, the comparison of , and

2 for = 10 shows that has the lowest and highest performance for ILSVRC and CIFAR100 respectively. The detailed view in Table 7 gives further insights into the structure of results. ( ) is higher and ( , ) is lower for CIFAR100 compared to ILSVRC, indicating that distillation is much more efficient at a smaller scale. We conclude that distillation is not always useful in IL. The performance of distilled networks depends on the size of the dataset, the number of incremental states, and the presence or not of the bounded memory of the past. It should be used only when the incremental task is known to be characterized by a favorable combination of these parameters.

Additional experiment

We present a supplementary experiment which compares the performance of a very recent Neural Gas (NG) based approach to that of other methods. TOpology-Preserving knowledge InCrementer [START_REF] Tao | Few-shot class-incremental learning[END_REF] relies on the NG network to preserve the feature space topology using a Hebbian learning [START_REF] Martinetz | Competitive hebbian learning rule forms perfectly topology preserving maps[END_REF]. Two variants of are tested: (1) TOPIC-AL -uses an Anchor Loss to stabilize the NG network in order to preserve past knowledge and (2) TOPIC-AL-MML -uses an Anchor Loss and also a Min-Max Loss to control the network growth while adapting it to new knowledge. They are compared to , ℎ , , , , and . Note that we use a single dataset because the authors of [START_REF] Tao | Few-shot class-incremental learning[END_REF] did not provide their complete code and, while we tried to reproduce their results independently, that was not possible. 2 2 Following [START_REF] Tao | Few-shot class-incremental learning[END_REF], we use IMAGENET100 [START_REF] Russakovsky | Imagenet large scale visual recognition challenge[END_REF] [START_REF] Tao | Few-shot class-incremental learning[END_REF], where was found to have better performance. This difference is probably explained in part by method parametrization choices and in part by the fact that herding was not exploited for , and . We used the original parameters for the methods compared to in Table 8. The use of herding is beneficial for all methods compared to , with important impact for ℎ , and and lower impact for variants.

is not affected by the use of herding since this selection is done by the neural gas component. Globally, the results from Table 8 show that, while interesting, the recent adaptation of neural gas approaches to class IL lags well behind the best methods tested in this work.

Conclusion and perspectives

We presented a comparison of class IL algorithms. An analysis based on six desirable properties shows that none of the studied groups is best adapted in all applications. We then proposed a formalization of methods that are designed to cope with constant model complexity and with bounded or no memory of past classes. A selection of recently proposed algorithms is then presented and evaluated thoroughly. The evaluation confirms that no algorithm is best in all configurations.

When a memory is allowed, the best global result is obtained when incremental learning is cast as a kind of imbalanced learning. This type of approach implements a vanilla backbone followed by a bias rectification layer. It is especially useful in the most challenging conditions (low memory and many incremental states). If enough memory is available, and the number of incremental states is low, distillation based approaches become competitive. The choice of the method will thus depend on the computation and storage capacities but also on the expected characteristics of the data stream, which needs to be processed.

When no memory is allowed, fixed-representation meth-ods are globally much more competitive than fine-tuning ones while also being simpler and faster to deploy. They are particularly advantageous for large datasets, where distillation-based methods fail to scale-up. This finding is surprising insofar fixed-representation methods exploit a classical transfer learning scheme [START_REF] Kornblith | Do better imagenet models transfer better?[END_REF][START_REF] Razavian | CNN features off-the-shelf: An astounding baseline for recognition[END_REF]. They do not update models across incremental states and were considered less apt for usage in IL without memory [START_REF] Rebuffi | icarl: Incremental classifier and representation learning[END_REF]. We note that these methods work better than distillation based IL algorithms even when initial representations are learned with a few dozens of classes. Online learning methods [START_REF] Hayes | REMIND your neural network to prevent catastrophic forgetting[END_REF][START_REF] Hayes | Lifelong machine learning with deep streaming linear discriminant analysis[END_REF] are useful when the stream of data arrives image per image. The model capacity to learn individual classes is increased continuously as new images appear. They are fast to train and well adapted to embedded systems because they have low memory footprint.

For fairness, we evaluated fixed-representation based and fine-tuning based methods with the same initial representation. If a larger pool of classes is available at the beginning of the process, the performance of fixedrepresentations will be boosted because the initial representation generalizes better [START_REF] Belouadah | Deesil: Deep-shallow incremental learning[END_REF]. However, fixed-representations work well only if the task does not change over time, as it is the case in the evaluated scenarios presented in [START_REF] Aljundi | Memory aware synapses: Learning what (not) to forget[END_REF].

The evaluation is done with four different datasets dedicated to distinct visual tasks. This setting can be reused and enriched to ensure a robust testing of class incremental algorithms. We will release the detailed implementations of all presented methods to facilitate reproducibility.

The comparison presented here shows that recently proposed approaches reduce the performance gap between nonincremental and incremental learning processes. The analysis of existing algorithms proposed here highlights a series of open problems which could be investigated in the future. First, handling class IL as an imbalanced learning problem provides very interesting results with [START_REF] Wu | Large scale incremental learning[END_REF] or without [START_REF] Belouadah | Scail: Classifier weights scaling for class incremental learning[END_REF] the use of a distillation component. Here, we introduced a competitive method where classification bias in favor of new classes is reduced by using prior class probabilities [START_REF] Buda | A systematic study of the class imbalance problem in convolutional neural networks[END_REF]. It would be interesting to investigate more sophisticated bias reduction schemes to improve performance further. Second, a more in-depth investigation of why distillation fails to work for large scale datasets is needed. The empirical findings reported here should be complemented with a more theoretical analysis to improve its usefulness. Already, the addition of inter-class separation from [START_REF] Hou | Learning a unified classifier incrementally via rebalancing[END_REF] is promising. More powerful distillation formulations, such as the relational knowledge distillation [START_REF] Park | Relational knowledge distillation[END_REF], also hold promise. Third, the results obtained with herding based selection of exemplars are better compared to a random selection for all methods tested. Further work in this direction could followup on [START_REF] Liu | Mnemonics training: Multi-class incremental learning without forgetting[END_REF] and investigate in more depth which exemplar distribution is optimal for replay. Finally, the evaluation scenario should be made more realistic by: (1) dropping the strong hypothesis that new data are readily annotated when they are streamed; (2) using a variable number of classes for the incremental states and (3) working with imbalanced datasets, which are more likely to occur in real-life applications than the controlled datasets tested until now.

  and for ILSVRC and CIFAR100 with = 10 and |K| = 0. ( ) and ( ) are the correct classification for past/new classes. ( , ) and ( , ) are erroneous classifications for test samples of past classes mistaken for other past classes and new classes respectively. ( , ) and ( , ) are erroneous classifications for test samples of new classes mistaken for past classes and other new classes respectively. Since the number of test images varies across IL states, percentages are calculated separately for test images of past and new classes in each S to get a quick view of the relative importance of each type of errors. ( ), ( , ), and( , ) sum to 100% on each column, as do ( ), ( , ), and ( , ).

  , a subset of 100 classes extracted from the ILSVRC dataset, where each class contains 500 training images and 100 test images. To start with a good data representation, the first model M 0 is trained on 0 = 60 initial classes. The remaining 40 classes are divided in 8 incremental states containing each = 5 new classes. The past classes' memory is set to |K >0 | = 400 + 4 × ( -0 ), IL Method ℎ TOPIC-AL TOPIC-AL-MML Random 23.0 32.

Table 2

 2 Main characteristics of tested approaches: model update -indicates if the model is trained for each incremental state; distillation -if this part of the loss is exploited to control catastrophic forgetting; bias removal -is a separate component which is specifically dedicated to balancing results between past and new classes, and memory usage -if this component is compulsory (C) or not (NC). * refers to all methods built on top of .

Table 4

 4 Top-5 average incremental accuracy (%) for IL methods with herding using different memory sizes and numbers of IL states. Best results are in bold.

	States Dataset |K| 2 ℎ 2	= 10 2% LANDMARKS 1% 0.5% 79.3 76.5 71.0 96.0 95.3 93.9 95.1 94.0 91.8 66.5 56.1 47.9 ILSVRC VGGFACE2 CIFAR100 2% 1% 0.5% 2% 1% 0.5% 2% 1% 0.5% 79.9 76.4 72.6 97.2 96.9 96.5 97.2 96.6 96.1 79.8 75.4 69.9 80.5 80.0 79.4 96.2 96.0 95.7 95.4 94.9 94.4 82.6 80.8 78.8 79.4 74.4 65.9 96.4 94.5 91.3 96.6 94.7 91.4 82.4 77.9 70.7 81.4 79.0 75.0 96.4 95.4 94.0 96.1 94.6 92.6 85.1 81.7 76.0 84.0 80.9 76.5 97.0 95.7 92.4 96.9 95.3 92.2 80.0 74.0 69.0 85.5 82.8 79.7 97.3 96.6 95.7 97.9 97.3 96.6 88.8 87.6 83.5 82.0 79.8 76.6 96.5 95.8 95.2 97.3 96.0 94.0 85.6 83.2 79.1 80.9 78.1 73.9 96.7 95.4 93.4 96.5 94.7 92.5 81.8 77.0 71.2 84.3 82.1 78.3 97.2 96.3 94.8 97.2 95.8 94.0 86.4 83.9 79.1 79.2 76.5 73.0 95.9 95.2 94.6 97.0 95.5 92.7 83.4 80.5 75.2 76.7 76.6 76.4 91.7 91.5 89.7 93.8 93.5 93.5 79.5 79.4 78.7 75.5 75.1 74.3 92.7 92.5 92.2 94.0 93.7 93.2 66.9 65.8 64.2 80.9 80.7 78.2 94.7 93.2 93.0 96.3 95.8 94.7 60.7 60.7 60.7	|K| = 0.5% VGGFACE2 LANDMARKS T=20 T=50 T=20 T=50 T=20 T=50 ILSVRC 55.9 45.0 88.5 78.2 86.8 82.4 63.9 55.3 93.5 88.3 93.7 90.5 73.6 66.3 92.7 87.9 91.9 89.8 69.4 64.3 91.6 89.2 90.9 89.0 76.5 69.0 94.0 91.1 91.9 89.9 75.9 67.1 92.3 89.5 91.2 88.9 74.6 63.9 92.3 85.3 94.7 90.5 76.6 70.9 95.0 92.4 92.6 90.4 70.9 60.6 92.5 88.4 90.8 88.1 78.6 71.2 94.3 91.6 92.9 90.7 73.6 67.3 94.6 91.4 91.2 88.5 69.2 58.2 85.8 75.2 89.3 82.8 73.0 58.1 87.2 80.0 90.5 85.1 73.9 65.0 87.4 80.1 92.8 88.6	CIFAR100 T=20 T=50 35.5 35.4 53.5 47.9 69.0 63.0 64.3 54.8 68.8 55.9 62.9 54.2 50.5 19.6 69.8 51.0 61.5 51.0 71.4 57.9 63.6 44.1 62.3 33.5 63.9 44.0 52.8 46.4	-7.36 -4.13 -4.33 -5.19 -4.28 -4.70 -4.03 -3.70 -4.95 -3.62 -4.43 -7.62 -6.92 -6.02
		92.3	99.2	99.1	91.2	92.3	99.2	99.1	91.2	-
	States Dataset |K| 2 ℎ	= 10 2% LANDMARKS 1% 0.5% 77.9 73.0 65.3 95.3 93.8 91.1 93.9 91.4 87.4 64.5 53.4 43.9 ILSVRC VGGFACE2 CIFAR100 2% 1% 0.5% 2% 1% 0.5% 2% 1% 0.5% 79.8 75.9 72.2 97.3 97.0 96.6 97.1 96.4 96.0 78.6 73.9 67.5 77.0 70.1 60.0 96.0 94.1 90.7 95.8 93.2 89.1 80.0 73.7 63.3 85.0 82.4 78.6 97.3 96.8 96.1 97.8 97.2 96.4 88.2 86.5 82.6 81.0 78.2 75.1 96.4 95.6 94.5 96.9 95.3 92.7 84.6 81.1 74.9 78.3 75.2 71.2 96.2 94.9 92.2 95.8 93.6 90.1 79.0 73.9 64.7 82.0 78.6 74.1 96.7 95.6 93.4 96.6 94.7 91.9 84.2 79.9 72.7 74.4 74.3 74.3 83.3 83.3 83.2 93.1 93.1 92.6 78.6 78.6 78.0 74.5 74.3 74.2 92.6 92.5 92.2 93.9 93.6 92.9 66.5 65.2 63.7	|K| = 0.5% VGGFACE2 LANDMARKS T=20 T=50 T=20 T=50 T=20 T=50 ILSVRC 51.3 40.9 84.3 73.2 81.9 76.4 62.4 52.9 93.5 87.8 93.2 89.2 64.5 59.2 90.8 86.5 87.8 85.5 72.1 59.9 92.0 82.9 93.8 88.1 73.9 68.3 94.5 90.5 90.7 88.2 66.1 55.6 91.1 85.3 87.6 84.3 73.8 66.4 92.9 88.8 90.0 87.3 66.9 54.4 76.2 49.5 84.4 71.8 69.0 58.0 87.2 78.9 90.6 84.8	CIFAR100 T=20 T=50 32.6 33.4 50.4 44.3 59.9 49.4 54.2 18.1 67.9 47.7 58.1 46.3 67.1 52.7 58.8 28.8 63.4 42.5	-9.51 -4.36 -6.40 -4.42 -4.41 -6.22 -4.85 -12.41 -7.09
		92.3	99.2	99.1	91.2	92.3	99.2	99.1	91.2	-

Table 5

 5 Top-5 average incremental accuracy (%) for the main methods with random selection of exemplars for different memory sizes and numbers of IL states. Best results are in bold.

Table 6

 6 Top-5 average incremental accuracy (%) for IL methods without memory for past classes and different numbers of IL states. Best results are in bold.

	use of 2 normalization in with 2 points, while adding the mean state cal-2 improves the results of ibration in further gains another 1 points 2+ over 2 . The best fine tuning based approach without memory is

+ from

Table 8

 8 Top-1 average incremental accuracy for IL methods for IMAGENET100 with 60 initial classes and 8 incremental states containing each 5 classes ( = 9, 0 = 60, =1..8 = 5). The best result is in bold.where 400 images are divided equally between the first state classes, and 4 images per class are used for the classes that do not belong to the first state.Table8provides top-1 accuracy of classical class IL ap-

	proaches results of IMAGENET100. Results indicate that , ℎ , , , the NG-based incremental learner, for and , and also is the best approach, followed by , , , , ℎ and . The two variants of pro-vide very similar performances with -being marginally better. These results are different from those re-ported in

https://github.com/EdenBelouadah/ class-incremental-learning

[START_REF] Belouadah | Scail: Classifier weights scaling for class incremental learning[END_REF] which implement classical distillation, featuresbased distillation plus inter-class separation and the reuse of L2-normalized initial classifier weights, respectively. The authors of[START_REF] Javed | Revisiting distillation and incremental classifier learning[END_REF] noted that distillation induces a bias among past classes, which leads to confusion between their predictions. This finding is confirmed by the large number of past-past class confusions ( , ) associated to in Table 7. When advancing in incremental states, the number

We hope that the code will be made available and, in that case, we will incorporate results obtained with in the full experiment.

Table 7

Top-1 correct and wrong classification for ,

Declaration of interests

x The authors declare that they have no known competing financial interests or personal relationships that could have appeared to influence the work reported in this paper.

☐The authors declare the following financial interests/personal relationships which may be considered as potential competing interests: • Incremental learning algorithms are improved by casting the problem as an imbalanced learning case.

• Competitive performance can be achieved without the widely used knowledge distillation component.

• Herding-based exemplar selection for past classes clearly outperforms random selection.

• Fine-tuning based methods are better when a memory of the past is allowed.

• Fixed-representation based methods are better without a memory of the past.