Teamwork Is Not Always Good: An Empirical Study of Classifier Drift in Class-incremental Information Extraction
Year: 2023

Abstract:
Class-incremental learning (CIL) aims to develop a learning system that can continually learn new classes from a data stream without forgetting previously learned classes. When learning classes incrementally, the classifier must be constantly updated to incorporate new classes, and the drift in decision boundary may lead to severe forgetting. This fundamental challenge, however, has not yet been studied extensively, especially in the setting where no samples from old classes are stored for rehearsal. In this paper, we take a closer look at how the drift in the classifier leads to forgetting, and accordingly, design four simple yet (super) effective solutions to alleviate the classifier drift: an Individual Classifiers with Frozen Feature Extractor (ICE) framework where we individually train a classifier for each learning session, and its three variants ICE-PL, ICE-O and ICE-PL&O which further take the logits of previously learned classes from old sessions or a constant logit of an Other class as constraint to the learning of new classifiers. Extensive experiments and analysis on 6 class-incremental information extraction tasks demonstrate that our solutions, especially ICE-O, consistently show significant improvement over the previous state-of-the-art approaches with up to 44.7% absolute F-score gain, providing a strong baseline and insights for future research on class-incremental learning.1

heading: 1 Introduction
text: Conventional supervised learning assumes the data are independent and identically distributed (i.i.d.) and usually requires a pre-defined ontology, which may not be realistic in many applications in natural language processing (NLP). For instance, in event detection, the topics of interest may keep shifting over time (e.g., from attack to pandemic), and new event types and annotations could emerge
1The source code, model checkpoints and data are publicly available at https://github.com/VT-NLP/ICE.
incessantly. Previous studies (Ring et al., 1994; Kirkpatrick et al., 2017; Lopez-Paz and Ranzato, 2017) therefore proposed continual learning (CL), a.k.a., lifelong learning or incremental learning, a learning paradigm aiming to train a model from a stream of learning sessions that arrive sequentially. In this work, we focus on the class-incremental learning (CIL) setting (Wang et al., 2019), where a new session2 is composed of previously unseen classes and the goal is to learn a unified model that performs well in all seen classes.
When new learning sessions arrive sequentially, the classification layer must be constantly updated and/or expanded to accommodate new categories to the model. The change of the classifier between different sessions, i.e., classifier drift, can disturb or overwrite the classifier trained on previous classes, which consequently causes catastrophic forgetting (Biesialska et al., 2020). On the other hand, in many NLP tasks such as information extraction, the model also needs to classify nega-
2Session is defined as an incremental learning stage to learn new classes with a model trained on the previous sessions.
2241
tive instances into the Other type (i.e., none-of-theabove). The Other type adds extra difficulty to classification, and even worse, the meaning of Other varies as the model learns new sessions (Zheng et al., 2022). The CIL problem thus becomes even more challenging when Other is involved. We illustrate the event detection task in CIL (Yu et al., 2021) and the classifier drift problem in Figure 1.
Despite the progress achieved in CIL (Zhao et al., 2022; Zheng et al., 2022), there are two critical limitations that are still remained: (1) Most previous CIL approaches heavily rely on the rehearsalbased strategy which stores samples from previously learned sessions and keeps re-training the model on these examples in subsequent sessions to mitigate catastrophic forgetting, which requires high computation and storage costs and raises concerns about privacy and data leakage (Shokri and Shmatikov, 2015); (2) Previous approaches have mainly focused on regularizing or expanding the overall model, especially feature extractor, to tackle the forgetting issue (Cao et al., 2020), but they rarely investigate whether the drift of the classifier also leads to forgetting, especially in classification tasks that involve the Other category. In this work, we aim to tackle these limitations by answering the following two research questions: RQ1: how does classifier drift lead to forgetting in the setting where no samples are stored from old sessions for rehearsal?, and RQ2: how to devise an effective strategy to alleviate classifier drift, especially when there is an Other category involved?
In this paper, we aim to answer the two research questions above. First, to study how classifier drift alone affects the model, we build a baseline where we use a pre-trained language model as a fixed feature extractor, such that only the parameters in the classification layer will be updated. Second, to alleviate classifier drift, we propose a simple framework named Individual Classifiers with Frozen Feature Extractor (ICE). Instead of collectively tuning the whole classification layer, we individually train a classifier for the classes in each new session without updating old classifiers and combine all learned classifiers to classify all seen classes during inference. As individually trained classifiers may lack the context of all learned sessions (Zhang et al., 2021), they may not be comparable to each other. We further devise a variant ICE-PL which takes the logits of previous classifiers as constraints to encourage contrastivity among all the classes when
learning a new classifier for a new session. Third, both ICE and ICE-PL cannot be applied to detection tasks where an Other class is involved, thus we further design two variants of them: ICE-O and ICE-PL&O, which introduce a constant logit for the Other class and use it to enforce each individual classifier to be bounded by a constraint shared across different learning sessions during training.
We extensively investigate the classifier drift and evaluate our approach on 6 essential information extraction tasks across 4 widely used benchmark datasets under the CIL setting. Our major findings and contributions are: (1) By comparing the drifted baseline and our ICE, we find that the classifier drift alone can be a significant source of forgetting and our approaches effectively mitigate the drift and forgetting. Our results reveal that training the classifier individually can be a superior solution to training the classifier collectively in CIL. (2) We find that the Other type can effectively improve individually trained classifiers, and it is also helpful when we manually introduce negative instances during training on the tasks that do not have Other. (3) Experimental results demonstrate that our proposed approaches, especially ICE-O, significantly and consistently mitigate the forgetting problem without rehearsal and outperform the previous stateof-the-art approaches by a large margin. (4) Our study builds a benchmark for 6 class-incremental information extraction tasks and provides a superstrong baseline and insights for the following studies on class-incremental information extraction.

