Abductive Commonsense Reasoning Exploiting Mutually Exclusive Explanations (2023)

Abstract: Abductive reasoning aims to find plausible explanations for an event. This style of reasoning is critical for commonsense tasks where there are often multiple plausible explanations. Existing approaches for abductive reasoning in natural language processing (NLP) often rely on manually generated annotations for supervision; however, such annotations can be subjective and biased. Instead of using direct supervision, this work proposes an approach for abductive commonsense reasoning that exploits the fact that only a subset of explanations is correct for a given context. The method uses posterior regularization to enforce a mutual exclusion constraint, encouraging the model to learn the distinction between fluent explanations and plausible ones. We evaluate our approach on a diverse set of abductive reasoning datasets; experimental results show that our approach outperforms or is comparable to directly applying pretrained language models in a zero-shot manner and other knowledge-augmented zero-shot methods.

## introduction abductive reasoning aims to find plausible explanations for an event @xcite . unlike deduction, which draws a firm conclusion from a set of premises, abduction requires reasoning from an outcome to plausible explanations. fig. 1 (top) demonstrates the distinction: given only the context x, both the blue and the red sentences describe possible subsequent events; however, upon seeing the outcome y only one of the two is a plausible explanation (although there may be others). humans apply abduction in everyday situations @xcite such as reading-between-the-lines (charniak and @xcite and analyzing causes and effects @xcite . learning to perform abduction is thus an important step towards building humanlike machines with commonsense knowledge. her flight was delayed. her flight left on time. tuned lipor lm p( explanation | x, y ) ? zero-shot figure 1 : top: an abductive reasoning example consisting of a context x, an outcome y, and two candidate explanations. the goal is to identify the plausible explanation given x and y. to predict an explanation, one can apply a pretrained language model (shown as lm) to score y given x and an explanation, and then compute the posterior probability for the explanation. bottom: using a lm without fine-tuning (zero-shot) leads to poor performance, whereas a lm fine-tuned via max-marginal likelihood (tuned) fails to distinguish the two explanations. lipor is trained to partition the explanations in a mutually exclusive manner. abductive reasoning has been extensively studied in the setting where annotations are available @xcite . however, because determining whether an explanation is plausible is a subjective and noisy process, annotating plausibility of explanations can be problematic for commonsense reasoning problems. @xcite show that, in a dataset verification step where five annotators are asked to determine whether a handwritten explanation is plausible, they disagree with each other on 62.34% of 1365 explanations. this subjectivity thus introduces annotator-specific bias as has been seen in related tasks @xcite . the potential bias in plausibility annotation motivates the study of learning to perform abductive reasoning without plausibility annotations. thus, we consider the setting where the context x and outcome y are observed, and models must learn to identify plausible explanations out of a given set of candidate explanations, without direct supervision over plausibility. rule-based methods use formal logic to reason about explanations @xcite ; however, their limited coverage prevents them from scaling to the full complexity of natural language. recently, pretrained language models, which have achieved remarkable performance on a range of nlp tasks @xcite , hold the potential for zero-shot abductive reasoning. specifically, @xcite directly estimate the probability of an explanation for an outcome through bayes' rule (zero-shot in fig. 1 ). in practice, however, this direct approach can often lead to performance that is only slightly better than random guessing @xcite . to avoid these issues, we reduce abductive reasoning down to a single constraint -an explanation must be plausible or implausible. this restriction, argued by @xcite , enforces that explanations are mutually exclusive; that is, one explanation being plausible automatically rules out some other explanations. we introduce likelihood learning with posterior regularization (lipor), an approach to perform abductive reasoning that only leverages mutual exclusivity of explanations and does not rely on plausibility annotations. specifically, we maximize the marginal likelihood of the outcome given the context and a set of explanations (tuned in fig 1 ), then use posterior regularization to enforce mutual exclusion between plausible and implausible explanations (lipor in fig 1 ). we show how to impose this relation with a simple distributional constraint on the posterior of the model. we empirically evaluate lipor on a diverse set of abductive reasoning datasets. specifically, we consider four datasets under the abductive reasoning framework: αnli @xcite , sen-making @xcite , δ-nli @xcite , and winowhy @xcite . results show that lipor consistently outperforms pretrained language models directly applied in a zero-shot manner and is comparable to different variants of a state-of-the-art knowledge-augmented zero-shot method @xcite . as humanwritten explanation candidates are not always available during fine-tuning, we further evaluate li-por on the explanation candidates generated via prompting @xcite . we show that, even though automatically generated explanations are noisy, lipor can still leverage them and outperform strong zero-shot models including gpt3. the second group leverages external knowledge bases (kbs). @xcite leverage comet @xcite , a dynamic knowledge graph, to generate a chain of commonsense inferences based on contexts of qa examples, which can be treated as explanations. @xcite ; @xcite pretrain language models on artificial question answering (qa) datasets, created from knowledge graphs; a system trained on such datasets can directly perform zero-shot qa. @xcite formulate multiple-choice qa as natural language inference (nli) and leverage both existing nli datasets and kbs to identify answer choices in a zero-shot manner. relation to deductive reasoning. both abduction and deduction have intermediate explanations. abductive reasoning infers the most likely explanation from outcomes. in contrast, deductive reasoning infers a conclusion given a complete set of premises. however, outcomes are often not a direct result of premises but come from a chain of reasoning over intermediate explanations. identifying and providing the correct chain of reasoning is crucial to building trustworthy systems. within the realm of deduction there are several different approaches that utilize neural models. @xcite develop a pipeline to automatically construct training examples from wikipedia, so that a system trained on such data is able to generate deductive inferences from natural language inputs without direct human supervision. @xcite present a neuro-symbolic theorem prover that extracts intermediate reasoning steps for understanding conversations. rajani et al. (2019); tafjord et al. (2021); nye et al. (2022); wei et al. (2022b) explanations as latent variables. modeling intermediate explanations as latent variables is a common approach, although training and inference details differ. here we consider representative works in nlp. @xcite apply a latent variable model to language understanding and train the model with variational expectation maximization. their method can generate free-form explanations but requires a small set of labeled examples for supervision. @xcite apply such a model to probe dialogue generation in a zero-shot manner. @xcite apply a latent variable model to analyze gender bias in large pretrained language models by viewing the behaviors of neurons as unobserved explanations. @xcite ; @xcite apply such a model to identify rationales for sequence classification/generation, where rationales are a minimal subset of inputs or previous words that can lead to the same predictions. li-por is a training scheme developed for learning such latent-variable models for abductive reasoning, which has a unique challenge of identifying multiple plausible explanations. ## abductive reasoning we consider four datasets that test abductive reasoning skills. while abduction can be difficult to pinpoint, we select datasets that obey the following criteria: there is a need for differentiating plausible explanations from implausible explanations, there is an observed outcome, and the outcome depends on intermediate explanations. based on these criteria, we use αnli @xcite , sen-making @xcite , δ-nli @xcite x: it was a very hot summer day z: {he decided to run in the heat, he drank a glass of ice cold water} y: he felt much better sen-making z: {a restaurant does not have doctors or medical treatment, a restaurant is usually too noisy for a patient, there are different types of restaurants in the city} y: it is not true that he was sent to a restaurant for treatment δ-nli to convert each to the abduction format, we first identify a context x, which sets a scope for candidate explanations z, as well as an outcome y. the outcome could either be an event caused by z or a conclusion reached by z. importantly, we differentiate explanation candidates z as ones that are consistent with x, from plausible explanations that are consistent with both x and y. a central assumption is that training abductive reasoning systems with the candidate set introduces less noise and subjectivity than directly supervising the systems with plausibility annotations. example conversions of each dataset are shown in notably these datasets differ in the number of plausible explanations, which we denote by a value @xmath0. in αnli and sen-making, m is fixed to 1 for all examples. however, in δ-nli and winowhy, m is variable, and we assume that half of explanations are plausible. however these explanations are discrete; an explanation is either plausible or implausible. a successful unsupervised system should assign high probabilities to plausible explanations and low probabilities to implausible explanations. this discreteness is encoded into some of the tasks directly. for example, @xcite ; @xcite instruct the annotators to make minimal possible changes to plausible explanations to produce implausible explanations, so that a system would fail if it predicts explanations based on superficial lexical features. ## lipor we now describe lipor, a method to adapt pretrained language models to incorporate mutual exclusivity between explanations. as we have seen, an abductive reasoning example consists of a context x, an observed outcome y, and an unobserved explanation @xmath1, which, together with x, has led to y. importantly, the candidate set of explanations z is given during training but the plausibility of each explanation is not. 1 the goal of abductive reasoning is to produce a distribution over explanations z, defined by p(z|x, y). we are interested in modeling the joint distribution p(y, z|x), which is factored as follows: given eq 1, the posterior distribution can be obtained via the bayes' rule, p(z|x, y) = p(y|z, x)p(z|x) p(y|x) . ## experimental setup metrics. accuracy is used to evaluate a system's predictive power. for datasets with @xmath2, accuracy is computed with regards to each example (i.e., whether the plausible explanation has been identified for each example). otherwise, to stay consistent with evaluation in prior works, we compute accuracy with regards to each explanation (i.e., whether the plausibility of each explanation is correctly predicted). therefore, more weight will be given to the instances that have larger |z| (within a single dataset, the variance of |z| for different examples is very small). baselines. we consider three groups of baselines: ma et al. (2021) for αnli, wang et al. (2020) for sen-making, rudinger et al. (2020) for δ-nli, and zhang et al. (2020) for winowhy. for (3), we run different variants of knowledge-driven data construction (abbreviated as kddc) @xcite , a method that leverages external knolwedge but not plausibility annotations. we note that kddc is designed to predict a single correct answer with argmax. to handle the datasets that have more than one correct answers, we modify kddc to choose the answers that have scores higher than the median. we also include knowledge-enabled natural language inference @xcite that is first supervised on qnli @xcite and then incorporate atomic at inference time for winowhy (abbreviated as qnli-atomic). for models that use both external knowledge and plausibility annotations, we take rainbow @xcite for αnli, ecnu-sensemaker @xcite for sen-making, and roberta-grande @xcite for winowhy. prompt for plausible explanations: provide a brief explanation for why it is not sensible that y prompt for implausible explanations: provide a brief explanation for why y y: he poured orange juice on his cereal. in: provide a brief explanation for why it is not sensible that he poured orange juice on his cereal. out: it is not sensible because orange juice does not go well with cereal. in: provide a brief explanation for why he poured orange juice on his cereal out: he wanted to eat a healthy breakfast. implementation & hyperparameters. we choose a bart-large model @xcite to be θ. we train the model with the hugging face transformers framework @xcite . we perform grid search with learning rates {1e-6, 3e-6, 5e-6, 1e-5}, batch sizes {2,4,8,16}, and λ {1e-2,1e-1,1,10}. we train 50 epochs for winowhy and 10 epochs for all other datasets. we perform evaluation on dev sets every 500 steps. we choose the checkpoint whose posterior distributions have the lowest average entropy on dev sets to run tests if the entropy starts to diverge during training. if the entropy converges, we choose the checkpoint at the end of training. because there are not train/dev/test sets for winowhy, to perform a direct comparison with other methods, we do not split the dataset ourselves and simply train models on all of the data and choose the checkpoint based on loss values. automatic candidate generation lipor assumes access to a candidate explanation set z during training with human-written explanations. however, we may also want to use the model in domains without a candidate set. we consider a variant that uses a noisy automatic candidate generation process. in this setting, set z will contain a set of explanations with no guarantee that any are plausible. to generate z we utilize language model prompting with gpt3 (text-davinci-002) @xcite . using prompt templates inspired by the instructions given to human annotators, we have the model generate explanations. we show example prompts for the sen-making dataset in fig. 4 . for datasets with fewer than 1000 unique contexts x (i.e., δ-nli and winowhy), we generate one plausible explanation and one implausible explanation for every x. for the other datasets, we randomly sample 1000 unique contexts and otherwise stay the same. we release the prompts as well as the generated explanations for every dataset in the supplementary materials. in this setting, lipor uses a lower pr penalty λ = 0.1. we additionally consider two more baselines. first, we score the most plausible explanation with the prompt as a prefix (denoted as prompted gpt3). secondly, we supervise roberta-large with the generated explanations. ## results we summarize the results in in fine-tuning with generated explanations ## analysis preserving plausible candidates models trained to prefer single plausible explanations can become overconfident in their predictions. a major benefit of lipor is that it considers multiple plausible candidates. while lipor is fine-tuned to favor mutual exclusivity, we find that at test time it remains able to score multiple plausible explanations highly. qualitative comparison mike was normally a good student. 100 50.0 z: everyone in class failed the test except for mike. 0 50.0 y: the teacher was very disappointed. ? lipor assigns close probabilities to the indistinguishably likely explanations, while the supervised model collapses to one of the explanations. the two examples on the bottom are those for which tuned bart fails to identify the plausible explanation because one explanation is short and the other is long. again, lipor is able to correct these mistakes. furthermore, the probability produced by lipor for each explanation also reflects the model's confidence to a certain degree. in the first example, "we met a golden retriever puppy and he played with us" is a much better explanation than "we were rained on," because one does not need to go to a park to experience rain. as a result, the difference between probabilities for the two explanations is 92.2%. for the second example, "we had an amazing time" could refer to example -pr +pr x: i love taking long warm showers. showers make me sleepy. 50.3 6.0 z: doing what you love is important. neil booked a tripped online. 47.5 64.0 z: neil took a trip to see the rocky mountains instead. 52.5 36.0 y: neil loved being so close to the mountains in nepal! fine-tuning (-pr) looks at superficial word cooccurrences, but lipor (+pr) tries to understand the true context. example -pr +pr x: we went to the park today. we were rained on! 53.5 3.9 z: we met a golden retriever puppy and he played with us. my best friend wanted to go on a trip. 50.5 40.9 z: my best friend wanted to try a new restaurant for lunch. ## conclusion we introduce lipor, which fine-tunes pretrained language models on abductive reasoning tasks without plausibility annotations. results shows that li-por achieves comparable performance to that of knowledge-augmented zero-shot methods.