Original: I NCREMENTAL FEW - SHOT LEARNING VIA VECTOR QUANTIZATION IN DEEP EMBEDDED SPACE
Revised: I NCREMENTAL FEW - SHOT LEARNING VIA VECTOR QUANTIZATION IN DEEP EMBEDDED SPACE

Original: A BSTRACT
Revised: A BSTRACT

Original: The capability of incrementally learning new tasks without forgetting old ones is a challenging problem due to catastrophic forgetting.
Revised: The capability of incrementally learning new tasks without forgetting old ones is a challenging problem due to catastrophic forgetting.

Original: This challenge becomes greater when novel tasks contain very few labelled training samples.
Revised: This challenge becomes greater when novel tasks contain very few labelled training samples.

Original: Currently, most methods are dedicated to class-incremental learning and rely on sufﬁcient training data to learn additional weights for newly added classes.
Revised: Currently, most methods are dedicated to class-incremental learning and rely on sufﬁcient training data to learn additional weights for newly added classes.

Original: Those methods cannot be easily extended to incremental regression tasks and could suffer from severe overﬁtting when learning few-shot novel tasks.
Revised: Those methods cannot be easily extended to incremental regression tasks and could suffer from severe overﬁtting when learning few-shot novel tasks.

Original: In this study, we propose a nonparametric method in deep embedded space to tackle incremental few-shot learning problems.
Revised: In this study, we propose a nonparametric method in deep embedded space to tackle incremental few-shot learning problems.

Original: The knowledge about the learned tasks is compressed into a small number of quantized reference vectors.
Revised: The knowledge about the learned tasks is compressed into a small number of quantized reference vectors.

Original: The proposed method learns new tasks sequentially by adding more reference vectors to the model using few-shot samples in each novel task.
Revised: The proposed method learns new tasks sequentially by adding more reference vectors to the model using few-shot samples in each novel task.

Original: For classiﬁcation problems, we employ the nearest neighbor scheme to make classiﬁcation on sparsely available data and incorporate intra-class variation, less forgetting regularization and calibration of reference vectors to mitigate catastrophic forgetting.
Revised: For classiﬁcation problems, we employ the nearest neighbor scheme to make classiﬁcation on sparsely available data and incorporate intra-class variation, less forgetting regularization and calibration of reference vectors to mitigate catastrophic forgetting.

Original: In addition, the proposed learning vector quantization (LVQ) in deep embedded space can be customized as a kernel smoother to handle incremental few-shot regression tasks.
Revised: In addition, the proposed learning vector quantization (LVQ) in deep embedded space can be customized as a kernel smoother to handle incremental few-shot regression tasks.

Original: Experimental results demonstrate that the proposed method outperforms other state-of-the-art methods in incremental learning.
Revised: Experimental results demonstrate that the proposed method outperforms other state-of-the-art methods in incremental learning.

Original:  I NTRODUCTION
Revised:  I NTRODUCTION

Original: Incremental learning is a learning paradigm that allows the model to continually learn new tasks on novel data, without forgetting how to perform previously learned tasks (Cauwenberghs & Poggio, 2001; Kuzborskij et al., 2013; Mensink et al., 2013).
Revised: Incremental learning is a learning paradigm that allows the model to continually learn new tasks on novel data, without forgetting how to perform previously learned tasks (Cauwenberghs & Poggio, 2001; Kuzborskij et al., 2013; Mensink et al., 2013).

Original: The capability of incremental learning becomes more important in real-world applications, in which the deployed models are exposed to possible out-of-sample data.
Revised: The capability of incremental learning becomes more important in real-world applications, in which the deployed models are exposed to possible out-of-sample data.

Original: Typically, hundreds of thousands of labelled samples in new tasks are required to re-train or ﬁne-tune the model (Rebufﬁ et al., 2017).
Revised: Typically, hundreds of thousands of labelled samples in new tasks are required to re-train or ﬁne-tune the model (Rebufﬁ et al., 2017).

Original: Unfortunately, it is impractical to gather sufﬁcient samples of new tasks in real applications.
Revised: Unfortunately, it is impractical to gather sufﬁcient samples of new tasks in real applications.

Original: In contrast, humans can learn new concepts from just one or a few examples, without losing old knowledge.
Revised: In contrast, humans can learn new concepts from just one or a few examples, without losing old knowledge.

Original: Therefore, it is desirable to develop algorithms to support incremental learning from very few samples.
Revised: Therefore, it is desirable to develop algorithms to support incremental learning from very few samples.

Original: While a natural approach for incremental few-shot learning is to ﬁne-tune part of the base model using novel training data (Donahue et al., 2014; Girshick et al., 2014), the model could suffer from severe over-ﬁtting on new tasks due to a limited number of training samples.
Revised: While a natural approach for incremental few-shot learning is to ﬁne-tune part of the base model using novel training data (Donahue et al., 2014; Girshick et al., 2014), the model could suffer from severe over-ﬁtting on new tasks due to a limited number of training samples.

Original: Moreover, simple ﬁne-tuning also leads to signiﬁcant performance drop on previously learned tasks, termed as catastrophic forgetting (Goodfellow et al., 2014).
Revised: Moreover, simple ﬁne-tuning also leads to signiﬁcant performance drop on previously learned tasks, termed as catastrophic forgetting (Goodfellow et al., 2014).

Original: Recent attempts to mitigate the catastrophic forgetting are generally categorized into two streams: memory relay of old training samples (Rebufﬁ et al., 2017; Shin et al., 2017; Kemker & Kanan, 2018) and regularization on important model parameters (Kirkpatrick et al., 2017; Zenke et al., 2017).
Revised: Recent attempts to mitigate the catastrophic forgetting are generally categorized into two streams: memory relay of old training samples (Rebufﬁ et al., 2017; Shin et al., 2017; Kemker & Kanan, 2018) and regularization on important model parameters (Kirkpatrick et al., 2017; Zenke et al., 2017).

Original: However, those incremental learning approaches are developed and tested on unrealistic scenarios where sufﬁcient training samples are available in novel tasks.
Revised: However, those incremental learning approaches are developed and tested on unrealistic scenarios where sufﬁcient training samples are available in novel tasks.

Original: They may not work well when the training samples in novel tasks are few (Tao et al., 2020b).
Revised: They may not work well when the training samples in novel tasks are few (Tao et al., 2020b).

Original: To the best of our knowledge, the majority of incremental learning methodologies focus on classiﬁcation problems and they cannot be extended to regression problems easily.
Revised: To the best of our knowledge, the majority of incremental learning methodologies focus on classiﬁcation problems and they cannot be extended to regression problems easily.

Original: In class-incremental learning, the model has to expand output dimensions to learn N (cid:48) novel classes while keeping the knowledge of existing N classes.
Revised: In class-incremental learning, the model has to expand output dimensions to learn N (cid:48) novel classes while keeping the knowledge of existing N classes.

Original: Parametric models estimate additional classiﬁcation weights for novel classes, while nonparametric methods compute the class centroids for novel classes.
Revised: Parametric models estimate additional classiﬁcation weights for novel classes, while nonparametric methods compute the class centroids for novel classes.

Original: In comparison, output dimensions in regression problems do not change in incremental learning as neither additional weights nor class centroids are applicable to regression problems.
Revised: In comparison, output dimensions in regression problems do not change in incremental learning as neither additional weights nor class centroids are applicable to regression problems.

Original: Besides, we ﬁnd that catastrophic forgetting in incremental few-shot classiﬁcation can be attributed to three reasons.
Revised: Besides, we ﬁnd that catastrophic forgetting in incremental few-shot classiﬁcation can be attributed to three reasons.

Original: First, the model is biased towards new classes and forgets old classes because the model is ﬁne-tuned on new data only (Hou et al., 2019; Zhao et al., 2020).
Revised: First, the model is biased towards new classes and forgets old classes because the model is ﬁne-tuned on new data only (Hou et al., 2019; Zhao et al., 2020).

Original: Meanwhile, the prediction accuracy on novel classes is not good due to over-ﬁtting on few-shot training samples.
Revised: Meanwhile, the prediction accuracy on novel classes is not good due to over-ﬁtting on few-shot training samples.

Original: Second, features of novel samples could overlap with those of old classes in the feature space, leading to ambiguity among classes in the feature space.
Revised: Second, features of novel samples could overlap with those of old classes in the feature space, leading to ambiguity among classes in the feature space.

Original: Finally, features of old classes and classiﬁcation weights are no longer compatible after the model is ﬁne-tuned with new data.
Revised: Finally, features of old classes and classiﬁcation weights are no longer compatible after the model is ﬁne-tuned with new data.

Original: In this paper, we investigate the problem of incremental few-shot learning, where only a few training samples are available in new tasks.
Revised: In this paper, we investigate the problem of incremental few-shot learning, where only a few training samples are available in new tasks.

Original: A uniﬁed model is learned sequentially to jointly recognize all classes or regression targets that have been encountered in previous tasks (Rebufﬁ et al., 2017;
Revised: A uniﬁed model is learned sequentially to jointly recognize all classes or regression targets that have been encountered in previous tasks (Rebufﬁ et al., 2017;

Original: Wu et al., 2019).
Revised: Wu et al., 2019).

Original: To tackle aforementioned problems, we propose a nonparametric method to handle incremental few-shot learning based on learning vector quantization (LVQ) (Sato & Yamada, 1996) in deep embedded space.
Revised: To tackle aforementioned problems, we propose a nonparametric method to handle incremental few-shot learning based on learning vector quantization (LVQ) (Sato & Yamada, 1996) in deep embedded space.

Original: As such, the adverse effects of imbalanced weights in a parametric classiﬁer can be completely avoided (Mensink et al., 2013; Snell et al., 2017; Yu et al., 2020).
Revised: As such, the adverse effects of imbalanced weights in a parametric classiﬁer can be completely avoided (Mensink et al., 2013; Snell et al., 2017; Yu et al., 2020).

Original: Our contributions are three fold.
Revised: Our contributions are three fold.