heading: 2 Related Work
text: Existing approaches for CIL can be roughly categorized into three types (Chen et al., 2022). Rehearsal-based approaches (a.k.a. experience replay) (Lopez-Paz and Ranzato, 2017; de Masson d’Autume et al., 2019; Guo et al., 2020; Madotto et al., 2021; Qin and Joty, 2021) select some previous examples (or generate pseudo examples) for rehearsal in subsequent tasks. While such approaches are effective in mitigating forgetting, they require high computation and storage costs and suffer from data leakage risk (Shokri and Shmatikov, 2015; Smith et al., 2021; Wang et al., 2022). Regularization-based approaches (Chuang et al., 2020) aim to regularize the model’s update by only updating a subset of parameters. Architecturebased approaches (Lee et al., 2020; Ke et al., 2021a,b,c; Feng et al., 2022; Zhu et al., 2022) adap-
tively expand the model’s capacity via parameterefficient techniques (e.g., adapter, prompt) to accommodate more data. While most existing approaches consider alleviating the forgetting of the whole model or transferring previous knowledge to new sessions, few of them thoroughly investigate how the classification layer of the model is affected as it expands to incorporate more classes into the model. Wu et al. (2019) find that the classification layer has a strong bias towards new classes, but they only study this issue in image recognition that doesn’t contain the Other class. To fill the blank in current research, we aim to take a closer look at how the drift in the classifier alone affects the model under the CIL setting, especially when Other is involved.
For class-incremental information extraction, several studies tackle the CIL problem in relation learning (Wu et al., 2021), and many of them apply prototype-based approaches equipped with memory buffers to store previous samples (Han et al., 2020; Cui et al., 2021; Zhao et al., 2022). Others investigate how to detect named entities (Monaikul et al., 2021; Xia et al., 2022) or event trigger (Cao et al., 2020; Yu et al., 2021; Liu et al., 2022) in the CIL setting. For instance, Zheng et al. (2022) propose to distillate causal effects from the Other type in continual named entity recognition. One critical disadvantage of existing approaches for continual IE is they heavily rely on storing previous examples to replay, whereas our method does not require any examplar rehearsal.

heading: 3 Problem Formulation
text: Class-incremental learning requires a learning system to learn from a sequence of learning sessions D = {D1, ...,DT } and each session Dk = {(xk, yk)|yk ∈ Ck} where xk is an input instance for the session Dk and yk ∈ Ck denotes its label. The label set Ck for session Dk is not overlapping with that of other sessions, i.e., ∀k, j and k ̸= j, Ck
⋂ Cj = ∅. Given a test input x and a model that has been trained on up to t sessions, the model needs to predict a label ŷ from a label space that contains all learned classes, i.e., C1 ⋃ ... ⋃ Ct and optionally the Other class. Generally, the training instances in old classes are not available in future learning sessions.
We consider a learning system consisting of a feature extractor and a classifier. Specifically, we use a linear layer G1:t ∈ Rc×h as the classification
layer, where c is the number of classes that the model has learned up to session t and h is the hidden dimension size of features. We denote the number of classes in a learning session k as nk, i.e., nk = |Ck|. The classification layer G1:t can be viewed as a concatenation of the classifiers in all learned sessions, i.e., G1:t = [W1; ...;Wt], where each of the classifier Wk ∈ Rnk×h is in charge of the classes in Ck. The linear layer outputs the logits o1:t ∈ Rc for learned classes, where ok refers to the logits for the classes in Ck. The term logit we use in this paper refers to the raw scores before applying the Softmax normalization.
In this work, we focus on studying the classincremental problem in information (entity, relation, and event) extraction tasks.We consider two settings for each task: the detection task that requires the model to identify and classify the candidate mentions or mention pairs into one of the target classes or Other, and the classification task that directly takes the identified mentions or mention pairs as input and classifies them into the target classes without considering Other.

