{'fraction_non_alphanumeric': 0.041525858190606724, 'fraction_numerical': 0.0101172851777064, 'mean_word_length': 4.377517722516035, 'pattern_counts': {'":': 0, '<': 12, '<?xml version=': 0, '>': 1, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 43, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Argumentative Explanations for Pattern-Based Text Classifiers

Recent works in Explainable AI mostly address the transparency issue of black-box models or create explanations for any kind of models (i.e., they are model-agnostic), while leaving explanations of interpretable models largely underexplored. In this paper, we fill this gap by focusing on explanations for a specific interpretable model, namely pattern-based logistic regression (PLR) for binary text classification. We do so because, albeit interpretable, PLR is challenging when it comes to explanations. In particular, we found that a standard way to extract explanations from this model does not consider relations among the features, making the explanations hardly plausible to humans. Hence, we propose AXPLR, a novel explanation method using (forms of) computational argumentation to generate explanations (for outputs computed by PLR) which unearth model agreements and disagreements among the features. Specifically, we use computational argumentation as follows: we see features (patterns) in PLR as arguments in a form of quantified bipolar argumentation frameworks (QBAFs) and extract attacks and supports between arguments based on specificity of the arguments; we understand logistic regression as a gradual semantics for these QBAFs, used to determine the arguments' dialectic strength; and we study standard properties of gradual semantics for QBAFs in the context of our argumentative re-interpretation of PLR, sanctioning its suitability for explanatory purposes. We then show how to extract intuitive explanations (for outputs computed by PLR) from the constructed QBAFs. Finally, we conduct an empirical evaluation and two experiments in the context of human-AI collaboration to demonstrate the advantages of our resulting AXPLR method.


Introduction
Humans have been using explanations in AI for many purposes such as to support human decision making [1,2], to increase human trust in the AI [3,4], to verify and improve the AI [5,6], and to learn new knowledge from the AI [7,8]. Explanations may also be required for an AI-assisted system to comply with recent regulations including the General Data Protection Regulation (GDPR) [9]. These various needs for explanation have drawn a great amount of attention to the field of explainable AI (XAI) in recent years [10]. When AI-assisted systems are used for prediction (referred to as prediction models or simply models in the literature and in this paper), explanations of interest are often categorized broadly into two types: local explanations and global explanations [10], where the former focus on explaining the predictions for specific inputs while the latter aim to explain the behavior of the model in general, irrespective of any inputs that it may take. If the model is inherently interpretable [11] (e.g., a decision tree), the model itself can be viewed as the global explanation whereas local explanations can be obtained during the prediction process (e.g., the corresponding path in the decision tree for the input, leading to the output/prediction). In this paper, we refer to explanations straightforwardly extracted from inherently interpretable models (e.g., the applicable path in a decision tree) as model-inherent explanations. However, if the model is opaque (e.g., it is a deep learning model), we may need to apply an additional step, by using a so-called post-hoc explanation method (e.g., LIME [12] and SHAP [13]), for extracting the explanations.
A number of properties of explanations have been identified as desirable in the literature, e.g., as in [14]. Amongst them, generally, we call an explanation faithful to the model if it accurately reflects the true reasoning process of the model (e.g., as discussed in [15]). Meanwhile, an explanation is deemed plausible if it agrees with human judgement (e.g., see [16]). These two properties of explanations, i.e., faithfulness and plausibility, may be important in different situations. For instance, we want faithful explanations in order to verify the model correctness while we want plausible explanations to satisfy end users. Note that model-inherent explanations can be deemed faithful due to their straightforward and sensible explanation extraction process. However, this does not guarantee other desirable properties of the explanations. For instance, using a decision tree path with depth of 15 as an explanation is not comprehensible to humans and, therefore, not very plausible either. Post-hoc explanations could be more effective for impressing end-users in this case though they are not inherently extracted from (or perfectly faithful to) the underlying interpretable model (i.e., the decision tree).
In this paper, we develop a novel post-hoc local explanation method that aims to generate plausible explanations for a specific class of interpretable prediction models performing binary text classification with natural language data. Binary text classification aims to classify a given text into one of two possible categories. Examples of binary text classification (both studied in this paper) are sentiment analysis (where a piece of text is classified as having positive or negative sentiment) and spam detection (where a message is classified as spam or not). Our interpretable prediction models are built using logistic regression (LR) [17, chapter 5] with textual patterns [18] as features. LR is a traditional machine learning method, leading to interpretable models with linear combinations of features, that can be used, in particular, for text classification [17, chapter 5]. Because text documents are unstructured data, we need to perform feature extraction so as to obtain numerical representations of the documents before training the LR classifier. One standard way to do feature extraction is using frequent n-grams (i.e., frequent n consecutive words in the dataset) as features and applying TF-IDF vectorization to find associated values of the features [19, chapter 2]. Though using n-grams as features is simple and often effective, it makes the model less generalizable to words or n-grams that have never appeared during training. Also, the features are usually too fine-grained for humans to synthesize the overview of what the model has learned even though LR is inherently interpretable. In this paper, as elsewhere (e.g., [20][21][22]), we use patterns as interpretable features for prediction, in alternative to n-gram features. We call our models of interest pattern-based logistic regression (PLR) models.
PLR models are inherently interpretable because LR is interpretable and because their features are interpretable and, as we will show, convenient for humans to learn or to extract knowledge from. However, their model-inherent explanations for PLR may not be plausible. This issue is especially critical when interactions among input features underpin the model whereas the model-inherent explanations treat features independently of each other. These feature interactions may result from agreement or disagreement between correlated pattern features. In order to address this problem, our proposed explanation method leverages computational argumentation (CA) to take care of the feature interactions and generate more plausible local explanations than the model-inherent explanations. We call our novel explanation method (combining LR, textual patterns, and CA) Argumentative eXplanations for Pattern-based Logistic Regression (AXPLR, pronounced "ax-plore"). 1 Generally, local explanations often have an argumentative spirit by nature since they need to argue for or against possible predictions of the model [23]. When there are several arguments involved, these arguments may also have dialectical relationships between each other. Hence, there are several existing works which use computational argumentation to underpin XAI methods and produce argumentative explanations. For example, DEAr [24] considers related training examples as arguments, which argue to classify a test example, and uses a dispute tree [25] as dialectical explanation. DAX [26] extracts local argumentative explanations from a deep neural network by using arguments and their relations to represent the nodes and their connections in the neural network. (For more approaches, see recent survey papers of argumentative XAI [23,27].) In our work, AXPLR uses pattern-based input features of the PLR model as arguments and draws dialectical relations from specificity of the pattern features. All are modeled using modified versions of Quantitative Bipolar Argumentation Frameworks (QBAFs) [28] before being processed and translated into argumentative explanations for human consumption. Specifically, we use two variants of QBAFs. Both include a mapping associating arguments with the classification they advocate, in addition to arguments, attack and support relations and base scores as in standard QBAFs. The two variants differ in the way they use specificity of patterns to define the direction of attacks and supports.
We summarize the contribution of our work as follows.
• We show that model-inherent local explanations for pattern-based logistic regression can lead to implausible explanations. • We propose AXPLR, a novel argumentative explanation method, to tackle the above problem by modeling relationships among pattern features using quantitative bipolar argumentation. • We prove that the argumentation framework underpinning AXPLR always predicts the same output as the original PLR model and satisfies several dialectical properties of human debates. • Using three binary text classification datasets, we conduct an empirical evaluation of the extracted argumentation frameworks. Moreover, for the same datasets, we conduct two human experiments to evaluate how plausible and helpful AXPLR is for human consumption compared to other explanation methods.
In the remainder of the paper, we explain the pattern-based logistic regression (PLR) model in Section 2. Then we discuss the weakness of the model-inherent explanations for PLR in Section 3. After that, Section 4 describes the two variants of QBAFs underpinning AXPLR, while Section 5 shows that these QBAFs satisfy many dialectical properties of human debates, leading to leaner derived AXPLR (of which the presentations are described in Section 6). Next, the experimental setup for AXPLR is explained in Section 7, followed by one empirical experiment in Section 8 and two human experiments (to assess the amenability of the argumentation underpinning AXPLR specifically) in Sections 9 and 10. Lastly, we discuss other possible uses of AXPLR in Section 11, position our work with respect to other related work in Section 12, and summarize the paper in Section 13.

Background
In this section, we provide necessary background on text classification (see Section 2.1) and PLR, including logistic regression (LR) which is the core machine learning method of PLR (see Section 2.2) and pattern features as well as the pattern extraction algorithm GrASP [18] used for constructing pattern features from training data (see Section 2.3). We conclude with an illustration of the overall process of PLR combining LR with GrASP for text classification (see Section 2.4). To illustrate ideas, we will use sentiment analysis as a running example of text classification throughout this section.

Binary Text Classification
We focus on the binary text classification task with two classes, using, as conventional, C = {0, 1} as the set of classes. For example, in the case of sentiment analysis, 0 stands for negative sentiment and 1 stands for positive sentiment. A training dataset D contains N different pairs of the form (x, y) where x is an input text and y ∈ C is the true class label of x. This dataset is used to train a classifier, which determines the probability of classes for any given input. In the context of binary text classification, D can be split into disjoint sets D + and D − , containing positive examples (y = 1) and negative examples (y = 0) in D, respectively. A classifier trained on D determines, for input x, a classŷ ∈ C.

Logistic Regression
For each input text x, let us assume that x can be represented as a feature vector f = [ f 1 , f 2 , . . . , f d ] where f i is a feature and d 1 is the number of features used to represent x. Then, an LR model targeting binary classification gives where w ∈ R d and b ∈ R are weights and bias of the LR model, respectively. The sigmoid function (so called a logistic function) is used to convert any real number into a value between 0 and 1: where z = 0 yields sigmoid(z) = 0.5. Note also that 1 − sigmoid(z) = sigmoid(−z). Normally, if , we predict class 1 for input x (i.e.,ŷ = 1). Otherwise, we predict class 0 (i.e.,ŷ = 0). The LR model is obtained after the training process is completed; it is fully characterized by w and b which minimize the objective function (typically the binary cross-entropy loss) to be used for predicting unseen examples (in some test datasets, for example).
The next questions are "How do the d features look like for text?" and "How can we obtain them?". We use pattern features whereby patterns indicate high-level characteristics of words in input texts, in addition to specifying exact words or lemmas. These high-level characteristics include both syntactic attributes (such as part-of-speech tags) and semantic attributes (such as synonyms and hypernyms). Thereby, we choose GrASP for this purpose.

Pattern features and GrASP: GReedy Augmented Sequential Patterns
GrASP is a supervised algorithm which learns expressive patterns able to distinguish two classes of text [18]. An example of GrASP pattern for distinguishing between positive and negative texts in sentiment analysis is This pattern matches, for example, a sequence of two words where the first word is "nothing" and the second word is a positive word according to a specific lexicon (such as the one released by [29]). Moreover, the pattern allows at most two additional words in-between to increase flexibility of the pattern. Examples of texts matched by this pattern include: "There is nothing delicious in this dinner ." and "... worse products . Nothing is delicate ! ..." where the bold-face words are words matching components in the pattern.
GrASP is applied directly to the training data. In order to use it, we need to prepare two lists of texts containing positive and negative examples that we want to distinguish. Also, we need to specify some hyperparameters such as the desired number of patterns, the number of gaps allowed, the set of linguistic attributes which can appear in the patterns, and the maximum number of attributes per pattern.
In the experiments in this paper, we employ the publicly released implementation of GrASP [30] which provides several built-in attributes that are suitable for classification tasks in general, e.g., the token text itself, its lemma, its hypernyms (according to wordnet [31]), part-of-speech tags, and sentiment tags. The resulting GrASP patterns are used as features in the LR model. Note, however, that we do not utilize the associated class GrASP assigns to each pattern to classify the input directly because GrASP does not tell us how to properly deal with the input that matches multiple (and potentially contradicting or relating) patterns. Instead, we use the patterns from GrASP only as features for training a classifier, letting the classifier decide how multiple patterns should play their roles and contribute to the final classification.

PLR using GrASP
In this paper, we focus on PLR, i.e., LR with GrASP patterns as features. To train PLR, we first split the training data D into D + and D − and feed them to the GrASP algorithm along with some hyperparameters mentioned above. After obtaining the d patterns, we extract the binary feature vector f for each training example x and use it to train the LR model together with the class label y. Specifically, for each input text x ∈ D, we extract the feature vector f = [ f 1 , f 2 , . . . , f d ] ∈ {0, 1} d where f i is a binary feature and d is the number of textual patterns used to represent x. f i equals 1 if the input x contains the pattern p i ; otherwise, f i equals 0. Then, to learn from the training data D, we train a binary logistic regression model using the binary cross-entropy loss (with a regularization term) as objective function.
During testing, given an unseen document x, we get the prediction by extracting the feature vector f using the d GrASP patterns and running the LR model on f. Figure 1 shows an illustrative example of how to make a prediction using a trained PLR model. Given the sentence "There is nothing better than hot sausages of this restaurant." as an input text x, we want to use a trained PLR model to predict the sentiment of this sentence. Assume that among the d patterns of the model, there are only four patterns Input x: There is nothing better than hot sausages of this restaurant. p 1 , p 2 , p 3 , and p 4 as shown in Figure 1 -that match this sentence. In other words, for i ∈ {1, 2, 3, 4}, f i = 1; otherwise, f i = 0. According to Equation 1, the probability of this text being a positive sentiment text, i.e., P(y = 1|x), equals sigmoid( . For the trained weights and bias in Figure 1, the predicted classŷ of x is positive (1) since the predicted probability is 0.5744, which is greater than 0.5.

Explaining PLR Classifiers: The Need for Argumentation
Since logistic regression is inherently interpretable and the GrASP patterns used are also interpretable, we can generate local explanations for inputs to a trained PLR model by reporting parts of the inputs that match the top-k patterns, in the spirit of much work in the XAI literature (e.g., [32, chapter 5] and [5]). Formally, given an input x, let s i be the contribution of the pattern p i for the predictionŷ, defined as follows, with reference to Equation 1: whenŷ = 1, s i = w i f i ; whenŷ = 0, s i = −w i f i (so, we can combine both cases to be s i = (−1)ŷ +1 w i f i ). Then we can return, as the local explanation forŷ, a list of triplets of the form (p i , π(p i , x), s i ) where s i , the contribution of pattern p i , is one of the k highest contributions and s i = 0, and π(p i , x) is a part of x that matches the pattern p i . We call this resulting model-inherent explanation the flat logistic regression explanation (FLX) (for x andŷ).
For the example in Figure 1, the input text x matches four patterns, and the model predicts class positive (i.e.,ŷ = 1). If we use FLXs, we can see that p 3 (which means the input text containing a positive word) has the highest contribution of 1.2. So, we will obtain (p 3 , π(p 3 , x), s 3 ) = ([[SENTIMENT:pos]], "better", 1.2) as the top triplet in the FLX (i.e., the most important reason) for predictingŷ = 1. Nevertheless, one problem with FLXs is that they do not take into account relationships among the patterns. For the example in Figure 1, the model has actually weakened the effect of p 3 by p 1 because the positive word in this case ("better") follows the word "nothing" and the model no longer considers it strongly positive in the context. What really makes the model answer positively is rather p 4 , which is considered less important by the FLX. Although the contribution of p 4 (0.5) is lower than that of p 3 , it is not overridden by other patterns. We could see that these four patterns are arguing to make the prediction, in that each pattern is an argument for or against the prediction. Some patterns have dialectical relations with one another (such as the disagreement between p 1 and p 3 ). Hence, to improve plausibility of the explanations and make them in line with the underpinning dialectical relations, we apply computational argumentation, as shown next, to generate local explanations for this PLR model. Specifically, we aim to use a form of) quantitative bipolar argumentation frameworks (QBAFs) [28] to simulate how the PLR model works on an input text. Intuitively, QBAFs are tuples comprising arguments, an attacks relation between arguments, a support relation between arguments and a base score for each argument. This conceptualisation serves our purposes well, as, intuitively, arguments in QBAFs can be used to represent applicable patterns, supports and attacks can reflect agreement and disagreement between these patterns, and base scores can represent the (learned) absolute weights of these patterns in the PLR model.

AXPLR: Argumentative Explanations for Pattern-Based Logistic Regression
In this section, we introduce our AXPLR method, whose overall generation process is shown in Figure 2, alongside the illustrative example from Figure 1. In Figure 2, the part above the purple line is the standard prediction process already captured in Figure 1, starting from extracting the feature vector from the input text and then computing the predicted probability using the model weights (w and b). Below the purple line, Figure 2 shows the four main steps for generating AXPLR. Using the feature vector and the model weights, the first step constructs a special type of quantitative bipolar argumentation framework (i.e., QBAFc) to represent relationships between the pattern features found in the input text (as well as the bias term b of the PLR model, corresponding to the top-most δ argument). This type of QBAF is special because each argument also supports a class in C, as represented by its background color. Particularly, the arguments with green background support the positive class, whereas the ones with red background support the negative class. The supported class, as well as the base score of the argument, is determined by the weight of the corresponding pattern (or the bias term b) in the PLR model. The second step computes the dialectical strength of each argument, considering its attacker(s) and supporter(s). Here, we propose a new strength function, returning a real number score in (−∞, ∞) that could reflect a class probability predicted by the PLR model (when the function is applied to the argument δ). With this new strength function, the dialectical strengths of some arguments might be negative, and thus possibly difficult to interpret (e.g., in Figure 2,what does it mean for argument α 1 (which supports the negative class) to support argument δ when the latter, having a negative strength, no longer supports the negative class?), so we do post-processing in the third step, making all the strength values to be positive and adjusting relations accordingly in a way that preserves the original meaning (e.g., in Figure 2, after δ's strength is flipped to be positive, its supported class then becomes the positive class; so, α 1 needs to attack δ and α 4 needs to support δ to preserve the original interactions between arguments). Finally, using the post-processed QBAFc, the fourth step generates the explanation which could be shallow (using only top-level arguments in the QBAFc) or deep (also using arguments at other levels in the QBAFc). The background color of text fragments matching the patterns reflects the postprocessed strengths of the corresponding arguments (where α 1 corresponds to "nothing better", α 2 to "nothing", α 3 to "better" and α 4 to "hot sausages"). Finally, we can present the explanations to humans.
In the remainder of this section, we provide details for the first three steps of the AXPLR generation process (in Sections 4.1, 4.2, and 4.3, respectively). Then, in Section 6, we give details of step 4. Before  that, in Section 5, we prove formal properties of (original and post-processed) QBAFcs, providing formal guarantees about their suitability to give rise to explanations.

QBAFc construction
To begin with, we define how two patterns can be related.
Definition 1. A pattern p 1 is more specific than or equivalent to another pattern p 2 (written as p 1 p 2 ) if and only if for every text t matched by p 1 , t is also matched by p 2 . In addition, p 1 is more specific than p 2 (written as p 1 p 2 ) if and only if p 1 p 2 but p 2 p 1 .
For instance, we can say from Figure 1 that p 1 p 3 because every text matched by p 1 is guaranteed to have a positive sentiment word which makes it matched by p 3 . However, p 3 p 1 because a text matched by p 3 is guaranteed to have a positive word but it may not have the word "nothing" followed by a positive word. These two facts also imply p 1 p 3 . Similarly, p 1 p 2 . Lemma 1. The relation is not reflexive and not symmetric, but it is transitive.
Next, we extract argumentation frameworks from a trained PLR model and a target input text x. These argumentation frameworks, like QBAFs [28], envisage that arguments can attack or support arguments, and that they are equipped with a base score. However, these frameworks differ from QBAFs in that the arguments therein support 2 classes (as indicated by the signs of the corresponding parameters in the PLR model). Moreover, these frameworks instantiate the notions of attack and support in generic QBAFs to match the computation of the PLR model. We name these frameworks QBAFcs (i.e., QBAFs with supported classes). We consider two ways to define dialectical relations in QBAFcs. Intuitively, we know that arguments for two patterns that are related by ≺ should be in a dialectical relation somehow; however, we are uncertain whether the more specific one should be the attacker/supporter or should be attacked/supported. So, we propose two variations of the extracted QBAFcs: top-down QBAFcs and bottom-up QBAFcs.  • R − T ⊆ A × A is the attack relation for the TQBAFc where • R + T ⊆ A × A is the support relation for the TQBAFc where To explain, both the TQBAFc and the BQBAFc use the same A, τ, and c. If the input text x matches n patterns, A will have n + 1 arguments. Amongst them, n arguments (those of the form α i ) are for the n matched patterns, while the other one is for the default argument (δ) corresponding to the bias term b in the LR model. Therefore, the QBAFcs always have at least one argument, which is the default. The supported class (c) of each argument depends on whether the corresponding weight in the LR model is positive or negative. If w i is positive, it means that the existence of the pattern p i contributes to the positive class. So, the supported class of α i should be positive (1). For the default argument, we consider the sign of the bias term b instead. Because the supported class encapsulates the sign, the base score (τ) of the argument will be only the absolute value of the corresponding weight.
The extracted TQBAFc and BQBAFc for the example in Figure 1 are shown in Figures 3 and 4, respectively. Following Definition 2, the differences between the TQBAFc and BQBAFc are the R − and R + components. For the TQBAFc, (arguments for) more specific patterns attack or support (arguments for) more general patterns. The most general patterns, in turn, attack or support the default argument. Hence, the more general patterns will stay "closer" to the default argument (which is usually placed at the top of QBAFcs when using graphs to visualise them in figures, as shown in Figure 3. That is why we call TQBAFcs top-down. Conversely, for the BQBAFc, (arguments for) more general patterns attack or support (arguments for) more specific patterns. The most specific patterns, in turn, attack or support the default argument. Therefore, the more specific patterns will stay "closer" to the default argument, as shown in Figure 4, so we call BQBAFcs bottom-up. To decide whether two arguments are related by attack or support, we check the classes supported by the arguments: if they support the same class, then they are related by support; otherwise, by attack.
We believe that both top-down and bottom-up arrangements may be legitimate, but in different situations. Later, in Section 6, we will show that, in TQBAFcs, we explain to users with general patterns first and provide more specific patterns as details when requested. In BQBAFcs, by contrast, we explain to users with specific patterns first (as they contain more information) and mention general patterns as supporting or opposing reasons.
After this point, when we mention a QBAFc in this paper, we mean that it could be either a TQBAFc or a BQBAFc, unless otherwise stated. We assume that any generic QBAFc is of the form A, R − , R + , τ, c . Furthermore, following notations in related work [28], we use R − (a) and R + (a) to represent sets of arguments attacking and supporting the argument a, respectively. Formally, R − (a) = {b ∈ A|(b, a) ∈ R − } and R + (a) = {b ∈ A|(b, a) ∈ R + }.
in Definition 2 that δ never attacks or supports any other argument. So, its out-degree equals 0, and therefore we usually put it at the top of figures (as shown in Figures 3 and 4).
Additionally, thanks to Definition 2 and Lemma 2, the graph structures underlying any TQBAFc and BQBAFc are directed acyclic graphs (DAGs). Theorem 1. The graph structure of any QBAFc is a directed acyclic graph (DAG).

Strength calculation
After we obtain the QBAFcs, the next step is to calculate the dialectical strength of each argument therein. To make this strength faithful to the underlying PLR model, we propose the logistic regression semantics, given by the strength function σ, defined next. Definition 3. The logistic regression semantics is defined as the strength function σ : A → R, where, for any a ∈ A: where τ(a) is the base score of a and ν(b) is the out-degree of b.
This semantics can be applied to both TQBAFcs and BQBAFcs. According to Equation 3, the strength of an argument starts from its base score, and it is increased and decreased by the strengths of its supporters and its attackers, respectively. However, the strength of each supporter/attacker must be divided by its out-degree (i.e., ν(b)) before being combined with the base score. Note that ν(b) in Equation 3 is always greater than or equal to 1 because b ∈ R − (a) or b ∈ R + (a), meaning that b attacks or supports at least one argument (which is a). So, no division by 0 may occur in this equation. Additionally, any argument a with no attackers or supporters (i.e., R − (a) = R + (a) = ∅) will have the strength equal to its base score, by Definition 3.
Because QBAFcs are DAGs (see Theorem 1), we can use topological sorting to define the order to compute the arguments' strengths. Considering the TQBAFc in Figure 3, for example, α 1 and α 4 do not have any attacker or supporter, so their strengths equal their base scores. Next, we can calculate the strengths of α 2 and α 3 , and then δ: All the results are displayed in Figure 3. Similarly, the strengths are computed for the BQBAFc and shown in Figure 4. We can see that the strength of the default arguments δ of both TQBAFc and BQBAFc is equal to the absolute of the logit  (1) The predicted probability for the class c(δ) equals sigmoid(σ(δ)).

Proof. See Appendix A.3.
In other words, we can read the prediction from the default argument δ. The negative strength of δ implies that the argument can no longer support its originally supported class; therefore, the prediction must be the opposite class. Since σ(δ) is computed from τ(δ) and the strengths of the attackers and the supporters of δ, we can use these attackers and supporters as explanation for the prediction. Furthermore, we may generalize the results of Theorem 2 to other arguments α i ∈ A. For instance, in Figure 4, we could say that the pattern [[TEXT:nothing], [SENTIMENT:pos]] of α 1 (weakly) supports the negative class with α 1 's strength of 0.1, but it is not sufficient to make the final prediction become negative (indeed, even after the support by α 1 , the strength of δ remains negative, meaning that the final prediction is no longer the class δ originally supports, i.e., no longer the negative class).

Post-Processing
We have shown how to extract QBAFcs, equipped with a suitable notion of dialectical strength to match the workings of PLR so as to serve as a basis for explanation thereof. Nevertheless, when arguments in these QBAFcs have a negative dialectical strength, the human interpretation of any resulting explanations may be difficult. Using Figure 3 as an example, we can see that argument α 2 ([[TEXT:nothing]]), supporting the negative class, supports argument δ, which represents the final prediction. Due to δ supporting the negative class and σ(δ) being negative, we can read from the figure that the final prediction is the positive class. However, it is counterintuitive to say that a pattern for the negative class supports the prediction of the positive class. Hence, we propose a post-processing step for QBAFcs to pave the way towards explanations better aligned with human interpretation.
According to Definition 4, to post-process a QBAFc from the previous step, we change the supported class of arguments with negative strengths (σ(a) < 0) to the other class (i.e., c (a) = 1 − c(a)) and flip their base scores to be negative values (i.e., τ (a) = −τ(a)). Then we re-label attacks and supports between arguments according to the new supported classes c while keeping the direction of the edges intact. Figures 5 and 6 show the post-processed QBAFcs of Figures 3 and 4, respectively. Note that, in this step, we also remove any edges where the strengths of the attackers or the supporters equal 0. As a result of this post-processing, the dialectical strength for all arguments becomes positive (as shown also in Figures 5 and 6). Generally: Theorem 3. Given a QBAFc A, R − , R + , τ, c and the corresponding QBAFc A , R − , R + , τ , c , using the logistic regression semantics σ, let σ(a) and σ(a) represent the dialectical strength of a ∈ A = A in QBAFc and QBAFc , respectively. Then, the following statements are true: Furthermore, Theorem 2 also applies to QBAFc s, as follows: Corollary 2. For a given QBAFc , the prediction of the underlying PLR model is the class c (δ) with the predicted probability of sigmoid(σ(δ) ). Thus, intuitively, the effect of the post-processing step is to flip all the negative strengths to be positive, so we adjust the QBAFc accordingly, while preserving the interpretations of the arguments. For instance, if the original argument a has τ(a) = 0.3, c(a) = 1 and σ(a) = −0.5, the meaning is that the argument initially supports the positive class with the base score of 0.3, but after taking into account dialectical relations, it supports the negative class instead with strength 0.5. After post-processing, we will obtain τ (a) = −0.3, c (a) = 0 and σ(a) = 0.5, with the (equivalent) meaning that the argument supports the negative class with strength 0.5.

Analyzing Properties of QBAFc and QBAFc
In this section, we analyze the logistic regression semantics σ, when applied to QBAFcs and QBAFc s, according to 11 group properties of gradual semantics proposed in [28]. These properties have been used to evaluate many argumentation frameworks and semantics in the literature [33][34][35] in order to ensure that the frameworks and semantics will lead to explanations that are consistent with general human reasoning and debate. Table 1 gives the formal definition of these properties for QBAFs A * , R − * , R + * , τ * under semantics σ * . Note that these properties apply naturally to QBAFcs of the form A, R − , R + , τ, c and QBAFc s of the form A , and so on. The definition of < between two sets used in GP10 and GP11 is defined as follows. Given P ⊆ A and Q ⊆ A, P Q if and only if there exists an injective mapping f from P to Q such that ∀α ∈ P, σ(α) σ( f (α)). Furthermore, P < Q if and only if P Q but Q P. Table 2 summarizes our results (the proofs are in Appendix A.5). To briefly explain here, GP1 is satisfied by both QBAFc, σ and QBAFc , σ because when there is neither attacker nor supporter, the right side of Equation 3 has only τ(α) left, making the argument's strength equal its base score. Meanwhile, GP2-GP5 are not satisfied by QBAFc, σ since the strengths of attackers and supporters of QBAFc (not yet post-processed) could be negative. As a result, when an argument has only attackers,  Table 1 Dialectical properties for QBAFs A * , R − * , R + * , τ * under semantics σ * (adapted from [28]).
it may not be the case that its strength becomes lower than its base score (i.e., GP2 may not be satisfied). Similarly, when an argument has only supporters, it may not be the case that its strength becomes higher than its base score (i.e., GP3 may not be satisfied). Furthermore, the strength of an argument in QBAFc, σ could be less than its base score due to not only attackers with positive strengths but also supporters with negative strengths, making GP4 unsatisfied. Similarly, when the strength of an argument in QBAFc, σ is higher than its base score, it could also be due to attackers with negative strengths (not only supporters with positive strengths), making GP5 unsatisfied. In contrast, after we post-process QBAFc to be QBAFc , no argument strengths can be negative (see Corollary 1); therefore, GP2-GP5 are satisfied by QBAFc , σ . Next, GP6 and GP9 are satisfied by both QBAFc, σ and QBAFc , σ as we can easily see from Equation 3. As for GP2-GP5, GP7 and GP8 may not be satisfied by QBAFc, σ due to the fact that, in QBAFc, the strengths of attackers and supporters could be negative, whereas QBAFc , σ satisfies GP7 and GP8 since QBAFc does not suffer from negative strengths. Lastly, both QBAFc, σ and QBAFc , σ do not satisfy GP10 and GP11 because the < relation imposes a condition only on argument strengths while our semantics σ considers not only the strengths of the attackers and the supporters but also their out-degrees. For illustrative counterexamples of these GPs, please see Appendix A.5.
In conclusion, QBAFc , σ satisfies nine out of the eleven group properties, while QBAFc, σ satisfies only three. This means that our post-processing step is important to make the argumentation framework align better with human interpretation and become more suitable for generating local explanations.

Presenting AXPLR to humans
Presenting the whole QBAFc as a local explanation to lay users may not be a good idea since the graph could be very complicated (in terms of the number of arguments, relations, and depth). Also, the notions of attack and support may not be familiar to the users. So, the last step of AXPLR is extracting the explanation from the QBAFc . We know from Theorem 2 and Corollary 2 that the prediction of the LR model is associated to the strength of the default argument δ. Hence, we can explain the prediction based on how σ(δ) was calculated. The value of σ(δ) depends on τ (δ) (corresponding to the bias term in LR) and the strength σ of all the attackers and supporters of δ. Therefore, we return, as the local explanation for c (δ), a list of triplets (p j , π(p j , x), σ(α j ) ) where x is the input text, α j (representing the pattern p j ) is one of the k strongest supporters of δ, and π(p j , x) is a part of x that matches the pattern p j . If we want both evidence for and counter-evidence against the prediction, we can show triplets (p j , π(p j , x), σ(α j ) ) for the top k supporters and attackers with the highest σ(α j ) . We call explanations of this form shallow AXPLR. Figure 7 shows an example of shallow AXPLR (extracted from a BQBAFc ) for the deceptive review detection task 3 where the color intensity represents the strengths of the arguments. Shallow AXPLR are similar to the flat logistic regression explanations (FLXs) introduced in Section 2.4. The only differences are that (i) FLXs select the top k patterns based on the size of w j f j (which is equivalent to τ(α j )) while our shallow AXPLR select top k arguments based on the dialectical strength σ(α j ), and (ii) any patterns matched in x can be in FLXs whereas only attackers and supporters of δ can be in shallow AXPLR.
Shallow AXPLR leverage only the attackers and supporters of δ, but ignores the additional information available in the QBAFc . Therefore, we propose another variation of AXPLR, called deep AXPLR, which also use other arguments and relations in the QBAFc . Basically, deep AXPLR expand shallow AXPLR by additionally allowing users to see attackers and supporters (if any) of arguments in shallow AXPLR as well as "deeper" arguments in the QBAFc until there is no attacker or supporter for those arguments. Figure 8 shows a deep AXPLR, explaining the same example and using the same BQBAFc as the shallow AXPLR in Figure 7 does. Note that a deep AXPLR from a BQBAFc (as in Figure 8) shows specific patterns to the users first (as they directly support or attack δ) and hides more general patterns as supporting or opposing reasons (to be expanded) in deeper levels. In contrast, due to the opposite way of drawing attacks and supports, a deep AXPLR from a TQBAFc explains to users with general patterns first and provides more specific patterns as expandable details in deeper levels.
Shallow and deep AXPLR are just two examples of explanations that can be drawn from QBAFc s. We leave the study of other forms of explanations, such as conversational explanations [36] and counterfactual explanations [37], for future work.

Experimental Setup
To evaluate AXPLR, we conducted both empirical and human evaluations. For the empirical evaluation, we calculated some statistics for the QBAFcs extracted for target examples and performed analyses concerning sufficiency of the generated explanations (see Section 8). For the human evaluation, we (i) assessed plausibility of the explanations, i.e., how well the explanations from AXPLR align with human explanations compared to a standard method for explaining LR results (see Section 9), and (ii) assessed how well AXPLR can teach and support humans to perform a new task (see Section 10).
In the experiments, we targeted binary text classification using three English datasets as shown in Table 3. The table also shows the classes we consider as positive and negative when running GrASP and  • SMS Spam Collection [38] focusing on detecting spams in a collection of SMS (short message service) messages. The dataset is imbalanced, containing 13.40% spam messages and 86.60% ham messages (i.e., non-spams). • Amazon Clothes [39], focusing on classifying whether a review (of clothing, shoes, and jewelry products) has positive or negative sentiment. The overall dataset is balanced. • Deceptive Hotel Reviews [40,41] focusing on identifying whether a given hotel review is truthful (genuine) or deceptive (fake). There are 1600 reviews in total for 20 hotels. For each hotel, there are 20 truthful positive, 20 truthful negative, 20 deceptive positive, and 20 deceptive negative reviews (positive and negative here refer to the review sentiment).
For the LR classifiers of the first two datasets, the GrASP patterns were constructed with lemma, part-of-speech tags (POS), wordnet hypernyms, and sentiment attributes. We used alphabet size of 200, allowed two gaps in the patterns, and generated 100 patterns in total. For the last dataset (Deceptive Hotel Reviews), the settings were the same except that we used text attributes (capturing the whole word) instead of the lemma attributes and we generated 200 patterns in total. The performance of the LR classifiers of the three datasets are reported in Table 4. Accuracy is the percentage of correct predictions on the test set, while F1 is a harmonic mean of Precision and Recall of the model. Positive F1 and Negative F1 are F1s when we consider the positive and the negative classes as the main class. These

Experiment 1: Empirical Evaluation
We divide the empirical evaluation into two parts. The first part discusses the statistics for QBAFcs and QBAFc s we generated from the test sets. This helps us understand what the argumentation graphs look like on average. The second part focuses on sufficiency, aiming to answer "How many supporting arguments are needed on average so as to sufficiently make the model predict what it predicts?". This helps us decide how many arguments we should show in AXPLR generally.

Statistics for QBAFcs and QBAFc s
Tables 5-7 show the statistics of the QBAFcs and QBAFc s for the SMS Spam Collection, Amazon Clothes, and Deceptive Hotel Reviews, respectively. We measure the number of arguments supporting positive and negative classes (A +,δ and A −,δ respectively, defined below), the number of pairs in the (attacks and support) relations (R), and specifically those not involving the default argument (R \δ ): Note that, if R \δ = ∅, then the generated AXPLR amounts to a FLX where we do not consider relationships between features. We consider both the statistics for the whole test sets and the statistics for each of the four possible situations -true positives (TP), true negatives (TN), false positives (FP), and false negatives (FN). TP and TN are the cases where the model correctly predicts that the true class is 1 and 0, respectively. FP refers to cases when the predicted label is 1 but the true label is 0. On the contrary, FN refers to cases when the predicted label is 0 but the true label is 1. For more details, please see Appendix B.
Number of arguments. The spam dataset had the minimum average number of arguments (∼ 10 arguments per example as shown by |A| in Table 5 Table 5), we find 36 arguments per example on average. Looking at the underlying PLR model, we found that the default argument δ before post processing supported the negative class with τ(δ) = 5.800 (not shown in the Table), which was very high compared to the base scores of other arguments. This means that the classifier answered "Not spam" by default unless it could identify sufficient evidence to answer "Spam". Even true negative examples (TN) had around three arguments for the negative class on average, including δ. Interestingly, false negative examples (FN) had a relatively higher number of arguments than true Table 5 Statistics (Average ± SD) of QBAFc and QBAFc for the SMS Spam Collection dataset. TP, TN, FP, and FN stand for true positives, true negatives, false positives, and false negatives, respectively. A +,δ , A −,δ are sets of arguments supporting positive and negative classes, respectively. R is a set of (attack and support) relations, whereas R \δ is a subset of R containing specifically those not involving the default argument δ.

Measurement
TQBAFc negatives, but still less than those of true positives (TP). This implies that the false negative examples usually had some, but insufficient, evidence for the positive class, compared to the true negatives which almost have nothing. Unlike the SMS Spam Collection dataset, the base scores of δ for the Amazon Clothes and the Deceptive Hotel Reviews datasets were 0.2597 and 0.6932 supporting the negative class, respectively (not Table 6 Statistics (Average ± SD) of QBAFc and QBAFc for the Amazon Clothes dataset. TP, TN, FP, and FN stand for true positives, true negatives, false positives, and false negatives, respectively. A +,δ , A −,δ are sets of arguments supporting positive and negative classes, respectively. R is a set of (attack and support) relations, whereas R \δ is a subset of R containing specifically those not involving the default argument δ.

Measurement
TQBAFc shown in the tables). In order to push the prediction to either positive or negative, we needed evidence. Hence, the average number of arguments for these two datasets were similar for both classes (as shown by |A| of TP, TN, FP, FN in Tables 6-7). Examples predicted as positive, therefore, had higher number of arguments for the positive class (|A +,δ |) than those predicted as negative.
Similarly, examples predicted as negative had higher number of arguments for the negative class (|A −,δ |) than those predicted as posi- Table 7 Statistics (Average ± SD) of QBAFc and QBAFc for the Deceptive Hotel Review dataset. TP, TN, FP, and FN stand for true positives, true negatives, false positives, and false negatives, respectively. A +,δ , A −,δ are sets of arguments supporting positive and negative classes, respectively. R is a set of (attack and support) relations, whereas R \δ is a subset of R containing specifically those not involving the default argument δ.

Measurement
TQBAFc Number of relations. |R| had the similar trend as the number of arguments. Texts predicted as spams had a significantly higher number of attacks and supports than those predicted as non-spams (see |R − | and |R + | in Table 5). For the other two datasets, they usually had more supports than attacks, especially after post-processing, to provide sufficient evidence for the predictions. In any case, all three datasets had |R \δ | from 8 to 12, on average, making the explanations extracted from the QBAFc s (i.e., the AXPLR) different from the standard explanations for logistic regressions (i.e., the FLXs) due to many relations between features.
Other remarks. First, the number of arguments |A| for the TQBAFc, TQBAFc , BQBAFc, and BQBAFc for the same example are always equal. This is expected from Definitions 2 and 4. Second, |R| is different for TQBAFcs and BQBAFcs but their |R \δ | are the same. This is because TQBAFcs and BQBAFcs have the same relations between two non-default arguments except that the directions are reversed.

Sufficiency
Next, given a QBAFc , we were interested in the number of supporting arguments needed in order to sufficiently explain the prediction. Here, sufficiently means that given the base score of δ and all the attacking arguments, the strengths given by these supporting arguments are enough to make the strength of δ greater than 0. In other words, for each test example, we wanted to find the smallest k such that S ⊆ R + (δ), |S | = k and Furthermore, we extended our question to other arguments in QBAFc which had at least one attacker or supporter. (We call them intermediate arguments.) We wondered how many supporting arguments were needed to make the strength of the argument greater than 0, taking into account the base score and all the strengths from the attackers. Knowing the answers to these questions helps us decide how many arguments we should show to the users for explaining the final prediction or the intermediate arguments. Figures 9-11 show the results of this experiment. The x-axis of each plot is the number of supporting arguments used (k), whereas the y-axis shows the percentage of arguments (default or intermediate) of which the strength can be greater than 0 by using only k supporting arguments. Considering plots on the left-hand side of the three figures, we can see that the numbers of supporting arguments needed for δ were different for each dataset. The SMS Spam Collection dataset seemed to need the least. However, this was the case only for examples predicted as negative, i.e., the supported class was not flipped after post-processing, corresponding to Figure 9(c). The reason was that the base score of δ was relatively high. It could outnumber the strengths from the attackers even without the strengths from the supporters. Nevertheless, this was not true when the supported class flips from negative to positive as it required 4-6 supporting arguments to make 80% of the test set have sufficient explanations. Meanwhile, the Amazon Clothes and the Deceptive Hotel Reviews datasets required approximately 1-3 and 3-4 supporting arguments, respectively, for sufficient explanations of 80% of the test set (regardless of the predicted class). Besides, for the SMS Spam Collection and the Amazon Clothes datasets, BQBAFc required more supporting arguments than TQBAFc . This was likely because BQBAFc connected the arguments representing the most specific patterns to the default. For these two datasets, they outnumbered the most general patterns TQBAFc connected to the default. So, the default argument of BQBAFc had more supporters where the strengths were distributed. Therefore, more supporters were required to make the sufficient explanation.
Considering the plots on the right side of Figures 9-11, only one supporting argument was usually

Experiment 2: Plausibility
In this section, we aimed to evaluate the plausibility of AXPLR, compared to FLX, to confirm our hypothesis that it is essential to consider relations between features (i.e., patterns) when we generate local explanations. So, we compared the feature scores given by the explanation methods to scores reflecting how humans consider the features. For instance, if a machine indicates pattern p 1 as a main reason for predicting the positive class and humans think that p 1 is truly a sign of the positive class, we can say that the machine explanation aligns well with human judgement (i.e., having high plausibility). In other words, the higher correlation between machine explanation scores and human scores implies the higher plausibility of the explanation method. Hence, we chose Pearson's correlation as the metric in this experiment.

Datasets
We used the SMS Spam Collection (spam filtering) and the Amazon Clothes (sentiment analysis) datasets since humans generally perform well on these two tasks, making the human scores reliable. For each dataset, we needed 500 test examples for evaluation. These examples must have the predicted probability of the output class greater than 0.9 to ensure that the bad quality of the explanation was not due to low model accuracy or text ambiguity. Note that we did not conduct this experiment on the Deceptive Hotel Reviews dataset as lay humans are not adept at identifying deceptive reviews. The human accuracy was only around 55% in [8], so we cannot trust human judgement on machine explanations in this task. We would work on the deceptive review detection task in the next experiment instead.

Machine Explanations
As discussed in Section 6, both FLX and AXPLR use (p j , π(p j , x), s j ) triplets as explanations where s j is the score of the pattern p j or the match π(p j , x) in the input x. For FLX, s j equals w j f j , and any p j with the relatively large score s j can be chosen as a part of the explanation. By contrast, shallow AXPLR uses only arguments at the top level of the underlying QBAFc, i.e., arguments attacking or supporting δ, as explanations. Meanwhile, deep AXPLR can use any arguments in the QBAFc. The s j of AXPLR also depends on whether the QBAFc is TQBAFc or BQBAFc. So, we compared all of these variations in this experiment. Note that, because τ and σ of AXPLR need to be interpreted with the supported class, we adjusted s j for AXPLR to be self-contained. To put it simply, we multiplied τ (α j ) and σ(α j ) of AXPLR with 1 if c (α j ) = 1, or with -1 if c (α j ) = −1. This made the higher s j always imply the stronger evidence for the positive class (similar to FLX).

Human Scores
We recruited human participants via Amazon Mechanical Turk (MTurk) 4 and asked them whether the pattern p j or the matched phrase π(p j , x) was the evidence for the positive or the negative class. Since the pattern p j only may be difficult to understand, we provided the translation to help lay users on MTurk, as shown in Figure 12 (a). Another way to present the pattern is to show samples of phrases (from the training set) matched by the pattern. We also collected human answers for this pattern representation showing five unique samples per pattern 5 , as displayed in Figure 12 (b). Finally, a question for a single matched phrase π(p j , x) was a lot simpler as shown in Figure 12 (c). We provided five options for each question, ranging from definitely positive, positive, not sure, negative, and definitely negative. These correspond to the score 2, 1, 0, -1, and -2, respectively. For the SMS Spam Collection dataset, these options were instead definitely spam, spam, not sure, non-spam, and definitely non-spam. Each question was answered by five participants, and the scores were averaged before comparing with machine explanation scores.
Concerning the payment for answering questions, we paid the participants $0.30 per 10 pattern questions, $0.20 per 10 group-of-phrases questions, and $0.20 per 20 matched phrase questions.

Results
Tables 8 and 9 report the Pearson's correlations between the machine explanation scores and the human scores collected from Amazon Mechanical Turk for both datasets. The last row of each table shows inter-rater agreement measures (Fleiss' kappa) [42]. We observe that the agreement measures for the SMS Spam Collection dataset were very close to zero (especially for the questions for patterns and samples), while the agreement rates for the Amazon Clothes dataset (sentiment analysis task) were significantly higher. This was likely because evidence from the sentiment analysis task (including patterns, samples, matched phrases) usually conveys clear meanings even without contexts, whereas evidence from the spam detection task often requires contexts for humans to make decisions. For example, upset, worthless, and disappointed were surely for negative reviews. In contrast, mobile, win, and call could appear both in spam and non-spam texts. This caused higher disagreements in human answers though the model used these words certainly as evidence for the spam class. As a result, the human scores for the spam task were less reliable than the scores for the sentiment analysis task. Consequently, the overall correlations in Table 8 were also less than the scores in Table 9.
Hence, we focused on discussing the results in Table 9 with more reliable human scores. For each row, the correlation between the explanations and the human scores for patterns was lower than for samples and matched phrase. Hence, we should show not only the patterns but also some matched samples of the patterns to generate better plausible explanations. In addition, for TQBAFc and BQBAFc , the strengths of top-level arguments σ(α j ) were better than the base scores τ (α j ) in terms of the alignment with human judgement. The correlations were also significantly higher than FLX. This confirmed the advantage of the prominent feature of AXPLR, i.e., considering interactions between patterns when generating local explanations. However, by extending from arguments in the top level to all levels in the QBAFc , only the correlations in BQBAFc remained high, while the correlations in TQBAFc dropped. Therefore, deep AXPLR, utilizing arguments of all levels in the graph, would go along better with BQBAFc than TQBAFc . It also implied that the base scores of the most specific patterns, which equaled their strengths in TQBAFc , required some adjustments to align well with human judgement.

Experiment 3: Tutorial and Real-time Assistance
Among the three datasets, the deceptive review detection task is the most difficult tasks for humans. In this experiment, we follow the study [8] to evaluate how effective AXPLR can be used to teach and support humans to perform deceptive review detection.

Setup
We recruited participants via Amazon Mechanical Turk and redirected them to our a survey created using Qualtrics 6 . The survey aimed to assess the capability of humans to detect deceptive hotel reviews before and after they learn from explanations. It consisted of five parts.
(1) Attention-check questions (4 questions) -The participant needed to answer all the questions in this part correctly to proceed. (2) Pre-test (10 questions) -For each question, the participant was asked whether a given hotel review was truthful or deceptive. (3) Tutorial (10 questions) -The format was the same as part 2, but then, we revealed to the participant the correct answer and the AI-generated prediction and explanation for them to learn from. (4) Post-test (20 questions) -For the first ten questions, the questions and the format were the same as part 2. We additionally showed what the participant had answered during the pre-test as a reference. The next ten questions were the same as the first ten except that we also provided AI explanations (without the predictions) for these questions, as real-time assistance [8]. The format of the explanations was the same as what s/he had seen during the tutorial phase. The corresponding previous answer (from the first ten questions) was also provided when the participant answered each of the last ten questions. (5) Additional questions (5 questions) -The participant was asked general questions before finishing the survey. These include, for example, how they detected deceptive and truthful reviews and any (free-text) feedback they might want to tell us.
At the end of the survey, each participant was given a Reference ID as a proof that s/he had completed the task (i.e., the HIT) for claiming the reward from the MTurk system. The improved performance of humans after being trained and assisted by the explanations showed how useful the explanations were.
To motivate the participants to pay attention to the tasks, we divided the payment into two parts.
• A guaranteed reward ($2.00) was given after the participant completed the whole survey.
• A bonus reward -The participant was given an additional bonus reward of $0.10 for each question answered correctly (both in the pre-test and in the post-test). Therefore, the maximum bonus reward each participant could get was $0.10 x 30 = $3.00.

Explanations
We compared four explanation methods in this experiment including SVM, FLX, shallow AXPLR, and deep AXPLR. We selected linear SVM since there is a study [8] showing that tutorials from simple models such as linear SVM worked better than tutorials from deep models such as BERT [43]. To train the SVM, we used TF-IDF vectorizer and employed exhaustive search to find the best hyperparameter C ∈ {1, 10, 100, 1000}. As a result, the model achieved the accuracy and the macro F1 of 0.891. We generated the explanations for the SVM model by showing the most important 10 words according to the absolute value of SVM coefficients. We also highlighted these words in text with the color and the intensity reflecting the sign and the magnitude of the coefficient, respectively. An example of SVM explanations during the tutorial phase is shown in Figure 13.  Table 4. Note that the LR model underperformed the SVM model, with the accuracy of 0.853 and 0.891, respectively. We decided to use BQBAFc for both shallow and deep AXPLR due to two reasons. First, the top-level arguments of BQBAFc provided more contexts than those of TQBAFc , and n-gram explanations are usually better than word-level explanations thanks to more contexts provided [44]. Second, deep AXPLR went along better with BQBAFc than TQBAFc as discussed in Section 9. Both FLX and shallow AXPLR showed top 10 patterns/arguments and share the same presentation, as shown in Figure 7. Deep AXPLR also started from the top 10 arguments but allowed the users to expand them to see attacking and supporting arguments, as shown in Figure 8. Moreover, we provided the input text with highlights similar to SVM explanations to help the users locate where the patterns appear in the input. The intensity of the highlight represented the sum of the explanation scores of all patterns that the word matched. For AXPLR, we summed the scores from only the top-level patterns as the scores from other levels had been aggregated into the top level.

Question Selection
For test questions, we randomly selected 50 questions from the test set of the Deceptive Hotel Reviews dataset. Then we partitioned them into five question sets. One participant was assigned one set of test questions and one explanation method (for tutorial and real-time assistance). Each pair of explanation method and question set was assigned to five people. Overall, we had 4 explanation methods × 5 question sets × 5 annotations = 100 surveys in total. So, we recruited exactly 100 participants on MTurk without allowing a participant to do the survey twice.
For the ten tutorial questions for each explanation method, we selected them from the development set of the Deceptive Hotel Reviews dataset using submodular pick [12] to ensure that the selected examples covered important features of the task. Although submodular pick is a greedy algorithm, it provides a constant-factor approximation guarantee of 1−e −1 to the optimum [45]. This made the tutorial questions different for each explanation method except that shallow AXPLR and deep AXPLR share the same set of tutorial questions. Table 10 Scores of the human participants (Average ± SD) in the tutorial and real-time assistance experiment using the Deceptive Hotel Reviews dataset. The last column shows the average score of the model that provides real-time assistance. The maximum score is 10.

Explanation
Pre

Results
The average scores of human participants are displayed in Table 10. Using the pre-test scores as a baseline, we observe that the tutorial phase only did not help the participants perform better as the post-test scores without real-time assistance were not significantly greater than the baseline. However, the real-time assistance after the tutorial indeed helped. By the approximate randomization test with 1,000 iterations and a significance level of 0.05 [46,47], the post-test scores with real-time assistance from the explanations were significantly higher than the pre-test scores and the post-test scores with no assistance of the same explanation methods. Nevertheless, we see no significant difference across explanation groups, so we can conclude only that FLX, shallow AXPLR, and deep AXPLR are competitive with SVM for providing explanations to teach and support humans to detect deceptive reviews.
The last column in Table 10 shows the average performance of the underlying AI model on the same set of questions. SVM achieved 9 out of 10 in three question sets and 10 out of 10 in the other two, whereas the LR model (underlying FLX and AXPLR) got 7, 7, 8, 9, and 10 for the five question sets (regardless of the order). The total numbers of people that scored better than or equal to the AI during the pre-test, post-test with no assistance, and post-test with assistance are 6, 8, and 26 out of 100 people, respectively. This again shows the effectiveness of real-time assistance after the participants learned from the tutorial.
Finally, we asked the participants in the final part of the survey how they detected deceptive and truthful reviews. We manually selected interesting answers from the participants who got 8 correct answers or more during the post-test with AI assistance. The answers are shown in Tables 11 and 12. As expected, participants learning from SVM explanations rarely mentioned patterns but individual words. Some used the majority of highlighting colors as a heuristic (which was surprisingly effective, probably due to the good performance of SVM). Since FLX was extracted from the LR model with GrASP patterns, we noticed some patterns and generalizations noted by participants who learned from FLX such as "when my was closely followed by 1 and hotel was followed by different words" and "the language used, and symbols and punctuation". Similarly, we also saw patterns noted by participants who learned from both types of AXPLR such as "It uses pronouns closely together" and "The patterns of specific words close together stood out, like luxury hotel.", as well as implicit patterns such as "There's also much less usage of city and hotel names". On the other hand, they could also cover word-level cues, as we can see from the comments like "I would also assume it was deceptive if the reviewer said "I" a lot.". However, there was no participant in the deep AXPLR group mentioning the usefulness of sub-patterns (which could be expanded or collapsed). Also, the average scores of both types of AXPLR were not significantly different. It could imply that shallow AXPLR is already sufficient for tutorial and real-time assistance, without the need to go deep. Last but not least, we found two interesting comments from the deep AXPLR group. Table 11 Some answers from the participants on how they knew that a review was deceptive. These answers were manually picked from the participants who got 8 correct answers or more during the post-test with AI assistance. We also show the explanation method they were assigned and the final scores they got.

Explanation
Score Answer SVM 10 If it seems too biased and sounds exaggerated. 9 Certain key words are used repeatedly and unnaturally. 8 If it has more red than green.

FLX 9
Extreme and/or superlative language. 8 when my was closely followed by 1 and hotel was followed by different words 8 because of the words used, and naming the location, etc Shallow AXPLR 10 A city was not capitalized or the overuse and closeness of "my" and "I". 9 There were methods to look at the text or the type, as well as sentiment and identify some un natural responses. The patterns of specific words close together stood out, like luxury hotel. 8 It uses pronouns closely together, uses proper names for hotels and cities oddly, and so on.
Deep AXPLR 9 The review mentioned the city by name a few times and was accompanied by odd sounding and separated facts. 8 If the review kept mentioning the name of the city or referring to things as being luxurious or smelly, then I would generally assume that the review was deceptive. I would also assume it was deceptive if the reviewer said "I" a lot. 8 It uses certain turns of phrase that are highly improbable or likely to come from a genuine human. Syntax issues can also be indicative of a deceptive review.
One contrasted deceptive and truthful reviews -"If the review said "location" as apposed to naming the city, I was more likely to assume it was true, or if it mentioned the elevators or doormen. If it said "we" instead of "I" I was usually more inclined say it was truthful.". The other theorized the reason behind prominent patterns -"human phrasing that doesn't have hallmarks of being algorithmically generated or designed with the obvious intent to be picked up by a search engine (repeatedly mentioning the word Chicago was one example of this used).".

Discussion
We may conclude from the results of Experiment 3 that AXPLR is competitive with SVM and FLX in terms of assisting humans in detecting deceptive reviews. Also, according to the qualitative analysis, AXPLR helps humans capture non-obvious patterns which are helpful to perform the task to some degree. Still, there is a gap between human performance and model performance as we can notice in the last two columns of Table 10. To narrow down this gap further, there are some interesting directions that could be explored. First, how could we make the tutorial part more effective? We hypothesize that submodular pick might not be the best method to select tutorial questions. In fact, [8] has tried the spaced repetition strategy where humans are presented with important features repeatedly (with some space inbetween). However, it cannot be concluded from their experiment that spaced repetition is significantly better than submodular pick when it comes to selecting tutorial examples. It would be interesting to study whether there is a better method to select and arrange tutorial questions for supporting human learning.
Additionally, in our experiment, AXPLR transformed QBAFc into a local input-based explanation, identifying important parts in the input together with the associated patterns. However, there are other forms of explanations which could be extracted from QBAFc and might be more suitable for this task. One is counterfactual explanation, showing which arguments should be added or removed from the Table 12 Some answers from the participants on how they knew that a review was truthful. These answers were manually picked from the participants who got 8 correct answers or more during the post-test with AI assistance. We also show the explanation method they were assigned and the final scores they got.

Explanation
Score Answer SVM 10 It sounds truthful and may sometimes talk about both the good and bad of the experience. 9 Words are not frequently repeated and they are used in a natural manner. 8 If it has more green than red FLX 9 Down to earth. Pros and cons are expressed in a balanced, not hyperbolic way. 8 when the text wasnt too long and sounded realistic 8 the language used, and symbols and punctuation Shallow AXPLR

10
The use of brackets or parentheses.

9
The way the sentence was structured was far different then the other ones. The deceptive ones tried to appear truthful but the other ones just came off as natural. 8 It describes the layout and number of things in a more detailed fashion. There's less of a focus on repetitious usage of pronouns. There's also much less usage of city and hotel names.
Deep AXPLR 9 The review spoke on a personal level and did mention city names many times.

8
If the review said "location" as apposed to naming the city, I was more likely to assume it was true, or if it mentioned the elevators or doormen. If it said "we" instead of "I" I was usually more inclined say it was truthful. I also just payed attention to the overall vibe of the review. 8 Review features ordinary, human phrasing that doesn't have hallmarks of being algorithmically generated or designed with the obvious intent to be picked up by a search engine (repeatedly mentioning the word Chicago was one example of this used).
current QBAFc in order to change the model prediction. This may help humans better learn relative importance of the patterns. It is likely possible to extract counterfactual explanation from our QBAF', in line with a recent work by [37] extracting counterfactual explanations from argumentation frameworks for PageRank [48]. Besides, if needed, we could generate synthetic example(s) and/or QBAFc s to teach humans cases which are interesting but do not exist in the training data. For example, an input x 1 has a group of patterns strongly supporting the positive class, while an input x 2 has another group of patterns strongly supporting the negative class. What would happen if the two groups of patterns appeared in the same input? The answer to this question could aid humans in prioritizing knowledge learned from individual real examples. Combining groups of patterns is easier to do with AXPLR, but not FLX since FLX does not group related patterns together. Thus, overall, although AXPLR did not outperform existing methods significantly in this experiment, the experiment is a first step towards several possible extensions of AXPLR that may be worth exploring to better support human learning of new tasks.

General Considerations on AXPLR
According to Experiment 2, AXPLR renders highly plausible explanations compared to FLX, the traditional explanation method of LR. One possible reason for AXPLR not shining in Experiment 3 is that plausibility is not necessary for the tutorial and real-time assistance task. The task only requires humans to learn and apply useful patterns though they may not know the reasons why such patterns are for the genuine class or the deceptive class. On the other hand, AXPLR would be more suitable for the task where plausibility is needed. For example, if we use the classifier as a decision support tool, we want the explanation to provide insights about the input text that align well with human reasoning. Even though the prediction is correct, if the explanation does not make sense, it is possible that the humans distrust the model and make a wrong final decision, leading to undesirable consequences.
Another context where AXPLR could be useful is explanation-based human debugging of the model [49]. The individual model weight w i for the pattern feature p i may not make sense to humans when p i is in fact related to other pattern features (as we can see in Experiment 2, where τ(α i ) does not quite correlate with human reasoning). This may cause misunderstanding in the humans and lead to their feedback being harmful to the overall model performance. The QBAFcs of AXPLR would provide a more accurate view of how the pattern features have been used by the model. So, we believe that it is more likely leading to a successful model debugging than FLX. Moreover, with the argumentative structure of AXPLR, it would be interesting to see whether and how AXPLR could let humans argue with the model, contributing to a richer way of human-AI collaboration for reversing an undesirable output or improving the model.

Related Work
Local Explanations for Text Classification. Text classification is a fundamental task in natural language processing, so there exist many explanation methods which are applicable to this task. Focusing on local explanation methods (aiming to explain specific predictions), we can see several forms of explanations in literature such as extracted rationales [50,51], attribution scores [52,53], rules [54,55], influential training examples [56,57], and counterfactual examples [58,59]. Since AXPLR forms an explanation using triplets of a pattern p i , a matched phrase π(p i , x), and a score s i , it could be considered a mixture of rationales, attribution scores, and rules. This is another novelty aspect of AXPLR as we rarely find XAI work that combines multiple forms of explanations together. However, what makes this possible are the transparency of logistic regression (LR) and the interpretability of GrASP patterns. So, we classify AXPLR as a model-specific explanation method, unlike LIME [12] and SHAP [13] which are modelagnostic methods being applicable to any model architectures. Nonetheless, the issue of dependency between features is also found in other architectures besides LR, such as convolutional neural network (learned) features in [6]. Therefore, it would be interesting to study how to extend AXPLR to other architectures.
Computational Argumentation for Explainable AI. As discussed in the introduction, computational argumentation has been used to support some XAI methods and construct argumentative explanations in the literature. According to [23], existing works in this area can be divided into two groups. The first group (i.e., intrinsic) draws explanations from models that are natively using argumentative techniques such as AA-CBR [60] and DeLP [61]. The second group (i.e., post-hoc) extracts argumentative explanations from non-argumentative models such as neural networks [26] and Bayesian networks [62]. Following [23], some post-hoc approaches create a complete mapping between the target model and the argumentation framework from which explanations are derived such as [37,63], while other posthoc methods create an incomplete mapping between the model and the argumentation framework (so called approximate approaches) such as [26,62]. However, AXPLR is a post-hoc approach (due to the non-argumentative PLR model) that does not fit nicely into this complete-approximate dichotomy. On one hand, AXPLR constructs a complete mapping between the PLR model and the QBAFc since every activated feature in the model (as well as the bias term) has a corresponding argument in the QBAFc. On the other hand, the logistic regression semantics σ of AXPLR approximates the dialectical strength of every argument given that this strength does not actually exist in the PLR model. The approximation of σ is under an assumption that the strength of an argument is distributed equally and accordingly to every argument it attacks or supports, as represented by the fragments in Equation 3. So, we could say that AXPLR is a complete but intentionally approximate post-hoc approach so as to yield plausible explanations.
Argument Mining. Our work stays at the intersection of explainable AI, natural language processing, and computational argumentation. Another research area that is similar to ours is argument mining, which involves natural language processing and computational argumentation. Argument mining is the process of automatically detecting and modeling the structure of inference and reasoning given in natural language texts [64]. However, our work is not considered an argument mining work because the arguments in our QBAFc are arguing about the predicted output of a text classifier (PLR), whereas arguments in general argument mining works are arguing about a specific claim or conclusion in text. Therefore, input texts in argument mining works must possess the argumentative spirit inside, while input texts for AXPLR do not need to be argumentative but the classifier instead turns parts of them to be arguments for making classifications.

Conclusion
To generate local explanations for pattern-based logistic regression models, we proposed AXPLR, an explanation method enabled by quantitative bipolar argumentation frameworks we defined (TQBAFc and BQBAFc), capturing interactions among the patterns. We proved that the extracted and postprocessed frameworks underpinning AXPLR are faithful to the LR model and satisfy many desirable properties. After that, we proposed two presentations of AXPLR, shallow and deep, specifying whether we present only the top-level arguments or all the arguments in the explanations. We also conducted a number of experiments with AXPLR, amounting to empirical as well as human studies. The former discussed the statistics of the underlying argumentation frameworks for all input texts in the test sets and analyzed sufficiency of the explanations in terms of the number of supporting arguments needed. The latter assessed whether AXPLR is more plausible and helpful for human learning than traditional explanation methods for pattern-based LR models. The results show that taking into account relations between arguments as AXPLR does indeed helps the explanations align better with human judgement, particularly in the sentiment analysis task. Though AXPLR performed competitively with traditional explanation methods in tutoring and supporting humans to detect deceptive hotel reviews, there were many participants learning from AXPLR that could recall well-generalized patterns and important but implicit patterns deemed useful for the task.
from the views and opinions expressed by J.P. Morgan or its affiliates. This material is not a product of the Research Department of J.P. Morgan Securities LLC. This material should not be construed as an individual recommendation for any particular client and is not intended as a recommendation of particular securities, financial instruments or strategies for a particular client. This material does not constitute a solicitation or offer in any jurisdiction.
We will prove the result by contradiction. Assume that the graph G is not a DAG. Hence, there must be a non-trivial path which forms a cycle in G. Assume that the path is α i 0 , α i 1 , . . . , α i k , α i 0 with k 1. In this path, there must not be δ since the out-degree of δ is 0 (from Lemma 2). So, every edge in this path must be in the second set of the union above. Hence, we obtain that p i 0 p i 1 , p i 1 p i 2 , . . . , p i k p i 0 . Because is transitive (from Lemma 1), p i 0 p i 0 , but this is impossible since is not reflexive (also from Lemma 1). Here is the contradiction. Thus, the graph structure of the TQBAFc is a DAG.
The proof for BQBAFc is similar to the proof for TQBAFc. We will obtain that Assume the directed cyclic path in G is α i 0 , α i 1 , . . . , α i k , α i 0 with k 1. Hence, p i 0 p i k (from the last edge in the path), p i k p i k−1 (from the second last edge), . . . , p i 1 p i 0 (from the first edge). Because is transitive, p i 0 p i 0 , but this is impossible since is not reflexive. Here is the contradiction. Thus, the graph structure of any BQBAFc is also a DAG.

A.3. Proof of Theorem 2
Theorem 2. For a given QBAFc, the prediction of the underlying LR model can be inferred from the strength of the default argument: (1) The predicted probability for the class c(δ) equals sigmoid(σ(δ)).
Proof. First, we will prove that the predicted probability for the class c(δ) equals sigmoid(σ(δ)). In other words, we need to prove that, for c(δ) = 1, sigmoid(σ(δ)) = sigmoid( Case 1: c(δ) = 1 -The class supported by δ is Positive. Each argument α i ∈ A − {δ} supports class c(α i ) ∈ {0, 1}. We partition A − {δ} into two sets -one with Positive (1) as the supported class and the other with Negative (0) as the supported class. We use A + and A − to represent the two sets, respectively.
Applying Definition 3 to δ, we obtain Because c(δ) = 1, we know from Definition 2 that the bias term of the underlying LR model is b 0.
Next, for α i in A + , we know that c(α i ) = 1, so the corresponding weight in the LR model is For α j ∈ A − , in contrast, we know that c(α j ) = 0, so the corresponding weight in the LR model is w j < 0. Hence, τ(α j ) = |w j | = −w j . By Definition 2, all the supporters must support the same class whereas all the attackers must support the opposite class. So, R + (α j ) ⊆ A − and R − (α j ) ⊆ A + . By Definition 3, By Definition 2, summing up Equations 5, 6 (for all α i ∈ A + ), and 7 (for all α i ∈ A − ), we obtain that Next, we will show that α i ∈A + σ(α i ) and the blue part above are equal. As α i ∈ A + , it can appear as g only in the blue part. In other words, α i can either support another argument in A + or δ or attack another argument in A − . If α i supports or attacks ν(α i ) arguments in total (where ν(α i ) is the out-degree of α i ), we will find exactly ν(α i ) terms of σ(α i ) ν(α i ) in the blue part, and they sum up to σ(α i ). Hence, for every σ(α i ) in α i ∈A + σ(α i ), we can find the equivalent amount in the blue part. Meanwhile, g in the blue part must come from A + only (not δ or A − according to Definition 2). Thereby, Similarly, α j ∈ A − can either support another argument in A − or attack another argument in A + or δ. With the same logic as for the blue part, we obtain that However, Equations 6 and 7 remain the same. By summing up Equations 8, 6 (for all α i ∈ A + ), and 7 (for all α i ∈ A − ), we obtain that Because α i ∈ A + can either support another argument in A + or attack another argument in A − or δ, with the same logic as in the previous case, we obtain that What remains is Finally, the second point of the theorem is pretty obvious. Using the result from the first point, the predicted probability of class c(δ) equals sigmoid(σ(δ)) which is greater than 0.5 if σ(δ) > 0. So, it predicts c(δ). Otherwise, sigmoid(σ(δ)) < 0.5, and it predicts the other class which is 1 − c(δ).

A.4. Proof of Theorem 3
Theorem 3. Given a QBAFc A, R − , R + , τ, c and the corresponding QBAFc A , R − , R + , τ , c , using the logistic regression semantics, we use σ(a) and σ(a) to represent the strengths of a ∈ A = A in QBAFc and QBAFc , respectively. The following statements are true for a ∈ A = A .
Proof. According to Theorem 1, G = V, E for the QBAFc is a DAG where V = A and E = R − ∪R + . Let G = V , E be the graph structure of QBAFc where V = A and E = R − ∪R + . By Definition 4, we know that V = A = A = V and E = R − ∪ R + ⊆ R − ∪ R + = E. Hence, G is a subgraph of G and also a DAG 8 .
Then we can obtain the topological ordering t of arguments in V which is the ordering of strength computation for QBAFc . Assume that the order t is a 1 , a 2 , . . . , a k . Obviously, a 1 must be an argument in V that has no attack or support. Furthermore, we can divide the vertices in t into two groups (corresponding to the two bullet points of this theorem), one with σ(a i ) 0 and the other with σ(a i ) < 0. We name arguments in the former group and the latter group as g 1 , . . . , g r and l 1 , . . . , l s , respectively, where g i must be before g i+1 in t, l i must be before l i+1 in t, and r + s = k. So, t could be written as, for example, g 1 , g 2 , l 1 , g 3 , l 2 , l 3 , . . . , g r , l s−1 , l s . In any case, g 1 must be a 1 since a 1 has neither attacker nor supporter and, therefore, σ(a 1 ) = τ(a 1 ) 0. In general, the first part of t must be g 1 , . . . , g r * , l 1 , . . . where 1 r * r, and arguments after l 1 could be from either g or l. We will use mathematical induction on this topological ordering t to prove the two bullet points of this theorem.
According to the ordering t, all the original attackers and supporters of l 1 must be in {g h |1 h r * }. As a result, for a ∈ R − (l 1 ) ∪ R + (l 1 ), τ (a) = τ(a), c (a) = c(a), and σ(a) = σ(a) (as proven above). In contrast, since σ(l 1 ) < 0, by Definition 4, τ (l 1 ) = −τ(l 1 ) and c (l 1 ) = 1−c(l 1 ). In other words, the base score and the supported class of l 1 are flipped after post-processing. Because the classes of the attackers and supporters are not change whereas the class of l 1 is flipped, R − (l 1 ) = R + (l 1 ) and R + (l 1 ) = R − (l 1 ). Applying Definition 3 to l 1 in QBAFc , we obtain Hence, σ(l 1 ) = −σ(l 1 ) as required. • For any argument a i in t after l 1 (using strong induction): So far, we have shown that this theorem is true for g 1 , . . . , g r * and l 1 . Next, assuming that the theorem is true for any argument a 1 , . . . , a i , we need to show that the theorem is also true for a i+1 regardless of the group it belongs to. If a i+1 belongs to the g group (i.e., σ(a i+1 ) 0), we obtain that τ (a i+1 ) = τ(a i+1 ) and c (a i+1 ) = c(a i+1 ). The supported class of a i+1 is not flipped after post-processing. The original attackers of a i+1 could belong to either the g group or the l group. We use R − g (a i+1 ) and R − l (a i+1 ) to represent those sets of original attackers, respectively. After post-processing, the attackers in R − g (a i+1 ) will still be attackers (due to the unchanged supported classes on both sides of the relations) whereas the ones in R − l (a i+1 ) will become supporters (due to the supported class flipped only on one side). Similarly, the original supporters of a i+1 could be split into R + g (a i+1 ) and R + l (a i+1 ). After post-processing, those in R + g (a i+1 ) will still be supporters while those in R + l (a i+1 ) will become attackers. To sum up, R + (a i+1 ) is the union of two disjoint sets -R + g (a i+1 ) and R − l (a i+1 ). Meanwhile, R − (a i+1 ) is the union of two disjoint sets -R − g (a i+1 ) and R + l (a i+1 ). Applying Definition 3 to a i+1 in QBAFc , we obtain Hence, for a i+1 where σ(a i+1 ) 0, σ(a i+1 ) = σ(a i+1 ) as the theorem stated. Analogously, if a i+1 belongs to the l group (i.e., σ(a i+1 ) < 0), we obtain that τ (a i+1 ) = −τ(a i+1 ) and c (a i+1 ) = 1 − c(a i+1 ). After post-processing, the supported class of a i+1 is flipped. Also, the attackers in R − g (a i+1 ) will become supporters (due to the supported class flipped only on one side of the relations at a i+1 ) whereas the ones in R − l (a i+1 ) will still be attackers (due to the supported class flipped on both sides). Similarly, the supporters in R + g (a i+1 ) will become attackers, while those in R + l (a i+1 ) will still be supporters. To sum up, R + (a i+1 ) is the union of two disjoint sets - is the union of two disjoint sets -R − l (a i+1 ) and R + g (a i+1 ). Applying Definition 3 to a i+1 in QBAFc , we obtain Hence, for a i+1 where σ(a i+1 ) < 0, σ(a i+1 ) = −σ(a i+1 ) as the theorem stated. From both cases, the induction step is completed.
Our proof has covered all the arguments in the topological ordering t. Thus, the theorem is true for a ∈ A = A .
Note again that the definition of < between two sets used in GP10 and GP11 is defined as follows. Given P and Q are subsets of A, P Q if and only if there exists an injective mapping f from P to Q such that ∀α ∈ P, σ(α) σ( f (α)). Furthermore, P < Q if and only if P Q but Q P.  Figure 14, used as a counterexample in Appendix A.5. With each argument, there is a value pair (x, y) where x and y represent the base score and the strength (based on the logistic regression semantics σ) of the argument, respectively. The color represents the argument's supported class (i.e., green for positive (1) and red for negative (0)).

Appendix B. Machine Learning Terminology
This section explains meanings of technical terms concerning machine learning and classification that are used in this paper.
Dataset Splits. Working on a classification task, we usually divide a dataset we have into three splits. The first split is a training set, which is used to train our classification model. The second split is a test set, which is used to evaluate the final trained model. The third split is a development set (also called a validation set), which is used to evaluate model(s) under development so as to choose the best model architecture or hyperparameters. To ensure that the model can generalize beyond what it sees during training and development, all the three data splits must be mutually exclusive.
Because logistic regression (LR) does not have any hyperparameters or multiple architectures to choose, we did not use the development set while training the LR models in our experiments (Sections 7-10). However, in Section 10, we used the development set of the deceptive hotel review dataset for two purposes -(i) to tune the regularization hyperparameter of the support vector machine (SVM) model and (ii) to generate explanations for tutoring human participants to detect deceptive reviews.
Evaluation Metrics. For binary classification, let y andŷ be the true class and the predicted class of an example x, respectively. Hence, both y andŷ could be either 0 or 1, resulting in four possible situations.
• True Negative (TN): The model correctly predicts that the class of x is 0 (i.e., y =ŷ = 0). • False Positive (FP): The model predicts that the class of x is 1 (i.e.,ŷ = 1), but the true class of x is in fact 0 (i.e., y = 0). • False Negative (TN): The model predicts that the class of x is 0 (i.e.,ŷ = 0), but the true class of x is in fact 1 (i.e., y = 1).
By default, we consider class 1 to be the positive class and consider class 0 to be the negative class. However, we can also consider the four situations above with respect to a specific class c. Particularly, T P c (true positives) and To evaluate the performance of a classifier, we apply it to predict examples in a labeled test dataset D and report the percentage of correct predictions, so called the accuracy or classification rate.

Accuracy =
|{(x i , y i ) ∈ D |ŷ i = y i }| |D | = T P + T N T P + T N + FP + FN However, if the test dataset is class imbalanced, i.e., having examples of one class more than the other, accuracy may not be the best evaluation metric because a model can get a high accuracy only by always answering the majority class. Alternatively, we can report the model performance for each specific class c ∈ {0, 1} using the class precision, recall, and F1, defined as follows [17, chapter 4].
Precision c = P c = T P c T P c + FP c = |{(x i , y i ) ∈ D |ŷ i = y i = c}| |{(x i , y i ) ∈ D |ŷ i = c}| Recall c = R c = T P c T P c + FN c = |{(x i , y i ) ∈ D |ŷ i = y i = c}| |{(x i , y i ) ∈ D |y i = c}| (11) F1 c = 2P c R c P c + R c (12) There are two ways to aggregate the class-specific metrics to be the metrics for the overall performance. First, micro-averaging combines the T P, FP, and FN of all classes (in C) before computing precision and recall.

Micro Precision
Normally, when we work with datasets that are class imbalanced, we want the model to work well for all the classes, not just for the majority class. Therefore, we often use macro F1 as the main evaluation metric in addition to the classification accuracy.