Original: First, a uniﬁed framework is developed, termed as incremental deep learning vector quantization (IDLVQ), to handle both incremental classiﬁcation (IDLVQ-C) and regression (IDLVQ-R) problems.
Revised: First, a uniﬁed framework is developed, termed as incremental deep learning vector quantization (IDLVQ), to handle both incremental classiﬁcation (IDLVQ-C) and regression (IDLVQ-R) problems.

Original: Second, we develop intra-class variance regularization, less forgetting constraints and calibration factors to mitigate catastrophic forgetting in class-incremental learning.
Revised: Second, we develop intra-class variance regularization, less forgetting constraints and calibration factors to mitigate catastrophic forgetting in class-incremental learning.

Original: Finally, the proposed methods achieve state-of-the-art performance on incremental fewshot classiﬁcation and regression datasets.
Revised: Finally, the proposed methods achieve state-of-the-art performance on incremental fewshot classiﬁcation and regression datasets.

Original:  R ELATED W ORK
Revised:  R ELATED W ORK

Original: Incremental learning: Some incremental learning approaches rely on memory replay of old exemplars to prevent forgetting previously learned knowledge.
Revised: Incremental learning: Some incremental learning approaches rely on memory replay of old exemplars to prevent forgetting previously learned knowledge.

Original: Old exemplars can be saved in memory (Rebufﬁ et al., 2017; Castro et al., 2018; Prabhu et al., 2020) or sampled from generative models (Shin et al., 2017; Kemker & Kanan, 2018; van de Ven et al., 2020).
Revised: Old exemplars can be saved in memory (Rebufﬁ et al., 2017; Castro et al., 2018; Prabhu et al., 2020) or sampled from generative models (Shin et al., 2017; Kemker & Kanan, 2018; van de Ven et al., 2020).

Original: However, explicit storage of training samples is not scalable if the number of classes is large.
Revised: However, explicit storage of training samples is not scalable if the number of classes is large.

Original: Furthermore, it is difﬁcult to train a reliable generative model for all classes from very few training samples.
Revised: Furthermore, it is difﬁcult to train a reliable generative model for all classes from very few training samples.

Original: In parallel, regularization approaches do not require old exemplars and impose regularization on network weights or outputs to minimize the change of parameters that are important to old tasks (Kirkpatrick et al., 2017; Zenke et al., 2017).
Revised: In parallel, regularization approaches do not require old exemplars and impose regularization on network weights or outputs to minimize the change of parameters that are important to old tasks (Kirkpatrick et al., 2017; Zenke et al., 2017).

Original: To avoid quick performance deterioration after learning a sequence of novel tasks in regularization approaches, semantic drift compensation (SDC) is developed by learning an embedding network via triplet loss (Schroff et al., 2015) and compensates the drift of class centroids using novel data only (Yu et al., 2020).
Revised: To avoid quick performance deterioration after learning a sequence of novel tasks in regularization approaches, semantic drift compensation (SDC) is developed by learning an embedding network via triplet loss (Schroff et al., 2015) and compensates the drift of class centroids using novel data only (Yu et al., 2020).

Original: In comparison, IDLVQ-C saves only one exemplar per class and uses saved exemplars to regularize the change in feature extractor and calibrate the change in reference vectors.
Revised: In comparison, IDLVQ-C saves only one exemplar per class and uses saved exemplars to regularize the change in feature extractor and calibrate the change in reference vectors.

Original: Few-shot learning: Few-shot learning attempts to obtain models for classiﬁcation or regression tasks with only a few labelled samples.
Revised: Few-shot learning: Few-shot learning attempts to obtain models for classiﬁcation or regression tasks with only a few labelled samples.

Original: Few-shot models are trained on widely-varying episodes of fake few-shot tasks with labelled samples drawn from a large-scale meta-training dataset (Vinyals et al., 2016;
Revised: Few-shot models are trained on widely-varying episodes of fake few-shot tasks with labelled samples drawn from a large-scale meta-training dataset (Vinyals et al., 2016;

Original: Finn et al., 2017; Ravi & Larochelle, 2017; Snell et al., 2017; Sung et al., 2018).
Revised: Finn et al., 2017; Ravi & Larochelle, 2017; Snell et al., 2017; Sung et al., 2018).

Original: Meanwhile, recent works attempt to handle novel few-shot tasks while retraining the knowledge of the base task.
Revised: Meanwhile, recent works attempt to handle novel few-shot tasks while retraining the knowledge of the base task.

Original: These methods are referred to as dynamic few-shot learning (Gidaris & Komodakis, 2018;
Revised: These methods are referred to as dynamic few-shot learning (Gidaris & Komodakis, 2018;

Original: Ren et al., 2019a; Gidaris & Komodakis, 2019).
Revised: Ren et al., 2019a; Gidaris & Komodakis, 2019).

Original: However, dynamic few-shot learning is different from incremental few-shot learning, because they rely on the entire base training dataset and an extra meta-training dataset during meta-training.
Revised: However, dynamic few-shot learning is different from incremental few-shot learning, because they rely on the entire base training dataset and an extra meta-training dataset during meta-training.

Original: In addition, dynamic few-shot learning does not accumulate knowledge for multiple novel tasks sequentially.
Revised: In addition, dynamic few-shot learning does not accumulate knowledge for multiple novel tasks sequentially.

Original: Incremental few-shot learning: Prior works on incremental few-shot learning focus on classiﬁcation problems by computing the weights for novel classes in parametric classiﬁers, without iterative gradient descent.
Revised: Incremental few-shot learning: Prior works on incremental few-shot learning focus on classiﬁcation problems by computing the weights for novel classes in parametric classiﬁers, without iterative gradient descent.

Original: For instance, the weights of novel classes can be imprinted by normalized prototypes of novel classes, while keeping the feature extractor ﬁxed (Qi et al., 2018).
Revised: For instance, the weights of novel classes can be imprinted by normalized prototypes of novel classes, while keeping the feature extractor ﬁxed (Qi et al., 2018).

Original: Since novel weights are computed only with the samples of novel classes, the ﬁxed feature extractor may not be compatible with novel classiﬁcation weights.
Revised: Since novel weights are computed only with the samples of novel classes, the ﬁxed feature extractor may not be compatible with novel classiﬁcation weights.

Original: More recently, neural gas network is employed to construct an undirected graph to represent knowledge of old classes (Tao et al., 2020b;a).
Revised: More recently, neural gas network is employed to construct an undirected graph to represent knowledge of old classes (Tao et al., 2020b;a).

Original: The vertices in the graph are constructed in an unsupervised manner using competitive Hebbian learning (Fritzke, 1995), while the feature embedding is ﬁxed.
Revised: The vertices in the graph are constructed in an unsupervised manner using competitive Hebbian learning (Fritzke, 1995), while the feature embedding is ﬁxed.

Original: In contrast, IDLVQ learns both feature extractor and reference vectors concurrently in a supervised manner.
Revised: In contrast, IDLVQ learns both feature extractor and reference vectors concurrently in a supervised manner.

Original:  B ACKGROUND 3. I NCREMENTAL FEW - SHOT LEARNING
Revised:  B ACKGROUND 3. I NCREMENTAL FEW - SHOT LEARNING

Original: In this paper, incremental few-shot learning is studied for both classiﬁcation and regression tasks.
Revised: In this paper, incremental few-shot learning is studied for both classiﬁcation and regression tasks.

Original: For classiﬁcation tasks, we consider the standard class-incremental setup in literature.
Revised: For classiﬁcation tasks, we consider the standard class-incremental setup in literature.

Original: After the model is trained on a base task ( t = 1 ) with sufﬁcient data, the model learns novel tasks sequentially.
Revised: After the model is trained on a base task ( t = 1 ) with sufﬁcient data, the model learns novel tasks sequentially.

Original: Each novel task contains a number of novel classes with only a few training samples per class.
Revised: Each novel task contains a number of novel classes with only a few training samples per class.

Original: Learning a novel task ( t > 1 ) is referred to as an incremental learning session.
Revised: Learning a novel task ( t > 1 ) is referred to as an incremental learning session.

Original: In task t , we have access only to training data D t in the current task and previously saved exemplars (one exemplar per class in this study).
Revised: In task t , we have access only to training data D t in the current task and previously saved exemplars (one exemplar per class in this study).

Original: Each task has a set of classes C t = { c t 1 , ..., c tn t } , where n t is the number of classes in task t .
Revised: Each task has a set of classes C t = { c t 1 , ..., c tn t } , where n t is the number of classes in task t .

Original: In addition, it is assumed that there is no overlap between classes in different tasks C t (cid:84)
Revised: In addition, it is assumed that there is no overlap between classes in different tasks C t (cid:84)

Original: C s = ∅ for t (cid:54)
Revised: C s = ∅ for t (cid:54)

Original: =
Revised: =

Original: s .
Revised: s .

Original: After an incremental learning session, the performance of the model is evaluated on a test set that contains all previously seen classes C =
Revised: After an incremental learning session, the performance of the model is evaluated on a test set that contains all previously seen classes C =

Original: (cid:84)
Revised: (cid:84)

Original: i C i .
Revised: i C i .

Original: Note that our focus is not multi-task scenario, where a task ID is exposed to the model during test phase and the model is only required to perform a given task one time (van de Ven & Tolias, 2019).
Revised: Note that our focus is not multi-task scenario, where a task ID is exposed to the model during test phase and the model is only required to perform a given task one time (van de Ven & Tolias, 2019).

Original: Our model is evaluated in a task-agnostic setting, where task ID is not exposed to the model at test time.
Revised: Our model is evaluated in a task-agnostic setting, where task ID is not exposed to the model at test time.

Original: For regression tasks, we follow a similar setting with a notable difference that the target is realvalued y ∈ R .
Revised: For regression tasks, we follow a similar setting with a notable difference that the target is realvalued y ∈ R .

Original: In addition, the target values in different tasks do not have to be mutually exclusive, unlike the class-incremental setup.
Revised: In addition, the target values in different tasks do not have to be mutually exclusive, unlike the class-incremental setup.

