Guangnan Ye IBM Research New York, USA gye@us.ibm.com xcui@us.ibm.com Abstract In the recent advances of natural language processing, the scale of the state-of-the-art models and datasets is usually extensive, which challenges the application of sample-based explanation methods in many aspects, such as explanation interpretability, efficiency, and faithfulness. In this work, for the first time, we can improve the interpretability of explanations by allowing arbitrary text sequences as the explanation unit. On top of this, we implement a hessian-free method with a model faithfulness guarantee. Finally, to compare our method with the others, we propose a semantic-based evaluation metric that can better align with humans' judgment of explanations than the widely adopted diagnostic or retraining measures. The empirical results on multiple real data sets demonstrate the proposed method's superior performance to popular explanation techniques such as Influence Function or TracIn on semantic evaluation. As complex NLP models such as the Transformers family (Vaswani et al., 2017; Devlin et al., 2019) become an indispensable tool in many applications, there are growing interests to explain the working mechanism of these black-box models. Among the vast of existing techniques for explaining machine learning models, Influence Functions (Ham-pel, 1974; Koh and Liang, 2017) that uses training instances as explanations to a model's behavior have gained popularity in NLP very recently. Different from other methods such as using input erasure (Li et al., 2016), saliency maps or attention matrices (Serrano and Smith, 2019; Jain and Wallace, 2019; Wiegreffe and Pinter, 2019) that only look at  Equal Contribution. Wei Zhang did the work while being a research scientist at IBM T.J. Watson Research Center at Yorktown Heights, NY, USA; Ziming Huang was a research scientist at IBM Research Lab at Beijing, China. how a specific input or input sequence impacts the model decision, explaining with training instances can cast light on the knowledge a model has encoded about a problem, by answering questions like ' what knowledge did the model capture from which training instances so that it makes decision in such a manner during test? '. Very recently, the method has been applied to explain BERT-based (Devlin et al., 2019) text classification (Han et al., 2020; Meng et al., 2020b) and natural language inference (Han et al., 2020) models, as well as to aid text generation for data augmentation (Yang et al., 2020a) using GPT-2 (Radford et al., 2019). Although useful, Influence Function may not be entirely bullet-proof for NLP applications. First, following the original formulation (Koh and Liang, 2017), the majority of existing works use entire training instances as explanations. However, for long natural language texts that are common in many high-impact application domains (e.g., healthcare, finance, or security), it may be difficult, if not impossible, to comprehend an entire instance as an explanation. For example, a model's decision may depend only on a specific part of a long training instance. Second, for modern NLP models and large-scale datasets, the application of Influence Functions can lead to prohibitive computing costs due to inverse Hessian matrix approximation. Although hessian-free influence score such as TracIn (Pruthi et al., 2020b) was introduced very recently, it may not be faithful to the model in question and can result in spurious explanations for the involvement of sub-optimal checkpoints. Last, the evaluation of explanation methods, in particular, for the training-instance-based ones, remains an open question. Previous evaluation is either under an over-simplified assumption on the agreement of labels between training and test instances (Hanawa et al., 2020; Han et al., 2020) or is based on indirect or manual inspection (Hooker et al., 2019; Meng et al., 2020b; Han et al., 2020; Pruthi et al., 2020a). A method to automatically measure the semantic relations at scale and that highly correlates to human judgment is still missing in the evaluation toolset. To address the above problems, we propose a framework to explain model behavior that includes both a set of new methods and a new metric that can measure the semantic relations between the test instance and its explanations. The new method allows for arbitrary text spans as the explanation unit and is Hessian-free while being faithful to the final model. Our contributions are: 1. We propose a new explanation framework that can use arbitrary explanation units as explanations and be Hessian-free and faithful at the same time; 2. A new metric to measure the semantic relatedness between a test instance and its explanation for BERT-based deep models. Suppose a model parameterized by   is trained on classification dataset D = { D train , D test } by empirical risk minimization over D train . Let z = ( x , y )  D train and z (cid:48) = ( x (cid:48) , y (cid:48) )  D test denote a training and a test instance respectively, where x is a token sequence, and y is a scalar. The goal of training instance based explanation is to provide for a given test z (cid:48) an ordered list of training instances as explanation. Two notable methods to calculate the influence score are IF and TracIn : IF (Koh and Liang, 2017) assumes the influence of z can be measured by perturbing the loss function L with a fraction of the loss on z , and obtain I pert,loss ( z, z (cid:48) ;   ) =   L ( z (cid:48) ,   ) H  1     L ( z,   ) , (1) where H is the Hessian matrix calculated on the entire training dataset, a potential computation bottleneck for large dataset D and complex model with high dimensional   . TracIn (Pruthi et al., 2020b) instead assumes the influence of a training instance z is the sum of its contribution to the overall loss all through the entire training history, and conveniently it leads to TracIn ( z, z (cid:48) ) = (cid:88) i  i    i L (  i , z )    i L (  i , z (cid:48) ) , (2) where i iterates through the checkpoints saved at different training steps and  i is a weight for each checkpoint. TracIn does not involve Hessian matrix and more efficient to compute. We can summarize the key differences between them according to the following desiderata of an explanation method: Efficiency for each z (cid:48) , TracIn requires O ( CG ) where C is the number of models and G is the time spent for gradient calculation; whereas IF needs O ( N 2 G ) where N is the number of training instances, and N >> C in general. 1 Faithfulness IF is faithful to   since all its calculation is based on a single final model, yet TracIn may be less faithful to   since it obtains gradients from a set of checkpoints 2 . Interpretability Both methods use the entire training instance as an explanation. Explanations with a finer-grained unit, e.g., phrases, may be easier to interpret in many applications where the texts are lengthy. To improve on the above desiderata, a new method should be able to: 1) use any appropriate granularity of span(s) as the explanation unit; 2) avoid the need of Hessian while maintaining faithfulness. We discuss the solutions for both in Section 3.1 and 3.2, and combine them into one formation in Section 3.3 followed by critical implementation details. To achieve 1), we first start with influence functions (Koh and Liang, 2017) and consider an arbitrary span of training sequence x to be evaluated for the qualification as explanation 3 . Our core idea is to see how the model loss on test instance z (cid:48) changes 1 some approximation such as hessian-inverse-vector-product (Baydin et al., 2016) may improve efficiency to O ( NSG ) where S is the approximation step and S < N 2 We may say TracIn is faithful to the data rather than to the model . And in the case where checkpoint averaging can be used as model prediction, the number of checkpoints may be too few to justify Eq. 2. 3 the method can be trivially generalized to multiple spans with the training span's importance. The more important a training span is to z (cid:48) , the greater this influence score should be. We derive it in three following steps. First, we define the training span from token i to token j to be x ij , and the sequence with x ij masked is x  ij = [ x 0 , ..., x i  1 , [MASK] , ..., [MASK] , x j +1 , ... ] and its corresponding training data is z  ij . We use logit difference (Li et al., 2020) as importance score based on the empirical-risk-estimated parameter   obtained from D train as: imp ( x ij | z,   ) = logit y ( x ;   )  logit y ( x  ij ;   ) , where every term in the right hand side (RHS) is the logit output evaluated at a model prediction y from model   right before applying the SoftMax function. This equation tells us how important a training span is. It is equivalent to the loss difference imp ( x ij | z ;   ) = L ( z  ij ;   )  L ( z ;   ) , (3) when the cross entropy loss L ( z ;  ) =  (cid:80) y i I ( y = y i ) logit y i ( x ;  ) is applied. Then, we measure x ij 's influence on model   by adding a fraction of imp ( x ij | z ;   ) scaled by a small value (cid:15) to the overall loss and obtain   (cid:15), x ij | z := argmin  E z i  D train [ L ( z i ,  )] + (cid:15) L ( z  ij ;  )  (cid:15) L ( z ;  ) . Applying the classical result in (Cook and Weisberg, 1982; Koh and Liang, 2017), the influence of up-weighing the importance of x ij on   is d   (cid:15), x ij | z d(cid:15) (cid:12)(cid:12)(cid:12) (cid:15) =0 = H  1   (    L ( z ;   )     L ( z  ij ;   )) . Finally, applying the above equation and the chain rule, we obtain the influence of x ij to z (cid:48) as: IF + ( x ij | z, z (cid:48) ;   ) :=  (cid:15) L ( z (cid:48) ;   (cid:15), x ij | z ) | (cid:15) =0 =   L ( z (cid:48) ;   ) H  1   (   L ( z ;   )    L ( z  ij ;   )) . IF + measures the influence of a training span on an entire test sequence. Similarly, we also measure the influence of a training span to a test span x (cid:48) kl by applying Eq. 3 and obtain IF ++ ( x ij | z, x (cid:48) kl | z (cid:48) ;   ) :=  (cid:15) L ( z (cid:48) kl ;   (cid:15), x ij | z )   (cid:15) L ( z (cid:48) ;   (cid:15), x ij | z ) | (cid:15) =0 =(   L ( z (cid:48) kl ;   )    L ( z (cid:48) ;   )) H  1   (   L ( z ;   )    L ( z  ij ;   )) . On the choice of Spans Theoretically, IF + and IF ++ can be applied to any text classification problem and dataset with an appropriate choice of the span. If no information about valid span is available, shallow parsing tools or sentence split-tools can be used to shatter an entire text sequence into chunks, and each chunk can be used as span candidates. In this situation, the algorithm can work in two steps: 1) using masking method (Li et al., 2020) to determine the important test spans; and 2) for each span we apply IF ++ to find training instances/spans as explanations. Usually, we can choose top-K test spans, and even can choose K = 1 in some cases. In this work, we look at the later case without loss of generality, and adopt two aspect-based sentiment analysis datasets that can conveniently identify a deterministic span in each text sequence, and frame the span selection task as a Reading Comprehension task (Rajpurkar et al., 2016). We discuss the details in Section 5. Note that the discussion can be trivially generalized to the case where K > 1 using Bayesian approach such as imp ( x ij ) = EP ( x (cid:48) kl ) [ imp ( x ij | x kl ) (cid:48) ] which can be explored in future work. To achieve 2), we would start with the method of TracIn (Pruthi et al., 2020b) described in Eq. 2 which is Hessian free by design. TracIn defines the contribution of a training instance to be the sum of its contribution (loss) throughout the entire training life cycle, which eradicated the need for Hessian. However, this assumption is drastically different from IF 's where the contribution of z is obtained solely from the final model   . By nature, IF is a faithful method , and its explanation is faithful to   , and TracIn in its vanilla form is arguably not a faithful method. Proposed treatment Based on the assumption that the influence of z on   is the sum of influ-ences of all variants close to   , we define a set of faithful variants satisfying the constraint of {   i | 1 >  >> ||   i    || 2 } , namely  -faithful to   . The smaller  is, the more faithful the explanation method is. Instead, the  for TracIn can be arbitrary large without faithfulness guarantees, as some checkpoints can be far from the final   . Thus, we construct a  -faithful explanation method that mirrors TracIn as: TracInF ( z, z (cid:48) ) = (cid:88) i    +  i L (  +  i , z )    +  i L (  +  i , z (cid:48) ) . The difference between TracIn and TracInF is that the checkpoints used in TracIn are correlated in time whereas all variants of TracInF are conditionally independent. Finding a proper  i can be tricky. If ill-chosen,  i may diverge   so much that hurts gradient estimation. In practice, we estimate  i =  i g ( z i |   ) obtained from a single-step gradient descent g ( z i |   ) with some training instance z i on model   , scaled by an i -specific weighting parameter  i , which in the simplest case is uniform for all i . Usually  i should be small enough so that   +  i can stay close to   . In this paper we set  as the model learning rate for proof of concept. Is TracInF faithful? First, any   +  i is close to   . Under the assumption of Lipschitz continuity, there exists a k  R + such that  L (  +  i , z ) is bounded around  L ( , z ) by k |  i g 2 ( z i |   ) | , the second derivative, because | L (  +  i , z )   L ( , z ) | < k |  i g 2 ( z i |   ) | . A proper  i can be chosen so that the right hand side (RHS) is sufficiently small to bound the loss within a small range. Thus, the gradient of loss, and in turn the TracInF score can stay  -faithful to   for an sufficiently small  , which TracIn can not guarantee. By combining the insights from Section 3.1 and 3.2, we obtain a final form named TracIn ++ : TracIn ++ ( x (cid:48) kl | z (cid:48) , x ij | z ;   ) = (cid:88) i (cid:2) L (  +  i , z (cid:48) kl )  L (  +  i , z (cid:48) ) (cid:3) (cid:2) L (   +  i , z )  L (   +  i , z  ij ) (cid:3) . This ultimate form mirrors the IF ++ method, and it satisfies all of our desiderata on an improved explanability method. Similarly, TracIn + that mirrors IF + is TracIn + ( z (cid:48) , x ij | z ;   ) = (cid:88) i L ( z (cid:48) ;   +  i ) (cid:2) L (  +  i , z )  L (  +  i , z  ij ) (cid:3) . Since the RHS of IF , IF + and IF ++ equations all involve the inverse of Hessian Matrix, here we discuss the computation challenge. Following (Koh and Liang, 2017), we adopt the vector-Hessian-inverse-product (VHP) with stochastic estimation (Baydin et al., 2016). The series of stochastic updates, one for each training instance, is performed by the vhp() function in the torch.autograd.functional package and the update stops until convergence. Unfortunately, we found that naively applying this approach leads to VHP explosion due to large parameter size. To be specific, in our case, the parameters are the last two layers of RoBERTa-large (Liu et al., 2019) plus the output head, a total of 12M parameters per gradient vector. To stabilize the process, we take three approaches: 1) applying gradient clipping (set to 100) to avoid accumulating the extreme gradient values; 2) adopting early termination when the norm of VHP stabilizes (usually < 1000 training instances, i.e., the depth); and 3) slowly decaying the accumulated VHP with a factor of 0.99 (i.e., the damp) and update with a new vhp() estimate with a small learning rate (i.e., the scale) of 0.004. Please refer to our code for more details. Once obtained, the VHP is first cached and then retrieved to perform the dot-product with the last term. The complexity for each test instance is O ( dt ) where d is the depth of estimation and t is the time spent on each vhp() operation. The time complexity of different IF methods only vary on a constant factor of two. For each of TracIn , TracIn + and TracIn ++ , we need to create multiple model variants. For TracIn , we save three checkpoints of the most recent training epochs; For TracIn + or TracIn ++ , we start with the same checkpoint and randomly sample a mini-batch 3 times and perform one-step training (learning rate 1E-4) for each selection to obtain three variants. We do not over-tune those hyper-parameters for replicability concerns. Intuitively, a rational explanation method should rank explanations that are semantically related to the given test instance relatively higher than the less relevant ones. Our idea is to first define the semantic representation of a training span x ij of z and measure its similarity to that of a test span x (cid:48) kl of z (cid:48) . Since our method uses BERT family as the base model, we obtain the embedding of a training span by the difference of x and its span-masked version x ij as emb ( x ij ) = emb ( x )  emb ( x  ij ) , (4) where emb is obtained from the embedding of sentence start token such as [CLS] in BERT (Devlin et al., 2019) at the last embedding layer. To obtain embedding of the entire sequence we can simply use the emb ( x ) without the last term in Eq. 4. Thus, all spans are embedded in the same semantic space and the geometric quantities such as cosine or dot-product can measure the similarities of em-beddings. We define the semantic agreement Sag as: Sag ( z (cid:48) , { z }| K 1 ) = 1 K (cid:88) z cos ( emb ( x ij | z ) , emb ( x (cid:48) kl | z (cid:48) )) , (5) Intuitively, the metric measures the degree to which top-K training spans align with a test span on semantics. Label Agreement ( Lag ) label agreement (Hanawa et al., 2020) assumes that the label of an explanation z should agree with that of the text case z (cid:48) . Accordingly, we retrieve the top-K training instances from the ordered explanation list and calculate the label agreement ( Lag ) as follows: Lag ( z (cid:48) , { z }| N 1 ) = 1 K (cid:88) k  [1 ,K ] I ( y (cid:48) == y k ) , where I (  ) is an indicator function. Lag measures the degree to which the top-ranked z agree with z (cid:48) on class label, e.g., if the sentiment of the test z (cid:48) and explanation z agree. Re-training Accuracy Loss ( Ral ) Ral measures the loss of test accuracy after removing the top-K most influential explanations identified by an explanation method (Hanawa et al., 2020; Hooker et al., 2019; Han et al., 2020). The assumption is that the higher the loss the better the explanation method is. Formally, Ral ( f,   ) = Acc (  )  Acc (  (cid:48) ) , where   (cid:48) is the model re-trained by the set D train / { z }| K 1 . Notice the re-training uses the same set of hyper-parameter settings as training (Section 6.1). To obtain { z }| K 1 , we combine the explanation lists for all test instances (by score addition) and then remove the top-K from this list. Our criteria for dataset selection are two folds: 1. The dataset should have relatively high classification accuracy so that the trained model can behave rationally; and 2. The dataset should allow for easy identification of critical/useful text spans to compare span-based explanation methods. We chose two aspect-based sentiment analysis (ABSA) datasets; one is ATSA, a subset of MAMS (Jiang et al., 2019) for product reviews, where aspects are the terms in the text. The other is sentihood (Saeidi et al., 2016) of location reviews. We can identify the relevant span of an aspect term semiautomatically and train models with high classification accuracy in both datasets. (see Section 6.1 for details). Data statistics and instances are in Table 1 and 2. Train Dev Test MAMS 11186 1332 1336 sentihood 2977 747 1491 Table 1: Data Statistics. Automatic Span Annotation As shown in the colored text in Table 2, we extract the spans for each term to serve as explanation units for IF + , IF ++ , TracIn + and TracIn ++ . To reduce annotation effort, we convert span extraction into a question answering task (Rajpurkar et al., 2016) where we use aspect terms to formulate questions such as How is the service ? which concatenates with the text before being fed into pre-trained machine reading comprehension (RC) models. The output answer is used as the span. When the RC model fails, we use heuristics to extract words before and after the term word, up to the closest sentence boundary. See appendix for more details. We sampled a subset of 100 annotations and found that the RC model has about 70% of Exact Match (Ra-jpurkar et al., 2016) and the overall annotation has a high recall of over 90% but low EM due to the involvement of heuristics. For example, as shown in 2, if the span of location2 is annotated as I love it, span-based explanation methods will use it to find wrong examples for explanation. Thus test instances with incorrectly annotated spans are omitted, i.e., no tolerance to annotation error for test instances. To the contrary, for training instances, we do not correct the annotation error. The major reason is the explanation methods have a chance to rank the wrongly annotated spans lower (its importance score imp () of Eq. 3 can be lower and in turn for its influence scores.) Also, It is labor-intensive to do so. We train two separate models for MAMS and sentihood. The model's input is the concatenation of the aspect term and the entire text, and the output is a sentiment label. The two models share similar settings: 1. they both use ROBERTA-LARGE (Liu et al., 2019) from Huggingface (Wolf et al., 2019) which is fed into the BertForSequenceClassification function for initialization. We fine-tune the parameters of the last two layers and the output head using a batch size of 200 for ATSA and 100 for sentihood and max epochs of 100. We use AdamW optimizer (Loshchilov and Hutter, 2019) with weight decay 0.01 and learning rate 1E-4. Both models are written in Pytorch and are trained on a single Tesla V100 GPU and took less than 2 hours for each model to train. The models are selected on dev set performance, and both trained models are state-of-the-art: 88.3% on MAMS and 97.6% for sentihood at the time of writing. We compare the six explanation methods on two datasets and three evaluation metrics in Table 3 from which we can draw the following conclusions: 1) TracIn family outperforms IF family according to Sag and Lag metrics. We see that both metrics are robust against the choice of K . It it worth noting that TracIn family methods are not only efficient, but also effective for extracting explanations compared to IF family as per Sag and Lag . 2) Span-based methods (with +) outperform Vanilla methods (w/o +). It is good news because an explanation can be much easier to comprehend if we can highlight essential spans in text, and IF ++ and TracIn ++ shows us that such highlighting can be justified by their superiority on the evaluation of Sag and Lag . 3) Sag and Lag shows a consistent trend of TracIn ++ and IF ++ being superior to the rest of the methods, while Ral results are inconclusive, which resonates with the findings in (Hooker et al., 2019) where they also observed randomness after removing examples under different explanation methods. This suggests that the re-training method may not be a reliable metric due to the randomness and intricate details involved in the re-training process. 4) The Sag measures TracIn + differently than Lag shows that Lag may be an over-simplistic measure by assuming that label y can represent the entire semantics of x , which may be problematic. But Sag looks into the x for semantics and can properly reflect and align with humans judgments. The Impact of K on Metrics One critical parameter for evaluation metrics is the choice of K for Sag and Lag (We do not discuss K for Ral due to its randomness). Here we use 200 MAMS test instances as subjects to study the influence of K, as shown in Figure 1. IF IF + IF ++ TracInF TracIn + TracIn ++ Faithful to   ? We found that as K increases, all methods, except for IF and TracInF , decrease on Sag and Lag . The decrease is favorable because the explanation method is putting useful training instances before less useful ones. In contrast, the increase suggests the explanation method fails to rank useful ones on top. This again confirms that span-based explanation can take into account the useful information in x and reduce the impact of noisy information involved in IF and TracInF . How faithful our proposed TracIn ++ to   ? To answer this question, we first define the notion of strictly faithful explanation and then test an explanation method's faithfulness against it. Note that none of the discussed methods is strictly faithful, since IF ++ used approximated inverse-Hessian and TracIn ++ is a  away from being strictly faithful. To obtain ground truth, we modify TracIn ++ to use a single checkpoint   as the ultimately faithful explanation method 4 . Then, we obtain an explanation list for each test instance and compute its Spearman Correlation with the list obtained from the ground truth. The higher the correlation, the more faithful the method is. In Table 4 we discovered that TracIn ++ has similar mean as IF ++ but has a much lower variance, showing its stability over IF ++ . This aligns with the finding of Basu et al. (2021) which argues that in deep non-convex networks, influence function usually is non-stable across test instances. TracIn family arguably may be a promising direction to stability. Both methods are more faithful to Ground truth than Control that uses checkpoints, 4 The choice of ground truth can also be the exact computation of inverse-Hessian in IF (our future work). Faithfulness does not equal to correctness; there is no guarantee the ground truth is a valid explanation method, but it can be a valid benchmark for faithfulness Spearman Method Mean Var. showing that the model ensemble around   may be a better choice than checkpoint averaging for model explanations. Further explorations may be needed since there are many variables in this comparison. Table 5 demonstrate the differences of explanation methods. In action, TracIn ++ shows both the test span and explanation span to a user; TracIn + shows only the training span, and TracIn does not show spans. Interestingly we can observe the top-1 explanation found by TracIn ++ is more semantically related than others in the example, a common pattern among the test cases. Popular explanation methods include gradient-based (Sundararajan et al., 2017), attention-based (Clark et al., 2019; Jain and Wallace, 2019; Wiegreffe and Pinter, 2019), as well as sample-based (Koh and Liang, 2017; Yeh et al., 2018; Pruthi et al., 2020b) methods. Methods There have been a series of recent efforts to explain black-box deep neural nets (DNN), such as LIME (Ribeiro et al., 2016) that approximates the behavior of DNN with an interpretable model learned from local samples around prediction, Influence Functions (Koh and Liang, 2017; Koh et al., 2019) that picks training samples as explanation via its impact on the overall loss, and Exemplar Points (Yeh et al., 2018) that can assign weights to training samples. TracIn (Pruthi et al., 2020b) is the latest breakthrough that overcomes the computational bottleneck of Influence Functions with the cost of faithfulness. The Discussion of Explanation Faithfulness in NLP The issue of Faithfulness of Explanations was primarily discussed under the explanation generation context (Camburu et al., 2018) where there is no guarantee that a generated explanation would be faithful to a model's inner-workings (Jacovi and Goldberg, 2020). In this work, we discuss faithfulness in the sample-based explanations framework. The faithfulness to model either can be guaranteed only in theory but not in practice (Koh and Liang, 2017) or can not be guaranteed at all (Pruthi et al., 2020b). Sample-based explanation methods for NLP Han et al. (2020) applied IF for sentiment analysis and natural language inference and also studied its utility on detecting data artefacts (Gururangan et al., 2019). Yang et al. (2020b) used Influence Functions to filter the generated texts. The one closest to our work is (Meng et al., 2020a) where a single word is used as the explanation unit. Their formation uses gradient-based methods for single words, while ours can be applied to any text unit granularity using text masking. Explanation of NLP Models by Input Erasure Input erasure has been a popular trick for measuring input impact for NLP models by replacing input by zero vector (Li et al., 2016) or by marginaliza-tion of all possible candidate tokens (Kim et al., 2020) that arguably dealt with the out of distribution issue introduced by using zero as input mask. Similar to (Kim et al., 2020; Li et al., 2020; Jacovi and Goldberg, 2021) we also use [MASK] token, with the difference that we allow masking of arbitrary length of an input sequence. Evaluations of Sample-based Methods A benchmark of evaluating sample-based explanation methods has not been agreed upon. For diagnostic purposes, Koh et al. (2017) proposed a self-explanation method that uses the training instances to explain themselves; Hanawa et al. (2020) proposed the label and instance consistency as a way of model sanity check. On the non-diagnostic setting, sample removal and re-training (Han et al., 2020; Hooker et al., 2019) assumes that removing useful training instances can cause significant accuracy loss; input enhancement method assumes useful explanations can also improve model's decision making at model input side (Hao, 2020), and manual inspections (Han et al., 2020; Meng et al., 2020a) were also used to examine if the Test Case been here a few times and food has always been good but service really suffers when it gets crowded. TracIn ++ opens some new questions: 1) how can we generalize TracIn ++ to cases where test spans are unknown? 2) Can we understand the connection between IF and TracIn which may spark discoveries on sample-based explanation methods? 3) How can we apply TracIn ++ to understand sequence generation models? This work is supported by the MIT-IBM Watson AI Lab. The views and conclusions are those of the authors and should not be interpreted as representing the official policies of the funding agencies. We thank anonymous reviewers for their valuable feedback. We also thank your family for the support during this special time.
abstain abstain abstain objective method objective abstain abstain abstain abstain abstain abstain abstain other abstain abstain abstain abstain abstain abstain abstain abstain abstain objective abstain objective objective objective abstain abstain abstain other other abstain abstain abstain abstain abstain abstain method method method abstain abstain abstain method method method method abstain method abstain method abstain method other abstain abstain method method method method abstain method abstain abstain abstain abstain method abstain abstain method abstain abstain abstain method abstain method abstain abstain other abstain abstain method other method abstain abstain method method abstain method method method method abstain abstain abstain method method method abstain abstain other abstain abstain abstain method abstain method abstain abstain abstain abstain abstain abstain abstain abstain abstain method abstain method abstain abstain abstain abstain method abstain method abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain method abstain result abstain abstain result abstain abstain abstain abstain method result abstain result abstain abstain abstain abstain abstain abstain result result abstain result abstain abstain abstain abstain abstain abstain abstain abstain abstain other other other other abstain other other other method other other method other other other abstain abstain method other other other other