heading: 4 Approach

heading: 4.1 RQ1: How does Classifier Drift Lead to Forgetting?
text: We first design a DRIFTED-BERT baseline to investigate how classifier drift alone leads to forgetting, and then provide an insightful analysis of how classifier drift happens, especially in the setting of class-incremental continual learning.
DRIFTED-BERT Baseline In the current dominant continual learning frameworks, both the feature extractor and classifier are continually updated, which results in drift in both components towards the model’s predictions on old classes. To measure how the classifier drift along leads to forgetting, we build a simple baseline that consists of a pretrained BERT (Devlin et al., 2019) as the feature extractor and a linear classification layer (shown in Figure 2 (a)). The model first encodes a given input text x into the contextual representation. For event trigger and entity recognition, the model feeds the representation of a candidate span h into the linear layer to predict the logits for learned classes, i.e., o1:t = G1:t(h). For relation learning, we instead use the concatenation of head and tail representations as the feature, i.e., h = [hhead;htail]. For detection tasks, since each session contains an Other
class which has different meanings from other sessions, we follow (Yu et al., 2021) to set the logit for Other to a constant value δ, i.e., o0 = δ. We combine o0 and o1:t and pick the label with the maximum logit as the prediction. That is, we predict a sample as Other if and only if max(o1:t) < δ. We freeze the parameters in the feature extractor so that the encoded features of a given sample remain unchanged in different learning sessions. In this way, the updates in the classification layer become the only source of forgetting. Note that we do not apply any continual learning techniques (e.g., experience replay) to DRIFTED-BERT. We denote p(xt) as the predicted probability to compute the loss in training, where p(xt) = Softmax(o0:t). At the learning session t, the model is trained on Dt with the Cross Entropy (CE) loss:
LCE = − ∑
(xt,yt)∈Dt log p(xt). (1)
A Closer Look at Classifier Drift When the model has learned t sessions and needs to extend to the (t + 1)-th session, the classification layer G1:t needs to introduce new parameters to accommodate the new classes in Ct+1, i.e., G1:t+1 = [W1; ...;Wt;Wt+1]. As we assume that all previous training instances in D1:t are not accessible anymore, solely training the model on Dt+1 would lead to an extreme class-imbalance problem (Cao et al., 2020), which consequently causes catastrophic forgetting. However, most existing works rarely discuss how the drift in the classifier alone leads to forgetting, especially when the Other class is involved.
We first define the classifier drift between two consecutive learning sessions Dt and Dt+1 as the change from G1:t to G1:t+1 that makes the model
lose (part of) its acquired capability on the seen classes in C1:t. Intuitively, the CE loss aims to maximize the probability of the correct label while minimizing the probabilities of all other labels. Thus, there are two possible causes of classifier drift: (1) new logit explosion: the new classifier Wt+1 tends to predict logits ot+1 that are higher than those of all previous classes o1:t so that the model can trivially discriminate new classes, which causes the old classes being overshadowed by new classes. (2) diminishing old logit: as the old instances are not accessible in future learning sessions, the parameters in previous classifiers will be updated from the previous local optimum to a drifted sub-optimum, such that the classifier outputs low logits for old classes and cannot predict correctly. We empirically analyze the DRIFTED-BERT baseline to investigate the classifier drift in Section 5.2 and discuss the drifting patterns in different classification and detection tasks in Section 5.4.

