Previous work of class-incremental learning for Named Entity Recognition (NER) relies on the assumption that there exists abundance of labeled data for the training of new classes. In this work, we study a more challenging but practical problem, i.e. , few-shot class-incremental learning for NER, where an NER model is trained with only few labeled samples of the new classes, without forgetting knowledge of the old ones. To alleviate the problem of catastrophic forgetting in few-shot class-incremental learning, we generate synthetic data of the old classes using the trained NER model, augmenting the training of new classes. We further develop a framework that distills from the NER model from previous steps with both synthetic data, and real data from the current training set. Experimental results show that our approach achieves significant improvements over existing baselines. Existing models of Named Entity Recognition (NER) are usually trained on a large scale dataset with predefined entity classes, then deployed for entity extraction on the test data without further adaptation or refinement. In practice, data of new entity classes that the NER model has not seen during training arrives constantly, thus it is desirable that the NER model can be incrementally updated over time with knowledge of data for these new classes. In this case, one challenge is that the training data of old entity classes may not be available due to privacy concerns or memory limitations (Ma et al., 2020). Then, the model can easily degrade in terms of the performance on old classes when being fine-tuned with only annotations of new entity classes, i.e. , catastrophic forgetting . In addressing this problem, previous work in class-incremental learning for NER (Monaikul * Corresponding Author et al., 2021) regularizes the current model by distilling from the previous model trained on old (ex-isting) classes, using text from the training dataset of new classes. However, this requires abundance of data in the new training dataset being used for distillation. Such an assumption is usually unrealistic since the token-level annotations required by NER training are labor-consuming and scarce, especially for the new unseen classes. In this paper, we study a more realistic setting, i.e. , few-shot class-incremental learning for NER, where the model ( i ) incrementally learns on new classes with few annotations, and ( ii ) without requiring access to training data for old classes. There is very limited work in few-shot class-incremental learning for NER. Such a setting is more challenging compared with class-incremental learning for NER. First, the few-shot datasets in few-shot class-incremental learning may not contain enough information for the trained model to generalize during testing. Second, it is more challenging to solve the catastrophic forgetting problem in few-shot class-incremental learning when data for old classes is not available and new data is scarce. In class-incremental learning for NER (Monaikul et al., 2021), the same training sequence may contain entities of different classes. Therefore, when the training dataset for new classes is sufficiently large, its context, i.e. , words labeled as not from entities of new classes, may also contain abundant entities of the old classes. That is, the new training data can be regarded as an unlabeled replay dataset of the existing entity classes. In such case, we can simply address the problem of catastrophic forgetting by distilling from the previous model (trained on old classes) to the current one, using text from such a replay dataset (Mon-aikul et al., 2021). However, in few-shot class-incremental learning, we cannot expect to avoid catastrophic forgetting by distilling with only the few samples from the new training dataset, since 571 there may not exist sufficient (if any) entities of the old classes. In this paper, we propose a framework to enable few-shot class-incremental learning for NER. As mentioned above, since the few-shot dataset may not contain enough entities of old classes as replay data for distilling from the previous model, which leads to catastrophic forgetting, we consider generating synthetic data of the old entity classes for distillation. Such data is termed as synthetic replay . Specifically, we generate synthetic data samples of old classes by inverting the NER model. Given the previous model trained on the old classes, we optimize the token embeddings of the synthetic data, so that predictions from the previous model can contain old entity classes, given the synthetic data as input. In this way, the synthetic data is likely to contain entities of old classes, and distilling from the previous model with such data will thus encourage knowledge preservation of old classes. Additionally, to ensure the synthetic (reconstructed) data to be realistic, we propose to leverage the readily available real text data for new classes, via adversarially matching the hidden features of tokens from the synthetic data and those from the real data. Note that the synthetic data generated from such adversarial match with real data will contain semantics that are close to the real text data for new classes. Consequently, compared with training with only the few samples of new classes, the synthetic data will provide more diverse context that are close to the samples of the few-shot dataset, augmenting the few-shot training for the new classes. Further, with the generated synthetic data, we propose a framework that trains the NER model with annotations of the new classes, while distilling from the previous model with both the synthetic data and real text from the new training data. Our contributions of this work are summarized as follows:  We present the first work of studying few-shot incremental learning for Named Entity Recognition (NER), a more practical but challenging problem compared with class-incremental learning for NER. We approach the problem by proposing a framework that distills from the existing model with both, real data of new entity classes and synthetic data reconstructed from the model as replay data of old entity classes. Experiments show that our method significantly improves over existing baselines for the task of few-shot class-incremental learning in NER. Assume there is a stream of NER datasets D 1 , . . . , D t , . . . , annotated with disjoint entity classes, where t is the time step and D t = { ( X ti , Y ti ) } |D t | i =1 contains c t entity classes. Here X ti = [ x ti, 1 ,    , x ti,N i ] and y ti = [ y ti, 1 ,    , y ti,N i ] are the NER token and label sequences, respectively, with length N i , and |D t | is the size of the dataset. Dataset D 1 is the base dataset, assumed of reasonably large size for classes of step t = 1 . The datasets {D t } t> 1 are the few-shot datasets with about K samples for each class. In few-shot class-incremental learning, the NER model will be incrementally trained with D 1 , D 2 , . . . , over time, with data from D t only available at the t th time step. After being trained with D t , the model will be evaluated jointly on all entity classes encountered in D 1 ,    , D t , i.e. , we do not learn separate prediction modules for each time step. Figure 1 shows an example of annotations for different incremental learning steps on classes of PER , LOC , and TIME . In Figure 1, we should note that tokens that are labeled as O in the current step are likely to contain abundant entities from the previous classes. For instance, tokens annotated as O in step 3 include entities of previous classes, i.e. , PER and LOC . Therefore, when a large amount of training data is available for the new classes, the new dataset can be regarded as unlabeled replay data of previous classes. As an example, in Monaikul et al. (2021), 572 (a) London was attacked in 1943 . (b) Figure 2: (a) An example of L syn of Eq (4) at step 3 of Figure 1. (b) An example of distilling with D t at step 3 of Figure 1. M 2 and M 3 are models from step 2 and 3, respectively. We replace the predictions on the position of 1943 from M 2 with the correct annotation, TIME, from D 3 before training on M 3 . their performance of class-incremental learning on CoNLL2003 has been comparable or even better than training with full annotations of all the classes encountered, by just distilling with the training data of the new classes. However, in few-shot class-incremental learning, the few training samples of the current step may not contain enough entities of the previous classes. In Section 4, we also discuss the difference between few-shot class-incremental and few-shot learning for NER. Following Beltagy et al. (2019); Souza et al. (2019), we use the BERT-CRF as our NER model, which consists of a BERT base (Devlin et al., 2018) encoder with a linear projection and a conditional random field (CRF) (Lafferty et al., 2001) layer for prediction. We denote M t as the NER model for step t . M t is initialized from M t  1 to preserve knowledge of old classes. For time step t > 1 , M t is expected to learn about the new classes from D t , while not forgetting the knowledge from {D k } t  1 k =1 . Assume we have already obtained a synthetic dataset D tr = { E t,ri , Y t,ri } |D tr | i =1 of previous entity classes from {D k } t  1 k =1 , where E t,ri = [ e t,ri, 1 ,    , e t,ri,N i ] and Y t,ri = [ y t,ri, 1 ,    , y t,ri,N i ] are the reconstructed token embeddings and reference label sequence. Y t,ri is a randomly sampled label sequence containing classes from the previous steps and E t,ri is optimized so the output from M t  1 with E t,r i matches Y t,ri . We will discuss the construction of the synthetic D tr in Section 3.2. Given the current training data D t and M t  1 that has been trained on D t  1 , we propose to train M t by distilling from M t  1 with both the real data from D t and synthetic data from D tr . The challenge of such distillation is that the predictions from M t and M t  1 are likely to contain different set of labels, i.e. , M t should also predict with the new entity classes from D t . This is different from the standard setting of distillation, where the teacher and student models share the same label space (Hinton et al., 2015). In tackling such a problem of label space discrepancy, we propose separate approaches of distillation for D t and D tr , respectively. The distillation from M t  1 to M t involves matching the output distributions between M t to M t  1 . However, given an input sequence X from D t , the CRF layer outputs correspond to a sequence-level distribution P  ( Y | X ) , i.e. , probabilities for all possible label sequences of X , the cardinality of which, grows exponentially large with the length of X . Therefore, it is infeasible to match with the exact output distributions of CRF. Following the current state-of-the-art approach of NER distillation (Wang et al., 2020b), we approximate the sequence-level output distribution of CRF with only its top S predictions. Specifically, for model M t  1 , we have,  PM t  1 ( Y | X ) = [ PM t  1 (  Y 1 | X ) , . . . , (1) PM t  1 (  YS | X ) , 1  S (cid:88) s =1 PM t  1 (  Y s | X )] , where {  Y s } Ss =1 are the top S most probable predictions of label sequence from M t  1 . We set S = 10 . In this way, the output from the CRF of M t  1 becomes tractable. However, M t still cannot be trained with such an output from M t  1 . This is because M t  1 was not trained with the 573 new classes in D t . Therefore, when X is from D t , M t  1 will have wrong predictions on the tokens labeled as being from entities of new classes. In order to distill with M t  1 , we propose a correction for {  Y s } Ss =1 . Figure 2(b) shows an example of such a process. Specifically, on the positions of the sequence where D t has labeled as new classes, we replace the predictions in {  Y s } Ss =1 with the annotations from D t . We denote the corrected set of predictions as {  Y cs } Ss =1 . For training of M t , we first calculate the predicted distribution of M t with respect to {  Y cs } Ss =1 , as  PM t ( Y | X ) =[ PM t (  Y c 1 | X ) ,    , PM t (  Y cS | X ) , 1  S (cid:88) s =1 PM t (  Y cs | X )] , (2) where we compute the predicted probabilities from M t with regard to {  Y cs } Ss =1 from M t  1 . Then, M t can be trained by minimizing the cross entropy between  PM t  1 ( Y | X ) and  PM t ( Y | X ) via L real ( D t ) = (3)  1 | D t | (cid:88) X  D t CE (  PM t  1 ( Y | X ) ,  PM t ( Y | X )) , where CE (  ,  ) is the cross entropy function. Note that the definition of O is different in M t  1 and M t . Take Figure 2(b) as an example, the prediction of O in step 2 corresponds to both O and TIME for step 3, since TIME is not in the target entity classes of step 2. However, from the annotation of step 3, we know that tokens annotated as O are not TIME . Therefore, we can safely assume that the prediction of O in {  Y cs } Ss =1 from M 2 matches the definition of O in M 3 , i.e. , the semantics of O in {  Y cs } Ss =1 is the same for M t and M t  1 . Different from data in D r , in which we know tokens annotated as O are not from the new classes, data from D tr is reconstructed from M t  1 and only contains labels for the previous classes. Any token predicted with "O" from M t  1 can be potentially labeled as O or the new classes by M t . Therefore, with D tr , it is unclear how to correct the output of CRF from M t  1 , i.e. {  Y s } Ss =1 , for training of M t . By considering the above, we resort to another approach that decomposes the output from CRF, i.e. , sequence level label distribution, into marginal label prediction for each token, using the forward and backward method in Lafferty et al. (2001). Figure 2(a) shows a graphic example of our distillation loss L syn with D tr . Specifically, let C t be the cumulative number of possible labels for any given token in NER at step t , i.e. , C t = (cid:80) tk =1 c t , with c t be the number of class in D t . For each token with embedding e , we define p te = [ p te,O ; p te,C t  1 ; p te,c t ] and p t  1 e = [ p t  1 e,O ; p t  1 e,C t  1 ] as the predicted marginal distribution of a token from M t and M t  1 , respectively. p te,O , p t  1 e,O  R are the probabilities for class O , whereas p te,C t  1 , p t  1 e,C t  1  RC t  1 are the probabilities for entity classes encountered up to step t  1 . Further, p te,c t  R c t are probabilities for the new classes in step t . Since O from step t  1 corresponds to the O and the c t new classes in step t, we first collapse p te by computing  p te = [sum( p te,O , p te,c t ); p te,C t  1  1 ] , where we merge the predictions of O and c t new classes. In this way,  p te will have the same dimension as p t  1 e . Let E tr be the set of embeddings for all tokens contained in D tr . The distillation loss for D tr is L syn ( D tr ) = E e  E tr KL( p te || p t  1 e ) , (4) where KL( || ) is the KL divergence. where L real (  ) and L syn (  ) corresponds to distillation with the real data in D t and synthetic data in D tr , respectively, and  is a parameter balancing between the losses for D t and D tr . We set  = 1 in the experiment. Now we describe how to reconstruct D t r from M t  1 . Given a randomly sampled label sequence Y containing the old entity classes from {D k } k<t , we seek to reconstruct the embedding sequence E corresponding to its training data. In doing so, we randomly initialize embeddings E , then optimize the parameters of E with gradient descent so that its output with M t  1 matches the expected label sequence Y . Formally, we optimize E by minimizing the training loss of the CRF as L crf =  log PM t  1 ( Y | E ) . result in a domain gap of training on the synthetic data of old entities but testing on the real data. To alleviate this problem, we propose to encourage synthetic data to be more realistic by leveraging the real data from D t . Let h t  1 ,syn l ( E tr ) be the hidden state from the l th layer of the BERT encoder in M t  1 , regarding the set of synthetic token embeddings, E tr . Similarly, let h t  1 ,real l ( emb ( X t )) be the output hidden states from the l th layer of M t  1 , regarding the set of real tokens, X t , from D tr . Moreover, emb (  ) is the embedding layer. We propose to adversarially match h t  1 ,syn l ( E tr ) and h t  1 ,real l ( emb ( X t )) so that hidden states from the real and synthetic are not far away from each other. In this way, the reconstructed embeddings from D tr are likely to be more realistic. Specifically, let M l be a binary discriminator module, i.e. , one layer linear projection with sigmoid output, whose inputs are the real and synthetic hidden states, M  l = argmin M l  E h  h t  1 ,syn l ( E tr ) log M l ( h )  E h  h t  1 ,real l ( emb ( X t )) log(1  M l ( h )) , L advl = E h  h t  1 ,syn l ( E tr ) log(1  M  l ( h )) . (7) Finally, the loss for reconstructing D tr is L r = L crf +  (cid:88) l  l s L ladv , (8) where l s = 2 , 4 ,    , 12 , i.e. , we match every two layers of the BERT encoder in M t  1 . is a balancing parameter and is default to 10 in the experiment. Since we train M t with the reconstructed token embeddings from M t  1 , we freeze the BERT token embedding layer during training, so that M t  1 and M t can share the same token embeddings. This is also reasonable for the setting of few shot learning, since tuning all the model parameters with few samples will result in overfitting. Another problem we should consider is that the real data D t and synthetic data D tr may contain different sets of entity classes , i.e. , the few-shot dataset D t may not contain entities of old classes in D tr . In this case, for the token embeddings of old classes in D tr , s.t. , { e i,j | y t,ri,j  = O } , matching the hidden states of these embeddings with those from D t will distract these embedding from being optimized into the entities of old classes, which we will show in the experiments. Therefore, we overload the definition of E tr in (4) by excluding embeddings of the old entity classes in D tr from matching, i.e. , E tr = { e i,j | y t,ri,j = O } , while X t contains all the real tokens from D t . Algorithm 1 shows the complete procedure for constructing D tr . Since D tr contains entities of old classes from previous steps, distilling with L syn ( D tr ) will help preserving knowledge of old entity classes, i.e. , avoiding catastrophic forgetting, without accessing the real data from previous steps. Additionally, with D tr , M t is no longer trained with only few samples from D t , thus is less likely to overfit. This is because D tr can construct a relative larger scale, e.g. , several thousand sentences, within the computation limit. Additionally, the semantics of D tr can be close to D t , since their token embeddings are closely matched. Thus, compared with training only with D t , D tr provides more diverse text information for M t during training. Moreover, the entity of old classes from D tr can be regarded as negative samples for training of the new classes in D t , thus reducing the confusion between old and new classes for M t during training. Class-Incremental Learning : Different from continual learning, e.g. , (Hu et al., 2018), which sequentially learn on different tasks (usually with different classes) and requires task labels for prediction, class-incremental learning aims at jointly predicting with all the encountered classes without knowing task labels. Sun et al. (2019); Ke et al. (2021) have study continual learning for different tasks of NLP. Recently, Monaikul et al. (2021) studies class-incremental learning for NER, building a unified NER classifier for all the classes encountered over time. There are two problems regarding this method. Firstly, Monaikul et al. (2021) only works with a non-CRF-based model. However, many current state-of-the-art NER models are built with a CRF module (Liu et al., 2019; Chen et al., 2020; Wang et al., 2021). Secondly, it assumes that a large amount of data for the new classes is available, which is unrealistic since annotations for unseen classes are usually scarce. In this work, we assume only few-shot datasets are available for the new classes, i.e. , few-shot class-incremental learning, which was proposed in Tao et al. (2020); Mazumder et al. (2021), yet not studied in NER. Also, note that class-incremental learning is different meta-learning with episode training (Ding et al., 2021; Finn et al., 2017), since tasks/classes of meta-leaning may appear multiple times in episode 575 training, while we assume the dataset of each class only appear once in class-incremental learning. Few-Shot Learning : Models of few-shot learning are generally trained with a base dataset, then learned to predict unseen target classes with few samples. One branch of the works is based on metric learning. These generally involves predicting by learning to compare token features with class prototypes (Hou et al., 2020) or stored query samples (training data) of target classes (Yang and Katiyar, 2020). The latter violates our setting of class-incremental learning, for which it is prohibitive to store the training data for e.g. , privacy issue. Alternatively, Huang et al. (2020) avoids overfitting of few-shot learning by augmenting with noisy or unlabeled data from the web. Our approach is similar to Huang et al. (2020), in that we also augment few-shot training of the current step with additional data, except we use generated synthetic instead of real data. Recently, (Cui et al., 2021) proposes Template NER , a few-shot friendly model for NER that convert NER into a sequence-to-sequence problem. Our few-shot class-incremental learning is different from few-shot learning in that i) Few-shot learning requires data of different classes arrives at the same time and with complete annotations for all the target classe, while data of few-shot class-incremental learning arrives sequentially, containing annotation of only classes of the current step. ii) Existing works of few-shot NER build separate prediction modules for the target and base classes and ignore the performance of base classes during evaluation, thus incompatible with class-incremental learning. Data-Free Distillation : Data-free distillation refers to the case in which we distill from a teacher model to a student model with the training data of the teacher not available. A typical solution is to reconstruct synthetic training data from the trained teacher model for distillation. Such a setting was previously explored for model compression of image classification (Yin et al., 2020) and text classification (Ma et al., 2020). However, it has not been studied for NER scenarios. We use data-free distillation for transferring knowledge between models from the current and previous steps for few-shot class-incremental learning. Following the previous work of class-incremental learning for NER (Monaikul et al., 2021), we experiment with two datasets: CoNLL2003 and Ontonote 5.0. For CoNLL2003, our results are average over eight ordering of entity classes for each step as in Monaikul et al. (2021). For Ontonote 5.0, we rank the entities in alphabetic order and experiment with two combinations of different entity classes for different steps. Table 3 and 4 in the Appendix list the entity classes used for each step. Since CoNLL2003 is a relative smaller dataset, we conduct both 5-shot and 10-shot experiments for CoNLL2003 and 5-shot experiments for OntoNote 5.0. Following Yang and Katiyar (2020), our base datasets, i.e. , dataset of step 1, is the training data of CoNLL2003 and OntoNote 5.0, labeled with only entity classes included in step 1. The few-shot datasets are sampled from the evaluation dataset with greedy sampling (Yang and Katiyar, 2020). The resulting NER model of each step is tested on the entire test set. Please refer to the Appendix for addition details. We compare with the state-of-the art work of class-incremental learning for NER ( CI NER ). Additionally, we implement EWC++ (Chaudhry et al., 2018) with  = 0 , i.e. , using weights regularization to avoid forgetting instead of generating synthetic data. We also implement FSLL (Mazumder et al., 576 1 2 3 4 5 6 7 8 9 Steps 10 20 30 40 50 60 70 80 F 1 S c o r e CI NER EWC++FSLLL-TapNet+CDTTemplate NER AS-DFDOurs 2021), a state-of-the-art method of few-shot class-incremental learning for image classification with metric learning. As mentioned in the related work section, our method can be considered as data-free distillation. Therefore, we also include AS-DFD (Ma et al., 2020), the state-of-the-art method of data-free distillation in text classification . Specifically, we construct D tr with the adversarial regularization described in AS-DFD instead of (8). We also adapt L-TAPNet+CDT (Hou et al., 2020) for comparison. L-TAPNet+CDT is a state-of-the-art work of few-shot learning for sequence labeling with CRF module. Please refer to Appendix for how we adapt it for class-incremental learning. As an ablation study, we compare our method with: i) Ours (  = 0 ) , only train with only D t with  = 0 . ii) Ours (  = 0 , marg) , which is also training with  = 0 . The difference is that instead of using the sequence-level distillation with L real ( D t ) , we decompose the output of CRF into marginal predictions for each token, as described before (4). In this way, we can directly apply the token-level distillation in CI NER (Monaikul et al., 2021) for the CRF-based NER model. Compared with Ours (  = 0 ) , this is included to show the performance of directly applying token-level distillation for CRF-based model. iii) In Ours (  = 0 ) , we examine the usefulness of L adv by setting  = 0 . iv) Ours (all tokens) , which matches all the synthetic tokens in D tr with real tokens in D t , instead of matching with only those labeled as O in D tr , as described after eq (8). Table 1 and 2 show the F1 scores from different steps of few-shot class-Incremental learning on CoNLL2003. The values are averaged over eight permutations as in (Monaikul et al., 2021). Our methods outperform all the considered baselines for both 5-shot and 10-shot learning. Especially, CI NER (Monaikul et al., 2021) has the worst result among all the methods. This is because the performance of CI NER relies on a large amount of data from D t for replay of previous entities. Therefore, it does not work well in the few-shot scenario, where D t with only few samples may not contain entities of old classes for replay. Additionally, we find that the performance of AS-DFD (Ma et al., 2020) is slightly lower than Ours (  = 0 ) , i.e. , 577 distilling using data reconstructed with only L crf . AS-DFD is designed for text classification, where they use the feature of the special token [CLS] from BERT for classification, while features of the non-special tokens (within text) are trained with an augmented task of language modeling. However, in NER, features of the non-special tokens are directly used for prediction. Thus, simultaneously training such features with language modeling may distract the model from learning the task specific information needed for NER. In the ablation study, we find that our adversarial matching indeed improves the quality of the synthetic data ( Ours vs . Ours (  = 0 ) ), especially when excluding tokens of the reconstructed old entities from matching ( Ours vs . Ours (all tokens) ). Further, Ours (  = 0 , marg) has lower performance than Ours (  = 0 ) , showing that it might not be optimal to directly apply CI NER (Monaikul et al., 2021) with CRF based models. Figure 3 shows the results of class-incremental with OntoNote 5.0. Since there are more steps relative to the experiments for CoNLL2003, following previous works in few-shot class-incremental learning (Tao et al., 2020; Mazumder et al., 2021), we plot the F1 scores as curves, to highlight the relative difference of different methods over time. Our method consistently outperforms the baselines. Note that with larger number of steps of incremental learning, the curves may not be necessarily monotonically decreasing. This may indeed happen because training with some classes can benefit the performance of other downstream classes, thus 2 4 6 8 10 12 14 16 Value of 0 1 2 3 4 5 6 G a i n o n F 1 s c o r e s Step 2 Step 3 Step 4 Average Figure 5: F1 score gains of 10-shot learning with different values of  on CoNLL2003, relative to  = 0 . (locally) increasing the overall performance. In Appendix, we also present the ablation study with OntoNote 5.0. Figure 4 shows the t-sne plots of hidden states of tokens from 10-shot LOC  PER (explained in the caption). In (a), we can find that there are synthetic tokens that are very close to the real LOC tokens (green dots in the black ellipse). These synthetic tokens (within the black ellipse) are the reconstructed LOC . On the contrary, the synthetic context, i.e. , the rest of the synthetic tokens outside the ellipse, are far away from the real distribution. This may because the context contains more diverse information, which makes it more difficult to be reconstructed. Such a difference between real and synthetic tokens may cause a domain shift between training and testing, since we are training on synthetic token and testing on real tokens. Note that there is no tokens from D 2 (red dots) in the black ellipse of LOC , indicating that there may not be LOC entities in the few-shot dataset D 2 , unlike in non-few-shot learning where D 2 can contain a lot of entities of the old classes ( LOC ). (b) shows the result of matching all the synthetic tokens from D 2 r with all the real ones from D 2 . In this way, most of the synthetic tokens are matched with the real ones, except that only few synthetic tokens are aligned with the real LOC tokens. This is because the few-shot dataset D 2 may not contain entities from the old classes LOC . In this case, the adversarial matching will distract synthetic tokens from being reconstructed as LOC . Then, the reconstructed embedding sequences will contain less information from the old classes ( LOC ). In (c), we exclude synthetic tokens that are intended to be reconstructed as the old class LOC , i.e. , labeled as LOC in the target label sequence Y in Algorithm 1. As a result, the synthetic tokens contain both LOC and context that is aligned with the real distribution. We investigate the relationship between model performance and the value of  , i.e. , the parameter controlling the degree of adversarial matching. Figure 5 shows the the F1 scores from different steps on CoNLL2003, with different values of  . We experiment with 10-shot and report the gain of F1 score compared with  = 0 . We noticed that there is positive gain of the average F1 score on the whole experiment for a range of  values, i.e. , [1 , 16] . These results demonstrate that the proposed adversarial matching between the real and synthetic data ( D t and D tr ) is generally beneficial and is not sensitive to the selection of  . We present the first work of few-shot class-Incremental learning for NER To address the problem of catastrophic forgetting, we proposed to reconstruct synthetic training of the old entity classes from the model trained at the previous time step. Additionally, the synthetic data allows the model to be trained with a more diverse context, thus less likely to overfit to the few training samples of current step. Experimental results showed that our method outperforms the baselines, enabling the NER model to incrementally learning from new classes with few samples. This work was carried out during an internship at Adobe Research. Further, it was supported by NIH (NINDS 1R61NS120246), DARPA (FA8650-18-2-7832-P00009-12) and ONR (N00014-18-1-2871-P00002-3). We thank all the researchers involved from Adobe Research and the support from Duke University.
abstain objective objective objective result abstain abstain abstain abstain abstain abstain abstain objective abstain abstain abstain abstain abstain abstain abstain method objective objective method abstain method method abstain objective abstain abstain objective objective objective result other other other other other method other abstain other other other other other other other method other other abstain method abstain abstain abstain other abstain abstain abstain abstain abstain abstain abstain abstain abstain method other abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain other other abstain abstain abstain method abstain abstain abstain method abstain abstain abstain method abstain abstain abstain abstain abstain abstain abstain abstain abstain method method method abstain abstain abstain abstain abstain abstain abstain other abstain abstain method abstain method abstain abstain abstain abstain abstain abstain abstain abstain abstain other other other other other other other abstain method other other other abstain other abstain other abstain other other abstain other other other method abstain abstain result abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain result abstain abstain abstain result abstain abstain abstain abstain result abstain abstain abstain abstain result result abstain other abstain abstain abstain abstain result abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain result abstain abstain abstain abstain abstain objective abstain objective other other other