Original: 3. L EARNING VECTOR QUANTIZATION
Revised: 3. L EARNING VECTOR QUANTIZATION

Original: Traditional nonparametric methods, such as nearest neighbors, represent knowledge and make predictions by storing the entire training set.
Revised: Traditional nonparametric methods, such as nearest neighbors, represent knowledge and make predictions by storing the entire training set.

Original: Despite the simplicity and effectiveness, they are not scalable to a large-scale base dataset.
Revised: Despite the simplicity and effectiveness, they are not scalable to a large-scale base dataset.

Original: Typically, incremental learning methods are only allowed to store a small number of exemplars to preserve the knowledge of previously learned tasks.
Revised: Typically, incremental learning methods are only allowed to store a small number of exemplars to preserve the knowledge of previously learned tasks.

Original: However, randomly selected exemplars may not well present the knowledge in old tasks.
Revised: However, randomly selected exemplars may not well present the knowledge in old tasks.

Original: LVQ is a classical data compression method that represents the knowledge through a few learned reference vectors (Sato & Yamada, 1996; Seo & Obermayer, 2003; Biehl et al., 2007).
Revised: LVQ is a classical data compression method that represents the knowledge through a few learned reference vectors (Sato & Yamada, 1996; Seo & Obermayer, 2003; Biehl et al., 2007).

Original: A new sample is classiﬁed to the same label as the nearest reference vector in the input space.
Revised: A new sample is classiﬁed to the same label as the nearest reference vector in the input space.

Original: LVQ has been combined with deep feature extractors as an alternative to standard neural networks for better interpretability (De Vries et al., 2016; Villmann et al., 2017; Saralajew et al., 2018).
Revised: LVQ has been combined with deep feature extractors as an alternative to standard neural networks for better interpretability (De Vries et al., 2016; Villmann et al., 2017; Saralajew et al., 2018).

Original: The combinations of LVQ and deep feature extractors have been applied to natural language processing (NLP), facial recognition and biometrics (Variani et al., 2015;
Revised: The combinations of LVQ and deep feature extractors have been applied to natural language processing (NLP), facial recognition and biometrics (Variani et al., 2015;

Original: Wang et al., 2016;
Revised: Wang et al., 2016;

Original: Ren et al., 2019b; Leng et al., 2015).
Revised: Ren et al., 2019b; Leng et al., 2015).

Original: We notice that LVQ is a nonparametric method which is well suited for incremental few-shot learning because the model capacity grows by incorporating more reference vectors to learn new knowledge.
Revised: We notice that LVQ is a nonparametric method which is well suited for incremental few-shot learning because the model capacity grows by incorporating more reference vectors to learn new knowledge.

Original: For example, incremental learning vector quantization (ILVQ) has been developed to learn classiﬁcation models adaptively from raw features (Xu et al., 2012).
Revised: For example, incremental learning vector quantization (ILVQ) has been developed to learn classiﬁcation models adaptively from raw features (Xu et al., 2012).

Original: In this study, we present the knowledge by learning reference vectors in the feature space through LVQ and adapt them in incremental few-shot learning.
Revised: In this study, we present the knowledge by learning reference vectors in the feature space through LVQ and adapt them in incremental few-shot learning.

Original: Compared with ILVQ by Xu et al.
Revised: Compared with ILVQ by Xu et al.

Original: (2012), our method does not rely on predeﬁned rules to update reference vectors and can be learned along with deep neural networks in an end-to-end fashion.
Revised: (2012), our method does not rely on predeﬁned rules to update reference vectors and can be learned along with deep neural networks in an end-to-end fashion.

Original: Besides, our method uses a single reference vector for each class, while ILVQ automatically assigns different numbers of prototypes for different classes.
Revised: Besides, our method uses a single reference vector for each class, while ILVQ automatically assigns different numbers of prototypes for different classes.

Original:  M ETHODOLOGY 4. I NCREMENTAL DEEP LEARNING VECTOR QUANTIZATION
Revised:  M ETHODOLOGY 4. I NCREMENTAL DEEP LEARNING VECTOR QUANTIZATION

Original: The general framework of IDLVQ for both classiﬁcation and regression can be derived from a Gaussian mixture perspective (Ghahramani & Jordan, 1994), with a simpliﬁed covariance structure and supervised deep representation learning.
Revised: The general framework of IDLVQ for both classiﬁcation and regression can be derived from a Gaussian mixture perspective (Ghahramani & Jordan, 1994), with a simpliﬁed covariance structure and supervised deep representation learning.

Original: In the base dataset ( t = 1 ), a raw input x is projected into a feature space F 1 by a deep neural network f θ 1 , where θ 1 denotes the parameters in neural networks.
Revised: In the base dataset ( t = 1 ), a raw input x is projected into a feature space F 1 by a deep neural network f θ 1 , where θ 1 denotes the parameters in neural networks.

Original: In addition, N 1 reference vectors M 1 = { m 11 , ..., m 1 N 1 } are placed in the feature space F 1 , which can be learned to capture the representation of the base dataset.
Revised: In addition, N 1 reference vectors M 1 = { m 11 , ..., m 1 N 1 } are placed in the feature space F 1 , which can be learned to capture the representation of the base dataset.

Original: More reference vectors will be added incrementally while learning novel tasks.
Revised: More reference vectors will be added incrementally while learning novel tasks.

Original: The marginal distribution p ( f θ 1 ( x )) of feature vector can be described by a Gaussian mixture model p ( f θ 1 ( x ))
Revised: The marginal distribution p ( f θ 1 ( x )) of feature vector can be described by a Gaussian mixture model p ( f θ 1 ( x ))

Original: = (cid:80) N 1 i =1 p
Revised: = (cid:80) N 1 i =1 p

Original: ( i ) p ( f θ 1 ( x ) | i ) of N 1 components, where the prior p ( i ) = 1 /N 1 and the component distribution p ( f θ 1 ( x ) | i ) is Gaussian.
Revised: ( i ) p ( f θ 1 ( x ) | i ) of N 1 components, where the prior p ( i ) = 1 /N 1 and the component distribution p ( f θ 1 ( x ) | i ) is Gaussian.

Original: By assuming that each component distribution p ( f θ 1 ( x ) | i ) is isotropic Gaussian centered at m 1 i with the same covariance, the posterior distribution of a component given the input is
Revised: By assuming that each component distribution p ( f θ 1 ( x ) | i ) is isotropic Gaussian centered at m 1 i with the same covariance, the posterior distribution of a component given the input is

Original: [Equation]
Revised: [Equation]

Original: [Equation]
Revised: [Equation]

Original: where κ ( f θ 1 ( x ) , m 1 i ) =
Revised: where κ ( f θ 1 ( x ) , m 1 i ) =

Original: exp( −(cid:107) f
Revised: exp( −(cid:107) f

Original: θ 1 ( x ) − m 1 i (cid:107) 2 /γ ) is a Gaussian kernel and γ is a scale factor.
Revised: θ 1 ( x ) − m 1 i (cid:107) 2 /γ ) is a Gaussian kernel and γ is a scale factor.

Original: The conditional expectation of the output from a Gaussian mixture is ˆ y =
Revised: The conditional expectation of the output from a Gaussian mixture is ˆ y =

Original: (cid:80) N 1 i =1 p 1 ( i | x ) q 1 i , where q 1 i is the reference target associated with reference vector m 1 i .
Revised: (cid:80) N 1 i =1 p 1 ( i | x ) q 1 i , where q 1 i is the reference target associated with reference vector m 1 i .

Original: In classiﬁcation problems, q 1 i is either 0 or 1 indicating whether m 1 i and x have the same label.
Revised: In classiﬁcation problems, q 1 i is either 0 or 1 indicating whether m 1 i and x have the same label.

Original: Since each reference vector is assigned to a class at initialization, q 1 i is ﬁxed and does not require learning.
Revised: Since each reference vector is assigned to a class at initialization, q 1 i is ﬁxed and does not require learning.

Original: Meanwhile, q 1 i in regression problems is real-valued and has to be learned.
Revised: Meanwhile, q 1 i in regression problems is real-valued and has to be learned.

Original: The weights in neural networks θ 1 , reference vectors M 1 , reference targets q 1 i (in regression problems only) and the scale factor γ are learned concurrently by minimizing a loss function between the true label y and the predicted label ˆ y .
Revised: The weights in neural networks θ 1 , reference vectors M 1 , reference targets q 1 i (in regression problems only) and the scale factor γ are learned concurrently by minimizing a loss function between the true label y and the predicted label ˆ y .

Original: The proposed IDLVQ is a nonparametric method as it makes prediction based on similarity to reference vectors, instead of using any regression or classiﬁcation weights.
Revised: The proposed IDLVQ is a nonparametric method as it makes prediction based on similarity to reference vectors, instead of using any regression or classiﬁcation weights.

Original: The capacity of the model grows naturally by adding more reference vectors to learn novel tasks, while the old knowledge is preserved in existing reference vectors.
Revised: The capacity of the model grows naturally by adding more reference vectors to learn novel tasks, while the old knowledge is preserved in existing reference vectors.

Original: 4. I NCREMENTAL DEEP LEARNING VECTOR QUANTIZATION FOR CLASSIFICATION
Revised: 4. I NCREMENTAL DEEP LEARNING VECTOR QUANTIZATION FOR CLASSIFICATION

Original: For classiﬁcation problems, one reference vector is assigned to each class in our study.
Revised: For classiﬁcation problems, one reference vector is assigned to each class in our study.

Original: Thus, ˆ y represents the predicted probability that an input belongs to a class.
Revised: Thus, ˆ y represents the predicted probability that an input belongs to a class.

Original: The model can be trained to classify data correctly by minimizing the cross-entropy loss L CE between the predicted probability ˆ y and the true label y .
Revised: The model can be trained to classify data correctly by minimizing the cross-entropy loss L CE between the predicted probability ˆ y and the true label y .

Original: Although the cross-entropy loss encourages separability of features in base classes, it does not guarantee compact intra-class variation in the feature space.
Revised: Although the cross-entropy loss encourages separability of features in base classes, it does not guarantee compact intra-class variation in the feature space.