heading: 4.2 RQ2: How to Alleviate Classifier Drift?
text: To alleviate the classifier drift, we introduce two solutions ICE and its variant ICE-PL for the classification tasks without Other, and further design two additional variants ICE-O and ICE-PL&O for detection tasks where Other is involved. We illustrate the training process in a new learning session for ICE and its variants in Figure 2. Note that we only focus on the setting of continual learning without experience replay, i.e., the model does not have access to the data of old sessions.
ICE: Individual Classifiers with Frozen Feature Extractor We revisit the idea of classifier ensemble (Dietterich, 2000) and separated output layers in multi-task learning (Zhang and Yang, 2018) where task-specific parameters for one task do not
affect those for other tasks. Inspired by this, we propose to individually train a classifier for each session without updating or using previously learned classifiers G1:t (shown in Figure 2 (b)). In this way, previous classifiers can avoid being drifted to the sub-optimum, and the new classifier is less prone to output larger logits to overshadow old classes. Specifically, for an incoming session t + 1, we initialize a set of new weights and train the new classifier Wt+1 on Dt+1. We only use the logits for the classes in the new session ot+1 to compute the Cross-Entropy loss in optimization, i.e., p(xt+1) = Softmax(ot+1). During inference, as we need to classify all seen classes without knowing the session identity of each instance, we combine the logits from all classifiers W1, ...,Wt+1 together to get the prediction for all learned classes, i.e., o1:t+1 = [o1; ...; ot+1], where each classifier yields the logits via ok = Wk ·h given the encoded feature h for each mention.
ICE+Previous Logits (ICE-PL) One limitation of ICE is the classifier individually trained in one session may not be comparable to others. To provide contrastivity to classifiers, we first explore a variant named ICE-PL where we preserve the previous classifiers and only freeze their parameters, such that the new classifier is aware of previous classes during training (shown in Figure 2 (c)). That is, the model uses the logits from all classifiers o1:t+1 to compute the Cross-Entropy loss, i.e., p(xt+1) = Softmax(o1:t+1), while only the parameters in the new classifier are trainable. ICE-PL uses the same inference process as ICE.
ICE+Other (ICE-O) Both ICE-O and ICE-PL can only be applied to classification tasks and handling the Other category for detection tasks is challenging as each session Dt only contains the annotated mentions for the classes Ct, while the mentions from all the other classes such as C1:t−1 are labeled as Other, making the meaning of Other varies in different sessions. To tackle this problem, we purpose the ICE-O variant (shown in Figure 2 (d)) where we assign a constant value δ as the logit of the Other category. Specifically, for each prediction, we combine the logit of Other with the logits from the new session ot+1 to obtain the output probability, i.e., p(xt+1) = Softmax([δ; ot+1]), and then compute the Cross-Entropy loss to train the classifier to make predictions for both positive classes and Other. During the inference,
we combine the Other’s logit δ with the logits from all trained classifiers o1:t+1, i.e., o0:t+1 = [δ; o1; ...; ot+1] to predict for all learned positive types and Other. We select the label with the highest logit among o0:t+1 as the prediction, and a candidate will be predicted as Other if and only if max(o1:t+1) < δ.
While the Other class introduces additional difficulties to CIL, we argue that it can also be a good remedy to classifier drift. In particular, in each learning session k, while the classifier Wk is independently trained on Dk, the output logits ok also need to satisfy the constraint that max(ok) < δ when the classifier is trained on negative instances. Although the logits from any two distinct classifiers Wk and Wj (k ̸= j) do not have explicit contrastivity, both classifiers are trained under the constraint that max(ok) < δ and max(oj) < δ, which provides a weak contrastivity between them.
ICE+Previous Logits and Other (ICE-PL&O) To explore the effect of preserving the previous logits when Other is involved, we devise a ICE-PL&O variant that uses both the Other’s logit δ and previous logits o1:t during training (shown in Figure 2 (e)). That is, ICE-PL&O uses the combined logits o0:t+1 = [δ; o1; ...; ot+1] to compute the loss, i.e., p(xt+1) = Softmax(o0:t+1). ICE-PL&O adopts the same inference process as ICE-O.
While ICE-O and ICE-PL&O are naturally applied to detection tasks, for classification tasks without the Other class, we can also manually create negative instances based on the tokens or entity pairs without positive labels. Section 5.1 provides more details regarding how to apply ICE-O and ICE-PL&O to classification tasks.

heading: 5 Experiments and Discussions

heading: 5.1 Datasets and Experiment Setup
text: We use Few-NERD (Ding et al., 2021) for classincremental named entity recognition and split all the 66 fine-grained types into 8 learning sessions by following Yu et al. (2021) which apply a greedy algorithm to split the types into sessions and ensure each session contains the roughly same number of training instances. We use two benchmark datasets MAVEN (Wang et al., 2020) and ACE-05 (Doddington et al., 2004) for class-incremental event trigger extraction and following the same setting as (Yu et al., 2021) to split them into 5 learning sessions, respectively. For class-incremental relation
extraction, we use TACRED (Zhang et al., 2017) and follow the same setting as Zhao et al. (2022) to split the 42 relations into 10 learning sessions.
For each dataset, we construct two settings: (1) detection where the model classifies each token (or a candidate entity pair in relation extraction task) in a sentence into a particular class or Other; and (2) classification where the model directly takes in a positive candidate (i.e., an entity, trigger, or a pair of entities) and classify it into one of the classes. For the classification setting, as there are no negative candidates that are labeled as Other, we automatically create negative candidates and introduce the Other category so that we can investigate the effect of Other using ICE-O and ICE-PL&O. Specifically, we assign the Other label to the tokens if they are not labeled with any classes for entity and event trigger classification, and assign the Other label to the pairs of entity mentions if they are not labeled with any relations for relation classification. When we apply ICE-O and ICEPL&O to classification tasks, during inference, we do not consider the logit of the Other class.
Evaluation We use the same evaluation protocol as previous studies (Yu et al., 2021; Liu et al., 2022). Every time the model finishes the training on Session t, we evaluate the model on all test samples from Session 1 to Session t for classification tasks. For detection tasks, we evaluate the model on the entire test set where we take the mentions or mention pairs of unlearned classes as Other. Following Yu et al. (2021), we randomly sample 5 permutations of the orders of learning sessions and report the average performance.
Baselines We compare our approaches with the DRIFTED-BERT baseline and several state-ofthe-art methods for class-incremental information extraction, including ER (Wang et al., 2019), KCN (Cao et al., 2020), KT (Yu et al., 2021), EMP (Liu et al., 2022), CRL (Zhao et al., 2022). All these methods adopt experience replay to alleviate catastrophic forgetting. We also design two approaches to show their performance in the conventional supervised learning setting where the model is trained with the annotated data from all the sessions, as the approximate upperbound of the continual learning approaches: (i) BERT-FFE consists of a pre-trained BERT as the feature extractor and a classifier, where, during training, we fix the feature extraction and only tune the classifier; and (ii)
BERT-FT which shares the same architecture as BERT-FFE but both the feature extractor and classifier are tuned during training. More details about the datasets, baselines, and model implementation can be found in Appendix A.