Original: Speciﬁcally, in an incremental learning session, features of novel classes could overlap with those of previously learned classes.
Revised: Speciﬁcally, in an incremental learning session, features of novel classes could overlap with those of previously learned classes.

Original: As a result, the overall classiﬁcation accuracy could deteriorate after incremental learning sessions.
Revised: As a result, the overall classiﬁcation accuracy could deteriorate after incremental learning sessions.

Original: A desirable feature embedding leaves large margin between classes to mitigate overlap in features across old and new classes.
Revised: A desirable feature embedding leaves large margin between classes to mitigate overlap in features across old and new classes.

Original: Inspired by center loss (Wen et al., 2016) to enhance discriminative capability in facial recognition, a regularization term on intra-class distance to reference vectors is added to get compact intra-class variation.
Revised: Inspired by center loss (Wen et al., 2016) to enhance discriminative capability in facial recognition, a regularization term on intra-class distance to reference vectors is added to get compact intra-class variation.

Original: [Equation]
Revised: [Equation]

Original: As such, f θ 1 ( x ) is forced to stay close to the reference vector with the same label and naturally moves away from other reference vectors.
Revised: As such, f θ 1 ( x ) is forced to stay close to the reference vector with the same label and naturally moves away from other reference vectors.

Original: Consequently, features of new classes are more likely to lie in the margin between old classes to mitigate ambiguity in features across different classes.
Revised: Consequently, features of new classes are more likely to lie in the margin between old classes to mitigate ambiguity in features across different classes.

Original: The total loss in training the base task is given by L =
Revised: The total loss in training the base task is given by L =

Original: L CE + λ intra L intra , where λ intra is a hyper-parameter to control the weight for intra-class variation loss.
Revised: L CE + λ intra L intra , where λ intra is a hyper-parameter to control the weight for intra-class variation loss.

Original: The total loss is differentiable w.r.t.
Revised: The total loss is differentiable w.r.t.

Original: neural network parameters θ 1 , reference vectors M 1 = { m 11 , ..., m 1 n 1 } and scaling factor γ .
Revised: neural network parameters θ 1 , reference vectors M 1 = { m 11 , ..., m 1 n 1 } and scaling factor γ .

Original: All parameters in the model can be trained jointly in an end-to-end fashion.
Revised: All parameters in the model can be trained jointly in an end-to-end fashion.

Original: In an incremental session ( t > 1 ), a novel dataset D t contains n t classes and K t samples per class ( n t -way K t -shot).
Revised: In an incremental session ( t > 1 ), a novel dataset D t contains n t classes and K t samples per class ( n t -way K t -shot).

Original: n t new reference vectors are added and each reference vector is initialized as the centroid of features in a class m ti
Revised: n t new reference vectors are added and each reference vector is initialized as the centroid of features in a class m ti

Original: = 1 K t (cid:80) K t k
Revised: = 1 K t (cid:80) K t k

Original: =1 f θ t ( x k ) .
Revised: =1 f θ t ( x k ) .

Original: The new reference vectors along with the neural network parameters are ﬁne-tuned on D t to learn new knowledge in task t .
Revised: The new reference vectors along with the neural network parameters are ﬁne-tuned on D t to learn new knowledge in task t .

Original: To preserve the knowledge from the old tasks during incremental learning, the model should be updated only when necessary.
Revised: To preserve the knowledge from the old tasks during incremental learning, the model should be updated only when necessary.

Original: Therefore, cross-entropy loss is not used in incremental learning sessions because it always updates model parameters even if the sample is correctly classiﬁed.
Revised: Therefore, cross-entropy loss is not used in incremental learning sessions because it always updates model parameters even if the sample is correctly classiﬁed.

Original: Let m t + be the reference vector with the correct label and m t − be the nearest reference vector with a wrong label.
Revised: Let m t + be the reference vector with the correct label and m t − be the nearest reference vector with a wrong label.

Original: For a training sample ( x , y ) in D t , the sample is classiﬁed correctly if (cid:13)(cid:13)
Revised: For a training sample ( x , y ) in D t , the sample is classiﬁed correctly if (cid:13)(cid:13)

Original: f θ t ( x ) − m t + (cid:13)(cid:13) 2 < (cid:13)(cid:13)
Revised: f θ t ( x ) − m t + (cid:13)(cid:13) 2 < (cid:13)(cid:13)

Original: f θ t ( x ) − m t − (cid:13)(cid:13) 2 .
Revised: f θ t ( x ) − m t − (cid:13)(cid:13) 2 .

Original: In this case, the loss should be 0.
Revised: In this case, the loss should be 0.

Original: When (cid:13)(cid:13)
Revised: When (cid:13)(cid:13)

Original: f θ t ( x ) − m t + (cid:13)(cid:13) 2 > (cid:13)(cid:13)
Revised: f θ t ( x ) − m t + (cid:13)(cid:13) 2 > (cid:13)(cid:13)

Original: f θ t ( x ) − m t − (cid:13)(cid:13) 2 , the sample is misclassiﬁed.
Revised: f θ t ( x ) − m t − (cid:13)(cid:13) 2 , the sample is misclassiﬁed.

Original: We adapt the margin based loss function L M from De Vries et al.
Revised: We adapt the margin based loss function L M from De Vries et al.

Original: with a minor modiﬁcation
Revised: with a minor modiﬁcation

Original: [Equation]
Revised: [Equation]

Original: where ReLU ( · ) stands for the rectiﬁed linear unit function.
Revised: where ReLU ( · ) stands for the rectiﬁed linear unit function.

Original: The margin based loss leads to slow training convergence because it only updates two reference vectors one time.
Revised: The margin based loss leads to slow training convergence because it only updates two reference vectors one time.

Original: However, the adapted margin based loss is well suited in learning from few-shot samples while avoids unnecessary parameter updates.
Revised: However, the adapted margin based loss is well suited in learning from few-shot samples while avoids unnecessary parameter updates.

Original: Features for an old class could deviate away from the corresponding reference vector due to changes in θ t during incremental learning, leading to catastrophic forgetting.
Revised: Features for an old class could deviate away from the corresponding reference vector due to changes in θ t during incremental learning, leading to catastrophic forgetting.

Original: A forgetting loss L F is developed to regularize the drift in the feature space
Revised: A forgetting loss L F is developed to regularize the drift in the feature space

Original: [Equation]
Revised: [Equation]

Original: where x (cid:48)
Revised: where x (cid:48)

Original: i is the selected exemplar for class i and N t − 1 denotes the total number of classes in the base task and all previous novel tasks.
Revised: i is the selected exemplar for class i and N t − 1 denotes the total number of classes in the base task and all previous novel tasks.

Original: Note that the exemplar x (cid:48)
Revised: Note that the exemplar x (cid:48)

Original: i for class i ∈
Revised: i for class i ∈

Original: [ N t − 1 , N t ] is picked from D t whose feature is nearest to m ti at the end of each learning session.
Revised: [ N t − 1 , N t ] is picked from D t whose feature is nearest to m ti at the end of each learning session.

Original: The total loss in the incremental learning session t is L =
Revised: The total loss in the incremental learning session t is L =

Original: L M + λ F L F + λ intra L intra , where λ F and λ intra are weights for forgetting loss and intra-class variation loss, respectively.
Revised: L M + λ F L F + λ intra L intra , where λ F and λ intra are weights for forgetting loss and intra-class variation loss, respectively.

Original: The total loss is optimized w.r.t.
Revised: The total loss is optimized w.r.t.

Original: neural network parameters θ t and new reference vectors { m tN t − 1 +1 , ..., m tN t } .
Revised: neural network parameters θ t and new reference vectors { m tN t − 1 +1 , ..., m tN t } .

Original: The reference vectors for previously learned tasks are not updated by novel data to prevent catastrophic forgetting.
Revised: The reference vectors for previously learned tasks are not updated by novel data to prevent catastrophic forgetting.

Original: However, they may not be well suited to represent knowledge and make classiﬁcation in the new feature space F t as feature embedding is changed with updated θ t .
Revised: However, they may not be well suited to represent knowledge and make classiﬁcation in the new feature space F t as feature embedding is changed with updated θ t .

Original: Although the true optimal location of those reference vectors are difﬁcult to estimate without using the entire data from all tasks, they can be calculated approximately using the shift in features of exemplars.
Revised: Although the true optimal location of those reference vectors are difﬁcult to estimate without using the entire data from all tasks, they can be calculated approximately using the shift in features of exemplars.

Original: Considering that features of an exemplar x (cid:48)
Revised: Considering that features of an exemplar x (cid:48)

Original: i are close to m i in the feature space, the shift of a reference vector δ ti in the new feature space can be approximated by the shift of the exemplar’s features δ ti =
Revised: i are close to m i in the feature space, the shift of a reference vector δ ti in the new feature space can be approximated by the shift of the exemplar’s features δ ti =

Original: f θ t ( x (cid:48) i ) − f θ t − 1 ( x (cid:48) i ) .
Revised: f θ t ( x (cid:48) i ) − f θ t − 1 ( x (cid:48) i ) .

Original: Therefore, the reference vectors for previously learned tasks are calibrated m ti = m t − 1 i + δ ti , where m t − 1 i is the uncalibrated reference vector for class i ∈ [1 , N t − 1 ] .
Revised: Therefore, the reference vectors for previously learned tasks are calibrated m ti = m t − 1 i + δ ti , where m t − 1 i is the uncalibrated reference vector for class i ∈ [1 , N t − 1 ] .

Original: A test sample, which could be from any seen classes, is classiﬁed according to the distance to reference vectors { m t 1 , ..., m tN t } .
Revised: A test sample, which could be from any seen classes, is classiﬁed according to the distance to reference vectors { m t 1 , ..., m tN t } .

Original: The pseudo code for IDLVQ-C is presented in the appendix.
Revised: The pseudo code for IDLVQ-C is presented in the appendix.

Original: 4. I NCREMENTAL DEEP LEARNING VECTOR QUANTIZATION FOR REGRESSION
Revised: 4. I NCREMENTAL DEEP LEARNING VECTOR QUANTIZATION FOR REGRESSION

Original: For regression problems, the model is trained to recognize regression targets by the minimizing mean squared error (MSE) loss L MSE =
Revised: For regression problems, the model is trained to recognize regression targets by the minimizing mean squared error (MSE) loss L MSE =

Original: ( y − ˆ y ) 2 , where y is the real-valued target in training dataset.
Revised: ( y − ˆ y ) 2 , where y is the real-valued target in training dataset.

Original: The MSE loss function is differentiable w.r.t.
Revised: The MSE loss function is differentiable w.r.t.

Original: neural network weights, reference vectors and targets, and scale factor.
Revised: neural network weights, reference vectors and targets, and scale factor.

Original: Therefore, all parameters can be trained jointly in an end-to-end manner.
Revised: Therefore, all parameters can be trained jointly in an end-to-end manner.

Original: The proposed IDLVQ-R can also be interpreted as a kernel smoother in deep embedded space.
Revised: The proposed IDLVQ-R can also be interpreted as a kernel smoother in deep embedded space.

Original: Compared with traditional kernel smoother, such as Nadaraya-Watson estimator (Nadaraya, 1964),
Revised: Compared with traditional kernel smoother, such as Nadaraya-Watson estimator (Nadaraya, 1964),

Original: IDLVQ-R is sparse and hence more scalable as it only relies on a few reference vectors and targets.
Revised: IDLVQ-R is sparse and hence more scalable as it only relies on a few reference vectors and targets.

Original: In an incremental learning session ( t > 1 ), we have access to data D t that contains K t pairs of training samples ( x ti , y ti ) .
Revised: In an incremental learning session ( t > 1 ), we have access to data D t that contains K t pairs of training samples ( x ti , y ti ) .

Original: n t new reference vectors ( n t ≤ K t ) along with corresponding targets are added to the model to learn new knowledge in the novel task t .
Revised: n t new reference vectors ( n t ≤ K t ) along with corresponding targets are added to the model to learn new knowledge in the novel task t .

Original: We randomly select n t samples from
Revised: We randomly select n t samples from

Original: D t to initialize reference vectors and targets as follows
Revised: D t to initialize reference vectors and targets as follows

Original: [Equation]
Revised: [Equation]

Original: where N t − 1 is the total number of reference vectors in all previous tasks.
Revised: where N t − 1 is the total number of reference vectors in all previous tasks.

Original: The new reference vectors and targets are ﬁne-tuned by minimizing MSE on D t while keeping other parameters frozen.
Revised: The new reference vectors and targets are ﬁne-tuned by minimizing MSE on D t while keeping other parameters frozen.

Original: After new reference vectors and targets are ﬁne-tuned with novel data D t , the model makes prediction by smoothing targets of all reference vectors
Revised: After new reference vectors and targets are ﬁne-tuned with novel data D t , the model makes prediction by smoothing targets of all reference vectors

Original: [Equation]
Revised: [Equation]

Original: where N t is the current total number of reference vectors.
Revised: where N t is the current total number of reference vectors.

Original:  E XPERIMENTS
Revised:  E XPERIMENTS

Original: We ﬁrst describe the overall protocols, then we present the results on incremental few-shot classiﬁcation and regression problems.
Revised: We ﬁrst describe the overall protocols, then we present the results on incremental few-shot classiﬁcation and regression problems.

Original: 5. I NCREMENTAL FEW - SHOT CLASSIFICATION
Revised: 5. I NCREMENTAL FEW - SHOT CLASSIFICATION

Original: We empirically evaluate the performance of IDLVQ-C on incremental few-shot classiﬁcation on
Revised: We empirically evaluate the performance of IDLVQ-C on incremental few-shot classiﬁcation on

Original: CUB200-2011 (Welinder et al., 2010) and mini ImageNet datasets (Vinyals et al., 2016).
Revised: CUB200-2011 (Welinder et al., 2010) and mini ImageNet datasets (Vinyals et al., 2016).

Original: The dataset is split into base classes and multiple groups of novel classes.
Revised: The dataset is split into base classes and multiple groups of novel classes.

Original: We apply standard data augmentation, including random crop, horizontal ﬂip and color jitter, on all training images.
Revised: We apply standard data augmentation, including random crop, horizontal ﬂip and color jitter, on all training images.

Original: After each training session, the model performance is evaluated on a test set, which contains all classes that the model has been trained on.
Revised: After each training session, the model performance is evaluated on a test set, which contains all classes that the model has been trained on.

Original: CUB dataset is composed of 200 ﬁne-grained bird species with 11,788 images.
Revised: CUB dataset is composed of 200 ﬁne-grained bird species with 11,788 images.

Original: We split the dataset into 5894 training images, 2947 validation images and 2947 test images.
Revised: We split the dataset into 5894 training images, 2947 validation images and 2947 test images.

Original: All images are resized to 224 × 224.
Revised: All images are resized to 224 × 224.

Original: In addition, the ﬁrst 100 classes are chosen as base classes, where all training samples in base classes are used to train the base model.
Revised: In addition, the ﬁrst 100 classes are chosen as base classes, where all training samples in base classes are used to train the base model.

Original: The remaining 100 classes are treated as novel categories and split into 10 incremental learning sessions.
Revised: The remaining 100 classes are treated as novel categories and split into 10 incremental learning sessions.

Original: Each incremental learning session contains 10 novel classes and 5 randomly selected training samples per class mini ImageNet dataset is a 100-class subset of the original ImageNet dataset (Deng et al., 2009).
Revised: Each incremental learning session contains 10 novel classes and 5 randomly selected training samples per class mini ImageNet dataset is a 100-class subset of the original ImageNet dataset (Deng et al., 2009).

Original: Each class contains 500 training images, 50 validation images, and 50 test images.
Revised: Each class contains 500 training images, 50 validation images, and 50 test images.

Original: The images are in RGB format of the size 84 × 84.
Revised: The images are in RGB format of the size 84 × 84.

Original: We choose 60 and 40 classes for base and novel classes, respectfully.
Revised: We choose 60 and 40 classes for base and novel classes, respectfully.

Original: The 40 novel classes are divided into 8 sessions and each session contains 5 novel classes with 5 randomly selected training samples per class (5-way 5-shot).
Revised: The 40 novel classes are divided into 8 sessions and each session contains 5 novel classes with 5 randomly selected training samples per class (5-way 5-shot).

Original: ResNet18 (He et al., 2016) is used as the feature extractor for incremental classiﬁcation problems.
Revised: ResNet18 (He et al., 2016) is used as the feature extractor for incremental classiﬁcation problems.

Original: The learning process for each dataset is repeated 10 times and the average test accuracy is reported.
Revised: The learning process for each dataset is repeated 10 times and the average test accuracy is reported.

Original: The proposed method is compared with six methods for few-shot class-incremental learning: ﬁneturning using D t , joint training using the entire training set from all encountered classes, iCaRL (Rebufﬁ et al., 2017), Rebalancing (Hou et al., 2019), ProtoNet (Snell et al., 2017), incremental learning vector quantization (ILVQ) (Xu et al., 2012), SDC (Yu et al., 2020), and Imprint (Qi et al., 2018).
Revised: The proposed method is compared with six methods for few-shot class-incremental learning: ﬁneturning using D t , joint training using the entire training set from all encountered classes, iCaRL (Rebufﬁ et al., 2017), Rebalancing (Hou et al., 2019), ProtoNet (Snell et al., 2017), incremental learning vector quantization (ILVQ) (Xu et al., 2012), SDC (Yu et al., 2020), and Imprint (Qi et al., 2018).

Original: Note that ILVQ is applied to the features extracted by neural networks in our experiment.
Revised: Note that ILVQ is applied to the features extracted by neural networks in our experiment.

Original: The incremental few-shot learning results on CUB and miniImageNet are shown in Table 1 and 2, respectively.
Revised: The incremental few-shot learning results on CUB and miniImageNet are shown in Table 1 and 2, respectively.

Original: Our method outperforms ﬁne-tuning, iCaRL (Rebufﬁ et al., 2017), and ProtoNet (Snell et al., 2017) by a large margin.
Revised: Our method outperforms ﬁne-tuning, iCaRL (Rebufﬁ et al., 2017), and ProtoNet (Snell et al., 2017) by a large margin.

Original: Simply ﬁne-tuning the weights in classiﬁer with few-shot training samples for novel classes signiﬁcantly deteriorates the prediction accuracy.
Revised: Simply ﬁne-tuning the weights in classiﬁer with few-shot training samples for novel classes signiﬁcantly deteriorates the prediction accuracy.

Original: Although iCaRL alleviates catastrophic forgetting by tuning the model with a mix of old exemplars and novel few-shot data, the prediction accuracy still drops quickly because iCaRL requires sufﬁcient samples per class to achieve satisfactory performance.
Revised: Although iCaRL alleviates catastrophic forgetting by tuning the model with a mix of old exemplars and novel few-shot data, the prediction accuracy still drops quickly because iCaRL requires sufﬁcient samples per class to achieve satisfactory performance.

Original: The ProtoNet relies on distance to prototypes (the mean of features within a class) to make classiﬁcation but the ﬁxed feature extractor may not be able to well separate novel classes.
Revised: The ProtoNet relies on distance to prototypes (the mean of features within a class) to make classiﬁcation but the ﬁxed feature extractor may not be able to well separate novel classes.

Original: ILVQ is slightly better than ProtoNet because prototypes can be learned adaptively when more classes are available in incremental learning sessions.
Revised: ILVQ is slightly better than ProtoNet because prototypes can be learned adaptively when more classes are available in incremental learning sessions.

Original: Some prototypes in
Revised: Some prototypes in

Original: ILVQ are close to the border of a class, which are more effective than class centroids in ProtoNet.
Revised: ILVQ are close to the border of a class, which are more effective than class centroids in ProtoNet.