heading: 5.2 RQ1: How does Classifier Drift Lead to Forgetting?
text: We conduct an empirical analysis on event detection and classification tasks on MAVEN to answer RQ1 and gain more insight into the classifier drift.
Analysis of Old and New Classes Performance Our first goal is to analyze the classifier drift during the incremental learning process. In Table 1, we analyze how the performance of previously learned classes changes after the model has been trained on a new session for the DRIFTED-BERT baseline and the variants of ICE. After learning in each session k, we compute the (1) F-score on the new classes (Ck) learned in the current session, (2) accumulated F-score on the old classes (C1:k−1) from all previous sessions, and (3) F-score on the old classes (Ck−1) from the previous session, respectively. By
comparing the performance change on the same set of classes in two continuous sessions, e.g., the F-score on the new classes (Ck) learned in session k and the F-score on the classes (Ck) from the previous session after learning in session k+1, we can quantify how much the classifier is drifted. From Table 1, the performance of DRIFTED-BERT on old classes after learning on a new session is always decreased dramatically, verifying that classifier drift does occur in class-incremental learning and leads to severe forgetting. On the other side, our solutions, especially ICE-O, consistently retain similar performance on the old classes from the previous session after learning on a new session, demonstrating that it effectively alleviates the classifier drift and the forgetting issue. Besides, we find that the ICE-PL variant suffers from a considerable performance drop on both new and old classes, which indicates freezing previous classifiers’ parameters while preserving the logits of previously learned classes cannot address the classifier drift and forgetting problems. Note that although we only showed the results on event classification and detection on MAVEN, the conclusions are very consistent for
other tasks and datasets as shown in Appendix B.1.

heading: 5.3 RQ2: How to Alleviate Classifier Drift and Forgetting?
text: To answer RQ2, we evaluate the effectiveness of our proposed approaches to mitigating classifier drift and catastrophic forgetting.
Quantitative Comparison We conduct an extensive quantitative comparison of the baselines and our approaches on the 6 class-incremental IE tasks. From Table 2, 3 and 4, we can see that: (1) our approaches, especially ICE-O, without adopting experience replay, significantly and consistently alleviate the forgetting issue and show a remarkable improvement (i.e., ranging from 4.6% - 44.7% absolute F-score gain) over the previous state-of-theart methods that are all based on experience replay. Notably, ICE-O achieves performance that is even close to the supervised BERT-FFE upperbound on most of the classification and detection tasks. (2) Among the four approaches, ICE-O consistently outperforms other variants on all the classification and detection tasks, demonstrating that introduc-
ing negative instances during training can constrain the updates in the classifier, and consequently mitigate classifier drift and forgetting. (3) Persevering the logits of previous classes without updating the previous classifiers hurts the performance on most tasks, by comparing ICE-PL with ICE and comparing ICE-PL&O with ICE-O. This observation is consistent with our findings in Section 5.2. (4) Previous methods generally perform worse than our solutions even with experience replay. The possible reasons include overfitting to the stored examples in the small memory buffer or the regularization from replay may not be effective enough to mitigate the forgetting.
Comparison with CRL (Zhao et al., 2022) Note that, among all the baselines, CRL consistently outperforms others on the classification tasks. CRL is based on a prototypical network where each class is represented with a prototype computed from an embedding space and performs the classification with the nearest class mean (NCM) classifier. Compared with other Softmax-based classification approaches, CRL can accommodate new classes more flexibly without any change to the architecture. However, it still suffers from the semantic drift (Yu et al., 2020) problem as the embedding network must be continually updated to learn new classes, and it is non-trivial to adapt it to detection tasks where an Other class is involved under the class-incremental learning setting and the meanings of Other in different learning sessions are also different.
Comparison with Trainable Feature Extractor We also investigate if our proposed approaches can be further improved by tuning the BERT-based feature extractor. However, it naturally leads to forgetting as demonstrated by previous studies (Wang et al., 2019; Cao et al., 2020; Yu et al., 2021).
Thus, following these studies, we adopt experience replay and design a new variant named ICEO with Tunable Feature Extractor and Experience Replay (abbreviated as ICE-O+TFE&ER), which tunes the BERT-based feature extractor and adopts the same replay strategy as ER that preserves 20 samples for each class. From Table 2, 3 and 4, ICEO+TFE&ER significantly improves over ICE-O and achieves comparable performance to the supervised BERT-FT upperbound on all the classification tasks. However, ICE-O+TFE&ER performs much worse than ICE-O on all the detection tasks. We hypothesize that this is due to the meaning shift of the Other class when incrementally training it on a sequence of learning sessions. Experience replay may not be enough to constrain the feature extractor to handle the Other class properly.