Original: However, ILVQ does not achieve the best performance because the feature extractor is ﬁxed and cannot be learned along with the prototypes.
Revised: However, ILVQ does not achieve the best performance because the feature extractor is ﬁxed and cannot be learned along with the prototypes.

Original: IDLVQ-C has a small gain in the ﬁrst couple of incremental few-shot learning sessions compared with SDC (Yu et al., 2020) and Imprint (Qi et al., 2018).
Revised: IDLVQ-C has a small gain in the ﬁrst couple of incremental few-shot learning sessions compared with SDC (Yu et al., 2020) and Imprint (Qi et al., 2018).

Original: Similar to ProtoNet, SDC also relies on prototypes to make classiﬁcation.
Revised: Similar to ProtoNet, SDC also relies on prototypes to make classiﬁcation.

Original: The performance of SDC is better than that of ProtoNet because SDC ﬁne-tunes the feature extractor with novel dataset and compensates the drift in prototypes.
Revised: The performance of SDC is better than that of ProtoNet because SDC ﬁne-tunes the feature extractor with novel dataset and compensates the drift in prototypes.

Original: However, the compensation for the drift of old-class prototypes can be less accurate in SDC because it is approximated by samples in novel classes.
Revised: However, the compensation for the drift of old-class prototypes can be less accurate in SDC because it is approximated by samples in novel classes.

Original: In parallel, the imprint method directly computes the normalized classiﬁcation weights from the average of normalized features within a novel class.
Revised: In parallel, the imprint method directly computes the normalized classiﬁcation weights from the average of normalized features within a novel class.

Original: The imprint method avoids imbalanced classiﬁcation weights and circumvents the overﬁtting in few-shot class-incremental learning through weight normalization.
Revised: The imprint method avoids imbalanced classiﬁcation weights and circumvents the overﬁtting in few-shot class-incremental learning through weight normalization.

Original: Nevertheless, the ﬁxed feature extractor in the imprint method may not be well suited for novel classes.
Revised: Nevertheless, the ﬁxed feature extractor in the imprint method may not be well suited for novel classes.

Original: In contrast, IDLVQ-C updates the feature extractor only when necessary and compensates the shift of old reference vectors more accurately using exemplars from old classes.
Revised: In contrast, IDLVQ-C updates the feature extractor only when necessary and compensates the shift of old reference vectors more accurately using exemplars from old classes.

Original: That is why the gain of IDLVQ-C increases with more incremental few-shot learning sessions.
Revised: That is why the gain of IDLVQ-C increases with more incremental few-shot learning sessions.

Original: The performance of SDC, Imprint and IDLVQ-C is better than ofﬂine joint training in early sessions of incremental few-shot learning.
Revised: The performance of SDC, Imprint and IDLVQ-C is better than ofﬂine joint training in early sessions of incremental few-shot learning.

Original: Ofﬂine joint training may not result in oracle performance due to extremely imbalanced samples between base classes and novel classes.
Revised: Ofﬂine joint training may not result in oracle performance due to extremely imbalanced samples between base classes and novel classes.

Original: [Table]
Revised: [Table]

Original: [Table]
Revised: [Table]

Original: Ablation studies are conducted to analyze how individual components affect the performance of incremental few-shot learning.
Revised: Ablation studies are conducted to analyze how individual components affect the performance of incremental few-shot learning.

Original: We study ﬁve variants of our methods: (a) new reference vectors are initialized as class centroids and no tuning is done for feature extractor or old reference vectors; (b)
Revised: We study ﬁve variants of our methods: (a) new reference vectors are initialized as class centroids and no tuning is done for feature extractor or old reference vectors; (b)

Original: L intra is not used in incremental learning sessions; (c) L F is not used in the incremental learning sessions; (d) shift in old reference vectors are not compensated; (e) replace the margin based loss L M with the cross entropy loss L CE .
Revised: L intra is not used in incremental learning sessions; (c) L F is not used in the incremental learning sessions; (d) shift in old reference vectors are not compensated; (e) replace the margin based loss L M with the cross entropy loss L CE .

Original: Table 3 shows the results of our ablation studies on CUB dataset.
Revised: Table 3 shows the results of our ablation studies on CUB dataset.

Original: Without any ﬁne-tuning, the initial reference vectors for novel classes lead to descent accuracy in incremental few-shot classiﬁcation.
Revised: Without any ﬁne-tuning, the initial reference vectors for novel classes lead to descent accuracy in incremental few-shot classiﬁcation.

Original: It demonstrates the robustness of nonparametric classiﬁer.
Revised: It demonstrates the robustness of nonparametric classiﬁer.

Original: L intra leads to 0 .
Revised: L intra leads to 0 .

Original: 57% gain due to tight intra-class variation.
Revised: 57% gain due to tight intra-class variation.

Original: The less forgetting regularization L F is proved to prevent forgetting old classes and achieves a performance boost by 2 . 35% .
Revised: The less forgetting regularization L F is proved to prevent forgetting old classes and achieves a performance boost by 2 . 35% .

Original: The shift compensation for reference vectors effectively adapts old reference vector in new embedding spaces with a gain round of 1% .
Revised: The shift compensation for reference vectors effectively adapts old reference vector in new embedding spaces with a gain round of 1% .

Original: The margin based loss is more effective in preventing forgetting in early sessions of incremental learning.
Revised: The margin based loss is more effective in preventing forgetting in early sessions of incremental learning.

Original: The effect of the number of training samples per class.
Revised: The effect of the number of training samples per class.

Original: The proposed method is evaluated under different few-shot settings on CUB dataset to investigate the effect of different numbers of training
Revised: The proposed method is evaluated under different few-shot settings on CUB dataset to investigate the effect of different numbers of training

Original: [Table]
Revised: [Table]

Original: samples in novel classes, including 5-shot, 10-shot and 20-shot settings.
Revised: samples in novel classes, including 5-shot, 10-shot and 20-shot settings.

Original: One reference vector is assigned to each class in all few-shot settings.
Revised: One reference vector is assigned to each class in all few-shot settings.

Original: As shown in Fig.
Revised: As shown in Fig.

Original: 2 in the appendix, the performance of incremental learning improves as the number of samples per class increases.
Revised: 2 in the appendix, the performance of incremental learning improves as the number of samples per class increases.

Original: When the training samples are scarce, the training samples may not well present the generative distribution of training data.
Revised: When the training samples are scarce, the training samples may not well present the generative distribution of training data.

Original: Therefore, the learned reference vectors could be biased and classiﬁcation accuracy is low.
Revised: Therefore, the learned reference vectors could be biased and classiﬁcation accuracy is low.

Original: With more training samples, the learned reference vectors could well present the center of the distribution and classiﬁcation accuracy is improved.
Revised: With more training samples, the learned reference vectors could well present the center of the distribution and classiﬁcation accuracy is improved.

Original: The gap in performance becomes more obvious as the number of incremental learning sessions grows.
Revised: The gap in performance becomes more obvious as the number of incremental learning sessions grows.

Original: The detailed results are reported in Table 7 and 8.
Revised: The detailed results are reported in Table 7 and 8.

Original: 5. I NCREMENTAL FEW - SHOT REGRESSION
Revised: 5. I NCREMENTAL FEW - SHOT REGRESSION

Original: IDLVQ-R is tested on two regression datasets: sinusoidal wave and 3D spatial data.
Revised: IDLVQ-R is tested on two regression datasets: sinusoidal wave and 3D spatial data.

Original: Considering that there is no state-of-the-art method for incremental few-shot regression, we compare IDLVQ-R against three alternative methods: ﬁne-tuning using novel task data only, ﬁne-tuning using novel task data along with exemplars and ofﬂine training using the entire training dataset from all tasks.
Revised: Considering that there is no state-of-the-art method for incremental few-shot regression, we compare IDLVQ-R against three alternative methods: ﬁne-tuning using novel task data only, ﬁne-tuning using novel task data along with exemplars and ofﬂine training using the entire training dataset from all tasks.

Original: Sinusoidal wave is deﬁned by a function y
Revised: Sinusoidal wave is deﬁned by a function y

Original: = sin(3 πx )
Revised: = sin(3 πx )

Original: + 0 .
Revised: + 0 .

Original: 3 cos(9 πx )
Revised: 3 cos(9 πx )

Original: + 0 .
Revised: + 0 .

Original: 5 sin(7 πx )
Revised: 5 sin(7 πx )

Original: + (cid:15) , where (cid:15) is white noise with a standard deviation of 0.1.
Revised: + (cid:15) , where (cid:15) is white noise with a standard deviation of 0.1.

Original: 1000 training samples in the ﬁrst task (bas task) are generated by sampling x ∈ [ − 1 . 0 , 1 . 0] uniformly.
Revised: 1000 training samples in the ﬁrst task (bas task) are generated by sampling x ∈ [ − 1 . 0 , 1 . 0] uniformly.

Original: 5-shot training samples in two novel tasks are generated by sampling x ∈ [1 . 0 , 1 . 5] and x ∈ [1 . 5 , 2 . 0] , respectively.
Revised: 5-shot training samples in two novel tasks are generated by sampling x ∈ [1 . 0 , 1 . 5] and x ∈ [1 . 5 , 2 . 0] , respectively.

Original: As shown in Fig. 1(a), IDLVQ-R achieves comparable performance to ofﬂine neural networks in
Revised: As shown in Fig. 1(a), IDLVQ-R achieves comparable performance to ofﬂine neural networks in

Original: Fig. 1(d) which are trained using the entire training set from all tasks.
Revised: Fig. 1(d) which are trained using the entire training set from all tasks.

Original: In comparison, neural networks trained sequentially with few-shot training samples show catastrophic forgetting on old tasks in Fig. 1(b).
Revised: In comparison, neural networks trained sequentially with few-shot training samples show catastrophic forgetting on old tasks in Fig. 1(b).

Original: With the addition of exemplars during training, the networks perform better but still suffer from catastrophic forgetting on the base task in Fig. 1(c).
Revised: With the addition of exemplars during training, the networks perform better but still suffer from catastrophic forgetting on the base task in Fig. 1(c).