heading: 5.4 Analysis of Drifting Patterns
text: To take a closer look into how the classifier drift leads to forgetting and verify the two hypothetical drifting patterns we discuss in Section 4.1, we analyze the output logits (i.e., the scores before Softmax) from the old and new classifiers for DRIFTEDBERT and our ICE, ICE-PL, and ICE-O. Specifically, we take the test samples whose ground truth labels are learned in Session 1 (denoted as X 1test), for analysis. Every time the classifier is trained on a new session, we evaluate the classifier on X 1test, and then take (1) the logit of the gold class (Gold), and (2) the maximum logit from the new classifier (NCP), i.e., New Classifier’s Prediction, for analysis. For each type of logit, we report the average of the logits on all the samples in X 1test.
We have the following findings: (1) By examining the Gold logits and the logits from the new classifier (NCP) of DRIFTED-BERT, we observe that every time a new classifier is added and trained
on the new session, the new classifier incrementally outputs higher logits than those in the previous session on X 1test (blue solid line), whereas the Gold logits first decline a bit and stay at a certain level in the remaining sessions (blue dashed line). This observation confirms that two possible drifting patterns (i.e., new logit explosion and diminishing old logit) exist, and they can happen simultaneously and cause the new classifier overshadows the previously learned classifiers, which consequently leads to forgetting. (2) We find that while the old classifiers are not updated in ICE-PL, the new logit explosion issue gets even more severe (orange solid line), which explains why ICE-PL performs worse than ICE and ICE-O. We hypothesize that the presence of previous logits may encourage the new classifier to predict larger logits. (3) When the classifier in each session is trained individually instead of collectively (i.e., in ICE and ICE-O), the Gold logits from the old classifiers stay at a constant level (red dashed lines), whereas the logits from the new classifier are at a relatively lower level (green and red solid line). As such, the new classifier’s logits do not have much impact on those of old classes, which mitigates the drift and forgetting.
5.5 The Effect of the Logit for Other Class
Throughout all the experiments, we set the logit for Other class δ as 0 constantly. In this section, we further discuss the effect of the value of δ, and the effect of tuning the Other classifier. We show the results of event detection on MAVEN based on different fixed values or a tunable value of δ in Table 5. We found that the value of Other class’s logit does
not affect the model’s performance much as long as it is fixed. However, we noticed a significant performance decrease if we continually tuned it with a classifier, demonstrating that it is necessary to fix the Other class’s logit during the continual learning process in our approach.

heading: 5.6 Comparison with Recent LLMs
text: More recently, very large language models (LLMs) such as ChatGPT (OpenAI, 2022) demonstrate strong in-context learning ability without the need of gradient update. Thus, class-incremental learning may also be tackled as a sequence of in-context learning. However, several recent studies (Gao et al., 2023; Qin et al., 2023) have benchmarked several LLMs with in-context few-shot learning on various IE tasks and show worse performance than our approach. Our approach can efficiently achieve a good performance that is close to the supervised performance by only finetuning the last linear layer using a much smaller frozen BERT backbone. More critically, the knowledge LLMs are often bounded by the training data, whereas the goal of our continual learning approach focuses on incorporating up-to-date information into models.

heading: 6 Conclusion
text: In this paper, we investigate the answers and the solutions to the research questions that how the classifier drift alone affects a model in the classincremental learning setting, and how to alleviate the drift without retraining the model on previous examples. We, therefore, propose to train a classifier individually for each task and combine them together during inference, such that we can maximally avoid the drift in the classifier. Extensive experiments show that our proposed approaches significantly outperform all the considered baselines on both class-incremental classification and detection benchmarks and provide super-strong baselines. We hope this work can shed light on future research on continual learning in broader research communities.
Limitations
Our approaches mainly leverage a fixed feature extractor together with a set of individually trained classifiers to mitigate catastrophic forgetting whereas a tunable feature extractor may also be helpful and complement the individually trained classifiers, so a future direction is to design advanced strategies to efficiently tune the feature extractor in combination with our proposed ICE based classifiers. In addition, we mainly investigate the classifier drift and demonstrate the effectiveness of our solutions under the class-incremental continual learning setting. Another future direction is to explore similar ideas under other continual learning settings, e.g., task-incremental learning, online learning, or the setting where new sessions also contain annotations for old classes.

heading: Acknowledgments
text: This research is based upon work partially supported by the Amazon Research Award program and U.S. DARPA KMASS Program # HR001121S0034. The views and conclusions contained herein are those of the authors and should not be interpreted as necessarily representing the official policies, either expressed or implied, of DARPA or the U.S. Government. The U.S. Government is authorized to reproduce and distribute reprints for governmental purposes notwithstanding any copyright annotation therein.

heading: A More Details on Experiment Setup
text: A.1 Details of the Datasets Named Entity We use Few-NERD (Ding et al., 2021), a large-scale named entity recognition (NER) dataset to evaluate class-incremental named entity recognition and classification. Compared with the datasets used in previous continual NER works (Zheng et al., 2022), Few-NERD has a more diverse range of entity types and finer granularity, containing 8 coarse-grained and 66 fine-grained entity types. Thus, it is a better benchmark to study continual NER. We construct two settings for the NER task: (1) a detection task where the model is required to examine every token in the text and classify each of them into a learned positive entity type or Other, and; (2) a classification task where the positive candidate entity mentions have been provided and the model only needs to assign a learned entity type to the given candidate. Following Yu et al. (2021), we split the dataset into 8 learning sessions with the greedy algorithm such that each session contains the roughly same number of training instances.
Relation We use TACRED (Zhang et al., 2017) to evaluate relation detection and classification tasks. TACRED is a large-scale relation extraction dataset that contains 42 relations. In the previous continual relation classification setting (Cui et al., 2021), they ignore the long-tail distribution and assume each relation contains the same number of
instances. We instead use the original train/dev/test split in TACRED where relations are imbalanced. We build two settings for the relation task: (1) a detection task where the model needs to assign an ordered entity mentions with a seen positive relation type or Other, and; (2) a classification task that assumes the given entity pair must belong to one of learned relation, and the model is only required to predict a label it has learned. We follow the previous setting (Zhao et al., 2022) to split the dataset into 10 learning sessions, where we drop the relation with the fewest instances such that each session contains 4 positive relation types.
Event Trigger We adopt the following two event detection datasets for evaluation: (1) MAVEN (Wang et al., 2020): MAVEN is a largescale event detection dataset with 169 event types (including Other) in the general domain, and; (2) ACE-05 (Doddington et al., 2004): ACE 2005 English dataset contains 34 event types (including Other). For both datasets, we follow Yu et al. (2021) to use the same train/dev/test split and use the same ontology partition to create 5 incremental learning sessions for each dataset, where each session contains approximately the same number of training instances. We create two settings for event trigger: (1) two event detection tasks, where the model is required to evaluate each token in the sentence and assign it with a learned event type or Other, and; (2) a classification task where the model only needs to classify a positive trigger mention into a learned event type without considering Other. We did not construct the classification task for the ACE dataset as the majority of instances only contain the Other type and removing such instances will result in a very small dataset.
A.2 Baselines
We use the following baselines for our experiments: (1) DRIFTED-BERT: we build a baseline with a fixed pre-trained BERT as the feature extractor and only train its classification layer. We do not apply any other continual learning techniques to it. We primarily use this baseline to study the classifier drift discussed in this work. (2) ER (Wang et al., 2019): experience replay is introduced to continual IE by (Wang et al., 2019). In this work, we use the same strategy as in (Liu et al., 2022) to select examples to store in the memory and replay them in subsequent sessions. (3) KCN (Cao et al., 2020): the original work proposes a prototype-
based method to sample examples to store for replay as well as a hierarchical knowledge distillation (KD) to constrain the model’s update. We adapt their hierarchical distillation along with ER as the KCN baseline. (4) KT (Yu et al., 2021): a framework that transfers knowledge between new and old event types. (5) EMP (Liu et al., 2022): propose a prompt-based technique to dynamically expand the model architecture to incorporate more classes. (6) CRL (Zhao et al., 2022) proposes consistent representation learning to keep the embeddings of historical relations consistent. Since CRL is designed for the classification tasks without Other, we only evaluate this baseline on the classification tasks we build. (7) Upperbound: we train a model jointly on all classes in the dataset as an upperbound in the conventional supervised learning setting. We devise two different upperbounds: (i) BERT-FFE is the upperbound of our ICE-O model, where we only train the classifier and the feature extractor is fixed. The negative instances are used in the classification tasks without Other; and (ii) BERT-FT is the upperbound that trains both the whole BERT and the classifier.
A.3 Implementation Details
We use the pre-trained BERT-large-cased (Devlin et al., 2019) as the fixed feature extractor. We use AdamW (Loshchilov and Hutter, 2019) as the optimizer with the weight decay set to 1e − 2 and a learning rate of 1e − 4 for detection tasks and 5e− 4 for classification tasks. We apply gradient accumulation and set the step to 8. In each learning session Dk, we establish a limit of 15 maximum training epochs. We also adopt the early stopping strategy with a patience of 3, where training will be halted if there is no improvement in performance on the development set for 3 epochs. We set the constant value for the Other class δ to 0. We apply the experience replay strategy with the same setting as in (Liu et al., 2022) to ER, KCN, KT, and EMP as an assistant technique to mitigate forgetting. We store 20 examples for each class using the herding algorithm (Welling, 2009) and replay one stored instance in each batch during training to limit the computational cost brought by rehearsal. For CRL, we use the same sample selection and replay strategy as in the original work. For baselines, we adopt a frozen pre-trained BERT-large and a trainable Multi-Layer Perceptron (MLP) as the feature extractor.