Original: In conclusion, IDLVQ-R preserves old knowledge and adapts to new knowledge quickly using a few reference vectors and achieves satisfactory performance on incremental few-shot regression tasks.
Revised: In conclusion, IDLVQ-R preserves old knowledge and adapts to new knowledge quickly using a few reference vectors and achieves satisfactory performance on incremental few-shot regression tasks.

Original: The experiment details can be found in the appendix.
Revised: The experiment details can be found in the appendix.

Original: [Equation]
Revised: [Equation]

Original: y
Revised: y

Original: RMSE: 0.
Revised: RMSE: 0.

Original: (b) 1.0 0.5 0.0 0.5 1.0 1.5 2.0 x 2.0 1.
Revised: (b) 1.0 0.5 0.0 0.5 1.0 1.5 2.0 x 2.0 1.

Original: y
Revised: y

Original: RMSE: 0.
Revised: RMSE: 0.

Original: (c) 1.0 0.5 0.0 0.

Revised: (c) 1.0 0.5 0.0 0.

Original: 1.0 1.5 2.0 x 2.0 1.
Revised: 1.0 1.5 2.0 x 2.0 1.

Original: y
Revised: y

Original: RMSE: 0.
Revised: RMSE: 0.

Original: (d)
Revised: (d)

Original: 3D spatial data 1 is collected in North Jutland, Denmark.
Revised: 3D spatial data 1 is collected in North Jutland, Denmark.

Original: The inputs are longitude x 1 and latitude x 2 , and the output is altitude y .
Revised: The inputs are longitude x 1 and latitude x 2 , and the output is altitude y .

Original: 2482 training samples in the 1st task are collected in the area where x 1 ∈ [9 . 98 , 9 . 995] and x 2 ∈ [57 . 0 , 57 .
Revised: 2482 training samples in the 1st task are collected in the area where x 1 ∈ [9 . 98 , 9 . 995] and x 2 ∈ [57 . 0 , 57 .

Original: 20 training samples in the 2nd task are collected in the area where x 1 ∈ [9 . 995 , 10 . 0] and x 2 ∈ [57 . 02 , 57 .
Revised: 20 training samples in the 2nd task are collected in the area where x 1 ∈ [9 . 995 , 10 . 0] and x 2 ∈ [57 . 02 , 57 .

Original: 20 training samples in the 3rd task are collected in the area where x 1 ∈ [9 . 995 , 10 . 0] and x 2 ∈ [57 . 03 , 57 . 04] .
Revised: 20 training samples in the 3rd task are collected in the area where x 1 ∈ [9 . 995 , 10 . 0] and x 2 ∈ [57 . 03 , 57 . 04] .

Original: Approximately 300 test samples are collected for each task.
Revised: Approximately 300 test samples are collected for each task.

Original: [Table]
Revised: [Table]

Original: The normalized root mean squared errors (RMSE) between actual and predicted altitude in the test set are listed in Table 4.
Revised: The normalized root mean squared errors (RMSE) between actual and predicted altitude in the test set are listed in Table 4.

Original: The prediction accuracy drops signiﬁcantly when the model is ﬁnetuned with novel data only.
Revised: The prediction accuracy drops signiﬁcantly when the model is ﬁnetuned with novel data only.

Original: Catastrophic forgetting can be alleviated using exemplars from previous tasks.
Revised: Catastrophic forgetting can be alleviated using exemplars from previous tasks.

Original: IDLVQ-R achieves better results than ﬁne tuning with exemplars.
Revised: IDLVQ-R achieves better results than ﬁne tuning with exemplars.

Original: The good performance of
Revised: The good performance of

Original: IDLVQ-R can be attributed to two reasons.
Revised: IDLVQ-R can be attributed to two reasons.

Original: First, IDLVQ-R learns a number of reference vectors and targets to preserve the knowledge in encountered tasks.
Revised: First, IDLVQ-R learns a number of reference vectors and targets to preserve the knowledge in encountered tasks.

Original: Compared with a linear layer on top of neural networks, a number of reference vectors represent richer information about the training data.
Revised: Compared with a linear layer on top of neural networks, a number of reference vectors represent richer information about the training data.

Original: Second, IDLVQ-R is nonparametric and can represent local and nonlinear relationship without learning any regression coefﬁcient from few-shot data.
Revised: Second, IDLVQ-R is nonparametric and can represent local and nonlinear relationship without learning any regression coefﬁcient from few-shot data.

Original:  C ONCLUSIONS
Revised:  C ONCLUSIONS

Original: A new incremental few-shot learning approach is developed to harmonize old knowledge preserving and new knowledge adaptation through quantized vector in deep embedded space.
Revised: A new incremental few-shot learning approach is developed to harmonize old knowledge preserving and new knowledge adaptation through quantized vector in deep embedded space.

Original: Prediction is made in a nonparametric way using similarity to learned reference vectors, which circumvents biased weights in a parametric classiﬁcation layer during incremental few-shot learning.
Revised: Prediction is made in a nonparametric way using similarity to learned reference vectors, which circumvents biased weights in a parametric classiﬁcation layer during incremental few-shot learning.

Original: For classiﬁcation problems, additional mechanisms are developed to mitigate the forgetting in old classes and improve representation learning for few-shot novel classes.
Revised: For classiﬁcation problems, additional mechanisms are developed to mitigate the forgetting in old classes and improve representation learning for few-shot novel classes.

Original: For regression problems, the proposed approach has been reinterpreted as a kernel smoother to predict real-valued target over novel domain
Revised: For regression problems, the proposed approach has been reinterpreted as a kernel smoother to predict real-valued target over novel domain

Original: A PPENDIX
Revised: A PPENDIX

Original: A.
Revised: A.

Original: P SEUDO CODE FOR IDLVQ-C Algorithm
Revised: P SEUDO CODE FOR IDLVQ-C Algorithm

Original: In the base task ( t = 1 )
Revised: In the base task ( t = 1 )

Original: Initialize θ 1 , { m 11 , ..., m 1 N 1 } and γ
Revised: Initialize θ 1 , { m 11 , ..., m 1 N 1 } and γ

Original: Minimize L = L CE + λ intra L intra w.r.t.
Revised: Minimize L = L CE + λ intra L intra w.r.t.

Original: θ 1 , { m 11 , ..., m 1 N 1 } and γ
Revised: θ 1 , { m 11 , ..., m 1 N 1 } and γ

Original: Pick exemplars from D 1 for classes in the base task: x (cid:48)
Revised: Pick exemplars from D 1 for classes in the base task: x (cid:48)

Original: i =
Revised: i =

Original: arg min x ∈D 1 (cid:13)(cid:13)
Revised: arg min x ∈D 1 (cid:13)(cid:13)

Original: f θ t − 1 ( x ) − m 1 i (cid:13)(cid:13)for novel task t = 2 , 3 , ... do
Revised: f θ t − 1 ( x ) − m 1 i (cid:13)(cid:13)for novel task t = 2 , 3 , ... do

Original: Initialize { m tN t − 1 +1 , ..., m tN t }
Revised: Initialize { m tN t − 1 +1 , ..., m tN t }

Original: Minimize L = L M + λ F L F + λ intra L intra w.r.t.
Revised: Minimize L = L M + λ F L F + λ intra L intra w.r.t.

Original: θ t and { m tN t − 1 +1 , ..., m t N t }
Revised: θ t and { m tN t − 1 +1 , ..., m t N t }

Original: Calibrate old reference vector { m t − 1 1 , ..., m t − 1 N t − 1 } using m ti = m t − 1 i
Revised: Calibrate old reference vector { m t − 1 1 , ..., m t − 1 N t − 1 } using m ti = m t − 1 i

Original: + δ ti
Revised: + δ ti

Original: Pick exemplars from D t for classes in the novel task t : x (cid:48) i =
Revised: Pick exemplars from D t for classes in the novel task t : x (cid:48) i =

Original: arg min x ∈D t (cid:107) f
Revised: arg min x ∈D t (cid:107) f

Original: θ t − 1 ( x ) − m ti (cid:107)end for
Revised: θ t − 1 ( x ) − m ti (cid:107)end for

Original: A. P SEUDO CODE FOR IDLVQ-R Algorithm 2 IDLVQ-R
Revised: A. P SEUDO CODE FOR IDLVQ-R Algorithm 2 IDLVQ-R

Original: In the base task ( t = 1 )
Revised: In the base task ( t = 1 )

Original: Initialize θ , { m 1 1 , ..., m 1 N 1 } , { q 1 1 , ..., q 1 N 1 } and γ
Revised: Initialize θ , { m 1 1 , ..., m 1 N 1 } , { q 1 1 , ..., q 1 N 1 } and γ

Original: Minimize L MSE w.r.t.
Revised: Minimize L MSE w.r.t.

Original: θ , { m 11 , ..., m 1 N 1 } , { q 11 , ..., q 1 N 1 } and γ for novel task t = 2 , 3 , ... do
Revised: θ , { m 11 , ..., m 1 N 1 } , { q 11 , ..., q 1 N 1 } and γ for novel task t = 2 , 3 , ... do

Original: Initialize { m tN t − 1 +1 , ..., m tN t } and { q tN t − 1 +1 , ..., q tN t }
Revised: Initialize { m tN t − 1 +1 , ..., m tN t } and { q tN t − 1 +1 , ..., q tN t }

Original: Minimize L MSE w.r.t.
Revised: Minimize L MSE w.r.t.

Original: { m tN t − 1 +1 , ..., m tN t } and { q tN t − 1 +1 , ..., q tN t } end for
Revised: { m tN t − 1 +1 , ..., m tN t } and { q tN t − 1 +1 , ..., q tN t } end for

Original: A. E XPERIMENT DETAILS FOR INCREMENTAL FEW - SHOT CLASSIFICATION
Revised: A. E XPERIMENT DETAILS FOR INCREMENTAL FEW - SHOT CLASSIFICATION

Original: The base model is trained by the SGD optimizer (momentum of 0.9 and weight decay of 1e-4) with a mini-batch size of 64.
Revised: The base model is trained by the SGD optimizer (momentum of 0.9 and weight decay of 1e-4) with a mini-batch size of 64.

Original: For CUB dataset, the initial learning rate is 0.01 and is decayed by 0.1 after 60 and 120 epochs (200 epochs in total).
Revised: For CUB dataset, the initial learning rate is 0.01 and is decayed by 0.1 after 60 and 120 epochs (200 epochs in total).

Original: For miniImageNet, the learning rate also starts from 0.
Revised: For miniImageNet, the learning rate also starts from 0.

Original: and is decayed by 0.1 every 200 epochs (600 epochs in total).
Revised: and is decayed by 0.1 every 200 epochs (600 epochs in total).

Original: In an incremental learning session ( t > 1 ), the model is ﬁne-tuned with with D t with a learning rate of 0.01 for 100 epochs.
Revised: In an incremental learning session ( t > 1 ), the model is ﬁne-tuned with with D t with a learning rate of 0.01 for 100 epochs.

Original: Since novel data D t ( t > 1 ) contains very few training samples, all training samples in D t are included in one mini-batch.
Revised: Since novel data D t ( t > 1 ) contains very few training samples, all training samples in D t are included in one mini-batch.

Original: In addition, we use λ intra = 1 . 0 and λ F = 0 .
Revised: In addition, we use λ intra = 1 . 0 and λ F = 0 .

Original: 5 for both datasets.
Revised: 5 for both datasets.

Original: Empirically, larger λ intra leads to more compact intra-class variation.
Revised: Empirically, larger λ intra leads to more compact intra-class variation.

Original: However, convergence could be slow if λ intra is too large.
Revised: However, convergence could be slow if λ intra is too large.

Original: In addition, larger λ F results in less forgetting in old classes but makes learning novel classes more difﬁcult.
Revised: In addition, larger λ F results in less forgetting in old classes but makes learning novel classes more difﬁcult.

Original: A. A DDITIONAL RESULTS FOR INCREMENTAL FEW - SHOT CLASSIFICATION
Revised: A. A DDITIONAL RESULTS FOR INCREMENTAL FEW - SHOT CLASSIFICATION

Original: The accuracies for base and novel classes are reported separately in Table 5 and 6 for CUB amd miniImageNet, respectively.
Revised: The accuracies for base and novel classes are reported separately in Table 5 and 6 for CUB amd miniImageNet, respectively.

Original: The prediction accuracy of novel classes is calculated upon all novel classes the model has been trained on.
Revised: The prediction accuracy of novel classes is calculated upon all novel classes the model has been trained on.

Original: Note that the accuracy in Table 1 and 2 is calculated upon all classes (including base and novel classes) that the model has been trained on.
Revised: Note that the accuracy in Table 1 and 2 is calculated upon all classes (including base and novel classes) that the model has been trained on.

Original: The proposed IDLVQC demonstrates strong capability of preserving old knowledge by achieving the best performance on old classes across all learning sessions.
Revised: The proposed IDLVQC demonstrates strong capability of preserving old knowledge by achieving the best performance on old classes across all learning sessions.

Original: In parallel, Imprint method performs slightly better on novel classes than IDLVQ-C in early incremental learning sessions, while IDLVQ-C outperforms Imprint method in longer incremental learning sessions.
Revised: In parallel, Imprint method performs slightly better on novel classes than IDLVQ-C in early incremental learning sessions, while IDLVQ-C outperforms Imprint method in longer incremental learning sessions.

Original: The advantage of IDLVQ-C can be attributed to the adaptive feature extractor, which is tuned in each learning session.
Revised: The advantage of IDLVQ-C can be attributed to the adaptive feature extractor, which is tuned in each learning session.

Original: shot incremental setting.
Revised: shot incremental setting.

Original: [Table]
Revised: [Table]

Revised: Novelclasses

Original:  The test accuracy on CUB dataset using 10-way 10-shot and 10-way 20-shot incremental settings are reported in Table 7 and 8, respectively.
Revised: [Table] The test accuracy on CUB dataset using 10-way 10-shot and 10-way 20-shot incremental settings are reported in Table 7 and 8, respectively.

Original: The prediction accuracy improves in all methods with more training samples per class.
Revised: The prediction accuracy improves in all methods with more training samples per class.

Original: The iCaRL and Rebalancing methods show the most signiﬁcant improvement when the number of training samples increases.
Revised: The iCaRL and Rebalancing methods show the most signiﬁcant improvement when the number of training samples increases.

Original: The proposed IDLVQ-C is effective in different incremental few-shot scenarios as it achieves the best performance on 5-shot, 10-shot and 20-shot settings.[Table] [Table] [Table]
Revised: The proposed IDLVQ-C is effective in different incremental few-shot scenarios as it achieves the best performance on 5-shot, 10-shot and 20-shot settings.

Original: [Table]

Original: [Table]

Original: [Table]

Original: 200 Number of classes 55.0% 60.0% 65.0% 70.0% 75.0% 80.0%

Original: O v e r a ll a cc u r a c y

Original: A. E XPERIMENT DETAILS FOR INCREMENTAL FEW - SHOT REGRESSION
Revised: A. E XPERIMENT DETAILS FOR INCREMENTAL FEW - SHOT REGRESSION

Original: Sinusoidal wave : A six-layer feedforward neural network with ReLU nonlinear activation is used as the feature extractor.
Revised: Sinusoidal wave : A six-layer feedforward neural network with ReLU nonlinear activation is used as the feature extractor.

Original: IDLVQ-R learns 10 reference vectors and targets from the base task. 
Revised: IDLVQ-R learns 10 reference vectors and targets from the base task. In [Table] [Table]

Revised: [Table]

Original: In each incremental learning sessions, 5 pairs of reference vectors and targets are added.
Revised: [Table] ProtoNet [Table] [Table]

Revised: [Table]

Revised: Jointtrain

Revised: [Table]

Revised: iCaRL(

Revised: [Table]

Revised: each incremental learning sessions, 5 pairs of reference vectors and targets are added.

Original: After new reference vectors and targets are ﬁne-tuned, the model is capable of make prediction for all seen tasks.
Revised: After new reference vectors and targets are ﬁne-tuned, the model is capable of make prediction for all seen tasks.

Original: 10 exemplars are selected uniformly from the training set in the base task.
Revised: 10 exemplars are selected uniformly from the training set in the base task.

Original: In the incremental learning session of the 2nd task, the model is ﬁne-tuned on 10 exemplars and 5 novel training samples.
Revised: In the incremental learning session of the 2nd task, the model is ﬁne-tuned on 10 exemplars and 5 novel training samples.

Original: After the training converges, 5 novel training samples in the current task are added to the exemplar set.
Revised: After the training converges, 5 novel training samples in the current task are added to the exemplar set.

Original: In the incremental learning session of the 3rd task, the model is ﬁne-tuned withexemplars from old tasks and 5 novel training samples.
Revised: In the incremental learning session of the 3rd task, the model is ﬁne-tuned withexemplars from old tasks and 5 novel training samples.

Original: 3D spatial data : We follow the same training and test protocols as the sinusoidal wave dataset.
Revised: 3D spatial data : We follow the same training and test protocols as the sinusoidal wave dataset.

Original: We choose 40, 15 and 15 reference vectors and targets for 1st, 2nd and 3rd tasks, respectively.
Revised: We choose 40, 15 and 15 reference vectors and targets for 1st, 2nd and 3rd tasks, respectively.

Original: Adding more reference vectors does not result in obvious improvement in accuracy in our experiments. 
Revised: Adding more reference vectors does not result in obvious improvement in accuracy in our experiments. [Figure] O v e r a ll a cc u r a c y [Figure]

Original: A. V ISUALIZATION OF IDLVQ-C
Revised: A. V ISUALIZATION OF IDLVQ-C

Original: We show the visualization of standard neural networks and IDLVQ-C with/without intra-class variation loss in Fig.
Revised: We show the visualization of standard neural networks and IDLVQ-C with/without intra-class variation loss in Fig.

Original: MNIST dataset is used as a toy example for visualization.
Revised: MNIST dataset is used as a toy example for visualization.

Original: Classes 0-7 are old classes with sufﬁcient training samples, and classes 8 and 9 are novel classes with few-shot training samples.
Revised: Classes 0-7 are old classes with sufﬁcient training samples, and classes 8 and 9 are novel classes with few-shot training samples.

Original: It can be observed in Fig. 3(a) and 3(b) that standard neural networks and IDLVQ-C (without intra-class variation loss) trained by cross-entropy loss do not have compact intra-class variation.
Revised: It can be observed in Fig. 3(a) and 3(b) that standard neural networks and IDLVQ-C (without intra-class variation loss) trained by cross-entropy loss do not have compact intra-class variation.

Original: Consequently, features of novel classes are more likely to overlap with old classes.
Revised: Consequently, features of novel classes are more likely to overlap with old classes.

Original: In this case, the performance of class-incremental learning degrades very quickly because the classiﬁer cannot distinguish between features from different classes.
Revised: In this case, the performance of class-incremental learning degrades very quickly because the classiﬁer cannot distinguish between features from different classes.

Original: In comparison, the proposed IDLVQ-C makes intra-class variation compact and leaves large margin between classes in Fig 3(c).
Revised: In comparison, the proposed IDLVQ-C makes intra-class variation compact and leaves large margin between classes in Fig 3(c).

Original: As a result, the features of novel classes are less likely to overlap existing classes.
Revised: As a result, the features of novel classes are less likely to overlap existing classes.

Original: The compact intra-class variation and large margin between classes make features of novel classes distinguishable so that learning novel classes is easier.
Revised: The compact intra-class variation and large margin between classes make features of novel classes distinguishable so that learning novel classes is easier.

Original: In addition, the margin based loss only updates the model parameters when necessary and avoids catastrophic forgetting of old classes.
Revised: In addition, the margin based loss only updates the model parameters when necessary and avoids catastrophic forgetting of old classes.

Original: [Figure]
Revised: [Figure]