heading: B More Discussions
text: B.1 More Analysis on Old and New Type Performance
Table 6 and 7 show the performance of old and new classes for each learning session of the classincremental named entity detection and classification and class-incremental relation detection and classification tasks.
ACL 2023 Responsible NLP Checklist

heading: A For every submission:
text: 3 A1. Did you describe the limitations of your work?
Section 7
7 A2. Did you discuss any potential risks of your work? We don’t see any potential risks of this work
3 A3. Do the abstract and introduction summarize the paper’s main claims? Section 1
7 A4. Have you used AI writing assistants when working on this paper? Left blank.
B 7 Did you use or create scientific artifacts? Left blank.
B1. Did you cite the creators of artifacts you used? No response.
B2. Did you discuss the license or terms for use and / or distribution of any artifacts? No response.
B3. Did you discuss if your use of existing artifact(s) was consistent with their intended use, provided that it was specified? For the artifacts you create, do you specify intended use and whether that is compatible with the original access conditions (in particular, derivatives of data accessed for research purposes should not be used outside of research contexts)? No response.
B4. Did you discuss the steps taken to check whether the data that was collected / used contains any information that names or uniquely identifies individual people or offensive content, and the steps taken to protect / anonymize it? No response.
B5. Did you provide documentation of the artifacts, e.g., coverage of domains, languages, and linguistic phenomena, demographic groups represented, etc.? No response.
B6. Did you report relevant statistics like the number of examples, details of train / test / dev splits, etc. for the data that you used / created? Even for commonly-used benchmark datasets, include the number of examples in train / validation / test splits, as these provide necessary context for a reader to understand experimental results. For example, small differences in accuracy on large test sets may be significant, while on small test sets they may not be. No response.
C 3 Did you run computational experiments? Section 5
7 C1. Did you report the number of parameters in the models used, the total computational budget (e.g., GPU hours), and computing infrastructure used? The number of tunable parameters in our approach is very small
The Responsible NLP Checklist used at ACL 2023 is adopted from NAACL 2022, with the addition of a question on AI writing assistance.
3 C2. Did you discuss the experimental setup, including hyperparameter search and best-found hyperparameter values? Section 5, Appendix A
3 C3. Did you report descriptive statistics about your results (e.g., error bars around results, summary statistics from sets of experiments), and is it transparent whether you are reporting the max, mean, etc. or just a single run? Section 5
7 C4. If you used existing packages (e.g., for preprocessing, for normalization, or for evaluation), did you report the implementation, model, and parameter settings used (e.g., NLTK, Spacy, ROUGE, etc.)? We didn’t use any existing packages
D 7 Did you use human annotators (e.g., crowdworkers) or research with human participants? Left blank.
D1. Did you report the full text of instructions given to participants, including e.g., screenshots, disclaimers of any risks to participants or annotators, etc.? No response.
D2. Did you report information about how you recruited (e.g., crowdsourcing platform, students) and paid participants, and discuss if such payment is adequate given the participants’ demographic (e.g., country of residence)? No response.
D3. Did you discuss whether and how consent was obtained from people whose data you’re using/curating? For example, if you collected data via crowdsourcing, did your instructions to crowdworkers explain how the data would be used? No response.
D4. Was the data collection protocol approved (or determined exempt) by an ethics review board? No response.
D5. Did you report the basic demographic and geographic characteristics of the annotator population that is the source of the data? No response.

heading: Future Work
text: We hope this work can shed light on future research on continual learning in broader research communities. Limitations
Our approaches mainly leverage a fixed feature extractor together with a set of individually trained classifiers to mitigate catastrophic forgetting whereas a tunable feature extractor may also be helpful and complement the individually trained classifiers, so a future direction is to design advanced strategies to efficiently tune the feature extractor in combination with our proposed ICE based classifiers. In addition, we mainly investigate the classifier drift and demonstrate the effectiveness of our solutions under the class-incremental continual learning setting. Another future direction is to explore similar ideas under other continual learning settings, e. g. , task-incremental learning, online learning, or the setting where new sessions also contain annotations for old classes