# Rationale-Inspired Faithful Natural Language Explanations with Commonsense

Bodhisattwa Prasad Majumder Department of Computer Science and Engineering, UC
San Diego
{bmajumde<EMAIL_ADDRESS>Oana-Maria Camburu Department of Computer
Science, University of Oxford
{oana-maria.camburu<EMAIL_ADDRESS>Thomas Lukasiewicz
Department of Computer Science, University of Oxford
{oana-maria.camburu<EMAIL_ADDRESS>Julian McAuley
Department of Computer Science and Engineering, UC San Diego
{bmajumde<EMAIL_ADDRESS>
# Faithful and Socially-aligned Natural Language Explanations
with Rationales and Commonsense

Bodhisattwa Prasad Majumder Department of Computer Science and Engineering, UC
San Diego
{bmajumde<EMAIL_ADDRESS>Oana-Maria Camburu Department of Computer
Science, University of Oxford
{oana-maria.camburu<EMAIL_ADDRESS>Thomas Lukasiewicz
Department of Computer Science, University of Oxford
{oana-maria.camburu<EMAIL_ADDRESS>Julian McAuley
Department of Computer Science and Engineering, UC San Diego
{bmajumde<EMAIL_ADDRESS>
# Natural Language Explanations
with Extractive Rationales and Commonsense

Bodhisattwa Prasad Majumder Department of Computer Science and Engineering, UC
San Diego
{bmajumde<EMAIL_ADDRESS>Oana-Maria Camburu Department of Computer
Science, University of Oxford
{oana-maria.camburu<EMAIL_ADDRESS>Thomas Lukasiewicz
Department of Computer Science, University of Oxford
{oana-maria.camburu<EMAIL_ADDRESS>Julian McAuley
Department of Computer Science and Engineering, UC San Diego
{bmajumde<EMAIL_ADDRESS>
# Rationale-Inspired Natural Language Explanations
with Commonsense

Bodhisattwa Prasad Majumder Department of Computer Science and Engineering, UC
San Diego
{bmajumde<EMAIL_ADDRESS>Oana-Maria Camburu Department of Computer
Science, University of Oxford
{oana-maria.camburu<EMAIL_ADDRESS>Thomas Lukasiewicz
Department of Computer Science, University of Oxford
{oana-maria.camburu<EMAIL_ADDRESS>Julian McAuley
Department of Computer Science and Engineering, UC San Diego
{bmajumde<EMAIL_ADDRESS>
# Commonsense-grounded Self-rationalization

Bodhisattwa Prasad Majumder Department of Computer Science and Engineering, UC
San Diego
{bmajumde<EMAIL_ADDRESS>Oana-Maria Camburu Department of Computer
Science, University of Oxford
{oana-maria.camburu<EMAIL_ADDRESS>Thomas Lukasiewicz
Department of Computer Science, University of Oxford
{oana-maria.camburu<EMAIL_ADDRESS>Julian McAuley
Department of Computer Science and Engineering, UC San Diego
{bmajumde<EMAIL_ADDRESS>
# Self-Rationalization with Commonsense Grounding

Bodhisattwa Prasad Majumder Department of Computer Science and Engineering, UC
San Diego
{bmajumde<EMAIL_ADDRESS>Oana-Maria Camburu Department of Computer
Science, University of Oxford
{oana-maria.camburu<EMAIL_ADDRESS>Thomas Lukasiewicz
Department of Computer Science, University of Oxford
{oana-maria.camburu<EMAIL_ADDRESS>Julian McAuley
Department of Computer Science and Engineering, UC San Diego
{bmajumde<EMAIL_ADDRESS>
# Commonsense Grounding in Self-Rationalization
with Extractive and Natural Language Explanations

Bodhisattwa Prasad Majumder Department of Computer Science and Engineering, UC
San Diego
{bmajumde<EMAIL_ADDRESS>Oana-Maria Camburu Department of Computer
Science, University of Oxford
{oana-maria.camburu<EMAIL_ADDRESS>Thomas Lukasiewicz
Department of Computer Science, University of Oxford
{oana-maria.camburu<EMAIL_ADDRESS>Julian McAuley
Department of Computer Science and Engineering, UC San Diego
{bmajumde<EMAIL_ADDRESS>
# Rationale-Inspired Natural Language Explanations with Commonsense

Bodhisattwa Prasad Majumder Department of Computer Science and Engineering, UC
San Diego
{bmajumde<EMAIL_ADDRESS>Oana-Maria Camburu Department of Computer
Science, University of Oxford
{oana-maria.camburu<EMAIL_ADDRESS>Thomas Lukasiewicz
Department of Computer Science, University of Oxford
{oana-maria.camburu<EMAIL_ADDRESS>Julian McAuley
Department of Computer Science and Engineering, UC San Diego
{bmajumde<EMAIL_ADDRESS>
###### Abstract

Extractive rationales (i.e., subsets of input features) and natural language
explanations (NLEs) are two predominant types of explanations for machine
learning models. While NLEs can be more comprehensive than extractive
rationales, machine-generated NLEs have been shown to fall short in terms of
commonsense knowledge. In this paper, we show that commonsense knowledge can
act as a bridge between extractive rationales and NLEs, rendering both types
of explanations better. We introduce a self-rationalizing framework, called
RExC, that (1) extracts rationales as most responsible features for the
predictions, (2) expands the extractive rationales using commonsense
resources, and (3) selects the best-suited commonsense knowledge to generate
NLEs and give the final prediction. Our framework surpasses by a large margin
the previous state-of-the-art in generating NLEs across five tasks in both
natural language and vision-language understanding. Self-rationalization with
commonsense also strongly improves the quality of the extractive rationale and
task performances over the previous best performing models that also produce
explanations.111Code will be publicly released upon acceptance.

##  1 Introduction

Two of the currently predominant approaches in explainable machine learning
are (i) identifying a meaningful subset of inputs, known as _extractive
rationales_ Zaidan and Eisner (2008); Bastings et al. (2019); Sha et al.
(2021), and (ii) generating natural language explanations (_NLEs_) Park et al.
(2018); Hendricks et al. (2016); Camburu et al. (2018); Narang et al. (2020).
Extractive rationales have the advantage of being concise and provide a quick
explanation which, in some cases, are enough for users to trust the model.
However, in other cases, extractive rationales may not paint the full picture
or may be hard to comprehend even by experts Kaur et al. (2020); Camburu et
al. (2021); Alufaisan et al. (2021); Wiegreffe et al. (2020). In such cases,
NLEs can be complementary, as they allow for a more detailed justification in
a form that is most accessible to humans (natural language). However, machine-
generated NLEs, like other generated text, are prone to lacking commonsense
Camburu et al. (2020); Mao et al. (2019). This could be either because some
NLEs do not accurately explain the model or the model did not use commonsense
knowledge for its decision-making.

Figure 1: Illustrative examples of RExC on (a) natural language and (b)
vision-language tasks.

To ground both decision-making and rationalization in commonsense, as well as
to reap the benefits of both extractive rationales and NLEs, we combine them
in a unified framework, illustrated in Fig. 1. For example, in Fig. 1b, a
subset of super-pixels of an input image form the extractive rationales behind
the prediction in a question-answering task (Commonsense Question Answering
Talmor et al. (2019)). To synthesize the NLE, a semantic understanding of the
subject’s stance (e.g., person2 has a weapon to protect) is helpful. To
achieve this, our framework incorporates commonsense resources, which are
queried with the model-extracted rationales to fetch commonsense information
about the rationales. The framework then self-selects a subset of informative
knowledge snippets to guide the final answers and the NLEs.

Our unified framework, which we call RExC: (Extractive) Rationales, (Natural
Language) Explanations, and Commonsense, significantly improves the quality of
both extractive rationales and NLEs and bridges the gap between task
performance and explainability. RExC does not require direct supervision on
the rationale extraction nor on the selection of the pieces of commonsense
knowledge. We model these selections by a series of binary latent variables
and use variational learning to sample the rationales and the informative
pieces of commonsense knowledge (Section 2). The supervision comes from the
task labels and NLEs. The knowledge selection step provides positive
regularizing effects on task performance, NLE generation, as well as rationale
extraction. We also show that self-provided explanations from RExC exhibit
faithfulness being strongly associated with the predicted labels (Section 5).
The contributions of this work are summarized as follows:

  * •

We propose a self-rationalizing framework that incorporates commonsense
resources and provides two complementary types of machine explanations:
extractive rationales and NLEs. Furthermore, RExC allows selection of relevant
commonsense even without supervision from NLEs, a setup which could be used as
explanations in zero-shot settings (RExC-ZS).

  * •

We achieve state-of-the-art (SOTA) performance in NLE generation across five
tasks, spanning both natural language (NL) and vision-language (VL) domains.
Furthermore, extractive rationales from RExC are of _better_ quality compared
to the ones from previous SOTA models with (only) extractive rationales.

  * •

For predictive tasks, we consistently outperform the best performing models
that produce at least one of extractive rationales or NLEs. We also perform
similarly (and sometimes better) with the SOTA models that do not provide any
explanations, bridging the gap between explainability and task performance.

  * •

We ensure that RExC passes necessary faithfulness tests Wiegreffe et al.
(2020); DeYoung et al. (2020) by observing a high degree of association
between outputs and both types of explanations.

##  2 RExC: Self-Rationalization with Commonsense Grounding

We aim to solve a predictive task given an input and bring explanations for
the prediction via both extractive rationales and NLEs. More precisely, our
model RExC self-extracts the rationale from the input, uses them to query an
incorporated knowledge module, selects the most relevant pieces of knowledge
that help the final prediction and the NLE generation. We use Fig. 1a as a
running example (on an NL task) in this section, while details for both NL and
VL tasks are in Section 3.2.

Figure 2: Architecture of RExC. The commonsense knowledge module is frozen,
while the rest of the modules are trained jointly with the signals from the
NLEs and outputs. Deliverables from RExC are in blue.

###  2.1 Extractive Rationales via Binary Latent Variables

First, we define a neural module $\mathcal{R}$ extracting the rationale from
the input. An extractive rationale is a sufficient and minimal subset of input
units (e.g., tokens for language or super-pixels for images) that is a
significant indicator of a model’s prediction Lei et al. (2016). In Fig. 1a,
we see an example from the natural language inference task Bowman et al.
(2015) (details in Section 3.1), where the extractive rationale is a set of
tokens from the premise and hypothesis (‘‘bicycle race’’ and ‘‘riding bikes’’,
as highlighted) that are key features for the label (entailment).

We model rationales using a series of binary latent variables
($z_{i}^{r}\in\mathcal{Z}^{r}$) defined over the $N$ input units. An input
unit becomes a part of the rationale _iff_ the variable takes value 1 for that
unit. Following Bastings et al. (2019), we adapt a reparameterization strategy
to learn these binary latent selectors directly using backpropagation. Instead
of modeling each latent variable with a Bernoulli distribution, we use a Hard
Kumaraswamy (referred as $\operatorname{HardKuma}$) distribution Bastings et
al. (2019) that allows binary outcomes and facilitates optimization via
backpropagation. The parameters of the neural network $\mathcal{R}$ are
denoted by $\theta^{r}$ that estimates the $\operatorname{HardKuma}$ variables
for each input unit. We also encourage the rationale to be terse, and we
control the sparsity using an $L_{1}$ relaxation defined by the tractable
Kumaraswamy CDF.

###  2.2 Commonsense about Extractive Rationale

We hypothesize that commonsense222Our model is able to incorporate any type of
knowledge besides commonsense, e.g., form legal or medical domains. about the
extracted rationale are the most important bits of information for the
predictions and, implicitly, for the NLEs. Hence, we pass $z_{i}^{r}$s to the
commonsense module to expose only the extractive rationale for commonsense
expansion. For example, in Fig. 1a, we obtain relevant pieces of commonsense
knowledge (such as bicycle race requires bikes) for the rationale (i.e.,
‘‘bicycle race’’) which influence the prediction and the NLE generation.

More precisely, RExC incorporates a commonsense knowledge module,
$\mathcal{K}$, that supports input from an appropriate modality (e.g., text or
image). RExC queries $\mathcal{K}$ with the extractive rationales to obtain a
large pool of associated pieces of knowledge $\mathcal{S}$. We take advantage
of recent developments in generative models capable of providing commonsense
knowledge about a given entity, such as COMET Bosselut et al. (2019) for NL
inputs and VisualCOMET Park et al. (2020) for image inputs. For example, given
the entity ‘‘car’’, COMET would output pieces of commonsense knowledge such as
‘‘car is made up of car engine, front wheel, etc.’’. The generative
commonsense module does not suffer from the no-hit issue that is typically
encountered in non-parametric (retrieval) settings. Moreover, the parametric
form of the knowledge module is easily integrable in our end-to-end framework.
We denote the parameters of $\mathcal{K}$ as $\vartheta^{k}$, which are kept
frozen during RExC’s training.

To facilitate end-to-end training, we use soft representations of the
extractive rationales as query to $\mathcal{K}$. For that, we embed the input
using the embedding layer of $\mathcal{K}$ as
$\operatorname{emb}_{k}(\text{input})$ and perform element-wise multiplication
with $z_{i}^{r}$ as $\operatorname{emb}_{k}(\text{input}_{i})\odot z_{i}^{r}$
(see Fig. 2) to obtain the equivalent soft representation for the extractive
rationale that are finally passed to $\mathcal{K}$.

###  2.3 Targeted Knowledge Selection

While the knowledge module generates several pieces of commonsense knowledge
($\mathcal{S}$), not all of them are important for the prediction. Hence, we
introduce a knowledge selection step. Furthermore, the selected knowledge can
appear as supporting evidence in addition to the generated NLE---an advantage
of RExC over models that only generate NLEs. Hence, RExC explicitly learns to
select a set of knowledge from $\mathcal{S}$ before prediction and NLE
generation.

The ground-truth selection of knowledge is usually not available in the data;
hence, we model the selection step via another set of latent selectors
$z_{i}^{k}\in\mathcal{Z}^{k}$, which take a value from the interval $[0,1]$
and are realized by a $\operatorname{HardKuma}$ distribution (similarly to
Section 2.1). We assume that more than one knowledge snippet may be relevant,
however, we want the knowledge selection to be sparse. We use $L_{1}$
regularization to control the sparsity of the selected knowledge. The
parameters predicting the value of the latent selectors $z_{i}^{k}$ are
denoted as $\theta^{ks}$.

Again, to facilitate end-to-end training, we do not decode commonsense
knowledge into natural language. Rather, we retain the final hidden
representations of each piece of commonsense from the knowledge module as
$s_{i}\in S$. To use the selected knowledge, we perform element-wise
multiplication $s_{i}\odot z_{i}^{k}$ and fuse masked knowledge vectors into
the task prediction and NLE generation step. At inference time, we
additionally decode the selected commonsense and provide them as supporting
evidence along with the NLE in a variant of RExC that we call RExC+. During
human evaluation, we found that this evidence makes the NLEs get a better
quality score (see Section 4.2).

###  2.4 Task Prediction and NLE Generation

RExC uses best-suited commonsense that it selected for its task prediction and
NLE generation. We use a natural language explainer $\mathcal{G}$, that
encodes the soft representations of the knowledge fused at the embedding layer
Bhagavatula et al. (2020) and decodes them to an NLE (see Fig. 2). Further, we
add a predictor module $\mathcal{P}$, a linear layer with softmax, that takes
the final hidden representations of the NLE and projects them to the output
space for the task prediction. This makes the prediction process conditioned
on the NLE and, implicitly, on the extractive rationale. We denote the
parameters of $\mathcal{G}$ and $\mathcal{P}$ as $\theta^{g}$ and $\theta^{p}$
respectively. At the final stage, we use direct supervision from both the
ground-truth NLE and the ground-truth task output.

###  2.5 Training

The parameters for $\mathcal{R}$, $\mathcal{G}$, $\mathcal{P}$, and knowledge
selection can be jointly trained end-to-end with backpropagation by summing up
two losses: the negative log-likelihoods for original prediction task and for
the NLEs. We found updating parameters for $\mathcal{K}$ led to a minimal
improvement; hence, $\mathcal{K}$ is fixed for computational ease.

However, due to presence of $z_{i}^{r}$s in $\mathcal{R}$, we instead have to
optimize the lower bound $\mathcal{E}$ of the original log-likelihood. We
follow Bastings et al. (2019) and optimize

$\begin{split}\min_{\theta^{r},\theta^{g},\theta^{ks},\theta^{p}}-\mathcal{E}(\theta^{r},\theta^{k},\theta^{ks},\theta^{g},\theta^{p})\\\
+\lambda_{0}^{r}\sum\nolimits_{i=1}^{N}z_{i}^{r}+\lambda_{1}^{r}\sum\nolimits_{i=1}^{N-1}\left|z_{i}^{r}-z_{i+1}^{r}\right|,\end{split}$
(1)

where the second term is the $L_{1}$ penalty, the third term is a fused Lasso
to control the total number of transitions for compactness Lei et al. (2016),
and $\lambda_{0}^{r}$ and $\lambda_{1}^{r}$ are hyperparameters. Similar to
$\mathcal{R}$, we have another lower bound to optimize for $z_{i}^{k}$
variables in the knowledge selection step:

$\min_{\theta^{ks},\theta^{g},\theta^{p}}-\mathcal{E}(\theta^{ks},\theta^{g},\theta^{p})+\lambda_{0}^{k}\sum\nolimits_{i=1}^{M}z_{i}^{k},$
(2)

where the second term denotes $L_{1}$ regularization for sparse knowledge
selection. Finally, we combine the lower bounds as $\alpha\times$ Eq. (1)
$+(1-\alpha)\times$ Eq. (2), where $\alpha\in[0,1]$ is a hyperparameter. We
estimate the gradient of $\mathcal{E}$ via Monte-Carlo sampling from the
reparameterized $\operatorname{HardKuma}$ variables Kingma and Welling (2014).

##  3 Experiments

We experiment with RExC on three tasks of natural language understanding and
two tasks of vision-language understanding.

###  3.1 Tasks

ComVE. ComVE Wang et al. (2019) is a dataset for the task of commonsense
validation, where from a pair of sentences, a model needs to choose the
sentence that defies commonsense (see Fig. 3). The dataset also comes with
NLEs.

e-SNLI. SNLI Bowman et al. (2015) is a dataset for the task of recognizing
textual entailment, where given a pair of sentences (premise and hypothesis),
a model must classify their relation as either entailment, contradiction, or
neutral. We use the e-SNLI Camburu et al. (2018) dataset that contains NLEs
for SNLI (see Fig. 3).

COSe. CQA Talmor et al. (2019) is a multiple-choice commonsense question-
answering dataset. COSe Rajani et al. (2019) is an extension of CQA that
provides an NLE for each correct answer. We treat COSe as a multi-class
classification, where we concatenate each answer choice with the context and
perform softmax over the logits of the choices.

e-SNLI-VE. SNLI-VE Xie et al. (2019) is a computer-vision equivalent of the
SNLI dataset Bowman et al. (2015). SNLI-VE considers an image as a premise
(instead of text as in SNLI) and text as a hypothesis, with the same three
labels of entailment, neutral, and contradiction. e-SNLI-VE Kayser et al.
(2021) extends SNLI-VE with NLEs.

VCR. VCR Zellers et al. (2019) is a dataset for commonsense reasoning in a
visual-question-answering setup. In addition to predicting the answer, we
generate the NLEs from scratch (instead of choosing an NLE from a pool of
choices, as the dataset was introduced).

lcccccccccccccccccc ComVE e-SNLI COSe
System MET. BRTSc. BLRT. e-ViL Yes No MET. BRTSc.
BLRT. e-ViL Yes No MET. BRTSc. BLRT. e-ViL Yes No
Gold – – – 91.6 79.3 1.1 – – – 98.1 94.1 2.7 – – – 84.8 74.5 1.8
Neg-Heu 1.2 78.2 21.4 77.5 47.7 1.4 – – – – – – – – – – – –
NILE Kumar and Talukdar (2020) – – – – – – 11.3 75.3 41.2 84.3 80.1 9.4 – – –
– – –
GPT-2 Rajani et al. (2019) – – – – – – – – – – – – 1.3 43.1 16.9 59.5 35.4
16.7
BART Lewis et al. (2020a) 4.4 85.2 26.2 66.5 41.2 7.6 12.3 76.4 41.8 82.8 81.2
15.6 2.4 51.6 22.3 65.9 44.0 15.8
WT5 Narang et al. (2020) 3.4 86.4 27.0 67.7 46.2 11.0 12.3 75.3 42.3 85.3 82.7
12.8 2.2 52.0 22.4 73.0 53.9 10.5
RAG Lewis et al. (2020b) 3.2 89.4 26.0 62.1 43.2 15.0 13.1 77.4 45.3 87.6 81.3
13.4 3.6 55.4 23.7 79.2 63.1 9.5
RExC-ZS 7.8 72.4 24.1 65.7 56.3 16.1 11.9 63.4 40.7 88.1 85.6 5.7 2.4 38.4
17.4 83.2 73.2 5.6
RExC 14.1 91.9 33.5 87.2 72.6 2.7 19.5 86.6 51.4 94.8 93.8 3.7 7.1 60.4 30.5
87.3 74.4 2.1
RExC\+ – – – 88.3 72.5 1.1 – – – 95.4 94.1 2.7 – – – 87.8 74.5 1.8
w/o CS Sel. 11.4 90.1 33.2 84.3 65.3 5.1 17.9 83.4 51.0 92.8 91.6 5.8 6.4 58.4
27.8 85.0 70.2 2.5

Table 1: NLE evaluation for the NL tasks. Automatic metrics: METEOR (MET.),
BERTScore (BRTSc.), BLEURT (BLRT.) and human evaluation metrics: e-ViL score,
Yes/No %s. Bold indicates significant differences ($p<0.05$). RExC\+ adds the
selected knowledge with the generated NLEs, hence only used in the human
evaluations.

| e-SNLI-VE | VCR
---|---|---
System | MET. | BRTSc. | BLRT. | e-ViL | Yes | No | MET. | BRTSc. | BLRT. | e-ViL | Yes | No
Gold | \-- | \-- | \-- | 90.6 | 79.3 | 1.1 | \-- | \-- | \-- | 95.8 | 94.1 | 2.7
PJ-X Park et al. (2018) | 14.7 | 79.1 | 35.6 | 70.1 | 55.2 | 14.5 | 16.4 | 78.4 | 43.5 | 73.9 | 58.2 | 10.5
FME Wu and Mooney (2018) | 15.6 | 79.7 | 34.5 | 71.9 | 56.7 | 13.2 | 17.3 | 79.4 | 47.8 | 73.0 | 56.2 | 11.1
RVT Marasovic et al. (2020) | 18.8 | 81.1 | 35.3 | 72.2 | 55.4 | 12.8 | 11.2 | 78.9 | 44.2 | 73.2 | 57.4 | 11.5
e-UG Narang et al. (2020) | 19.6 | 81.7 | 37.8 | 75.6 | 57.9 | 9.9 | 11.8 | 79.0 | 45.6 | 75.1 | 59.3 | 10.4
RAG Lewis et al. (2020b) | 20.6 | 83.4 | 38.2 | 78.3 | 59.3 | 10.2 | 14.5 | 81.3 | 47.2 | 78.3 | 62.1 | 11.2
RExC-ZS | 12.4 | 78.7 | 35.9 | 79.7 | 60.7 | 10.3 | 15.7 | 78.9 | 41.4 | 78.9 | 65.2 | 10.2
RExC | 22.9 | 87.5 | 39.6 | 81.6 | 64.2 | 6.4 | 20.8 | 86.5 | 53.2 | 80.9 | 67.7 | 7.3
RExC+ | \-- | \-- | \-- | 82.0 | 65.3 | 6.3 | \-- | \-- | \-- | 81.7 | 67.0 | 6.3
w/o CS Sel. | 22.4 | 86.7 | 39.6 | 79.8 | 62.3 | 7.9 | 19.7 | 85.4 | 51.3 | 79.9 | 67.2 | 8.2

Table 2: NLE evaluation for the VL tasks. Automatic metrics: METEOR (MET.),
BERTScore (BRTSc.), BLEURT (BLRT.) and human evaluation metrics: e-ViL score,
Yes/No %s. Bold denotes significant differences ($p<0.05$). RExC\+ adds the
selected knowledge with the generated NLEs, hence only used in the human
evaluations.

###  3.2 Implementation Details and Baselines

The components of RExC for the NL tasks are:

  * •

Rationale extraction: We use the denoising encoder-decoder bart-base Lewis et
al. (2020a) with a linear layer and softmax at the end to generate the
distribution for latent selectors.

  * •

Commonsense resource: We pre-train a bart-base model as a proxy for COMET (we
matched with original perplexity, 11.47 vs. 11.14 with the same setup from
Bosselut et al. (2019)) that matches the tokenization scheme used in
$\mathcal{R}$.

  * •

NLE and task output: We use another bart-base model to generate the NLEs,
decoded with nucleus sampling ($p=0.95$) Holtzman et al. (2020). A linear
layer and a softmax are used as $\mathcal{P}$ to predict the task label.

The components of RExC for the VL tasks are:

  * •

Rationale extraction: We use a transformer-based VL model, UNITER Chen et al.
(2020), which uses self-attention to learn contextualized representations for
image-text input pairs. We add two MLPs on top of UNITER are used to generate
the distributions for each latent rationale selector from the image and text
input.

  * •

Commonsense resource: We use VisualCOMET Park et al. (2020) as image-based
commonsense module that is fine-tuned on ATOMIC Sap et al. (2019). For text
rationales, we follow the same structure as in the NL setup.

  * •

NLE and task output: We combine UNITER Chen et al. (2020), an encoder for
image-text pairs, and GPT-2 Radford et al. (2019), a language decoder,
following Kayser et al. (2021). We adapt GPT-2 to condition on the
representations learned by UNITER for VL inputs. We use nucleus sampling
($p=0.95$) for decoding NLEs from GPT-2. Like NL tasks, a linear layer
followed by a softmax are used for task prediction.

#### NL Baselines.333 We used the codes from the original implementations.

We use a general-purpose NLE generation model, WT5 Narang et al. (2020), as
the SOTA for all NL tasks. For ComVE, we further investigate a trivial
heuristic baseline (Neg-Heu), where we construct an NLE by negating the
nonsensical input sentence (we exploited the nature of the task, and short and
simple input, hence negating was easy in this case -- we add ‘‘not’’). For
example, if the model predicts ‘‘Cars can fly’’ as nonsensical, a trivial
justification can be ‘‘Cars cannot fly’’. For e-SNLI and COSe, we also compare
with their respective SOTA models that generate NLEs: NILE Kumar and Talukdar
(2020) and GPT-2 Rajani et al. (2019), respectively.

#### VL Baselines.

We consider a suite of baselines3 that can work in all VL tasks: PJ-X Park et
al. (2018) and FME Wu and Mooney (2018), both of which use a model pretrained
on VQA tasks; RVT Marasovic et al. (2020), a post-hoc explainer that uses off-
the-self computer vision algorithms to extract information from the input
image; and e-UG Kayser et al. (2021), the current SOTA in terms of NLE
generation, which uses UNITER to encode VL input and GPT-2 to generate NLEs.

#### Ablations of RExC.

We ablate RExC to investigate the effects of the extractive rationales (w/o
Rationales), commonsense module (w/o CS) and knowledge selection (w/o CS
Sel.). We also compare RExC with a retrieval-augmented NLE generation model
(RAG) Lewis et al. (2020b) to justify our choice of a generative commonsense
resource.

We also consider a baseline (RExC-ZS) where we only use task prediction loss
(and not NLE loss, i.e. zero-shot for NLEs) to learn the knowledge selection.
Only selected knowledge are concatenated to be used as NLEs.

##  4 Results444Due to lack of space, hyperparameters, additional results on
more automatic metrics, human evaluation, and more examples will be given
during the code release upon acceptance. and Discussion

We evaluate RExC with respect to performance in (1) NLE generation, (2)
rationale extraction, and (3) predictive task.

###  4.1 Automatic Evaluations

Following Kayser et al. (2021), we experiment with a suite of metrics
popularly used in language generation to capture how closely generated NLEs
follow ground-truth (when the predicted label is correct). Here, we report
METEOR Banerjee and Lavie (2005), BERTScore Zhang et al. (2020), and BLEURT
Sellam et al. (2020), which showed the highest correlation with human
evaluations in Kayser et al. (2021).

For NL tasks, RExC achieves the best values on all three automatic metrics in
subsection 3.1. We see sharp jumps (e.g., ranging from 4.7 to 9.7 points in
METEOR) between RExC and models that do not use commonsense knowledge, such as
fine-tuned versions of pretrained language models (BART and WT5). This
confirms that commonsense is a useful component for more accurate NLEs. The
gains for RExC over RExC w/o CS Sel. show that explicit knowledge selection
provides a regularizing effect.

Similarly for VL tasks, RExC outperforms the previous SOTA models (see Table
2). More specifically, RExC outperforms RVT, a competitive model that also
makes use of external commonsense resources, which indicates that (1)
extractive rationales are useful to gather relevant commonsense, and (2) joint
training for outputs and NLEs is superior over a post-hoc explainability
approach.

Figure 3: Examples of NLEs and extractive rationales generated from RExC along
with selected commonsense, for all five tasks, vs. explanations from the
previous SOTA for each dataset for the same (correct) outputs.

| e-SNLI | COSe
---|---|---
System | Acc. | IOU | Tok. | Acc. | IOU | Tok.
SOTA DeYoung et al. (2020) | 73.3 | 70.4 | 70.1 | 34.4 | 38.9 | 51.9
RExC | 78.3 | 72.8 | 73.5 | 39.2 | 41.6 | 56.2
w/o CS Sel. | 77.8 | 72.3 | 73.1 | 38.6 | 40.5 | 55.6
w/o CS | 73.4 | 70.9 | 69.8 | 35.4 | 39.1 | 52.6

Table 3: Comparison of previous SOTA models for rationale extraction vs. RExC
for rationale extraction performance on e-SNLI and COSe, using the ERASER
evaluation framework DeYoung et al. (2020). Best numbers are in bold.

RExC extracts better rationales. To evaluate the quality of extractive
rationales, we use ERASER DeYoung et al. (2020), a framework to compare
extractive rationales vs. ground-truth. ERASER uses accuracy (Acc.) and F1
scores at Intersection-Over-Union spans (IOU) or token (Tok.) level (details
in DeYoung et al. (2020)) to measure the overlap between extracted and the
ground-truth rationales. In Table 3, we show results for e-SNLI and COSe, the
only ones from our list that have ground-truth rationales available. We
observe that RExC leads to significantly superior-quality extractive
rationales as compared to models that do not use signals from NLEs or
commonsense to influence rationale extraction (e.g., 56.2 vs. 51.9 F1). Thus,
RExC achieves a new SOTA in extractive rationales for both datasets. Possible
explanations behind this can be: (1) additionally optimizing for NLEs
constrains RExC to generate more informative rationales, and (2) to obtain
better-suited commonsense for predictions and NLEs, RExC must generate high-
quality extractive rationales.

###  4.2 Human Evaluation of NLEs

Following Kayser et al. (2021), we designed a user study to measure the
quality of the generated NLEs. We make sure that the human annotators are able
to solve the predictive task before they evaluate the NLEs. For each NLE, we
ask: Given the input, does the explanation justify the answer? and provide
four options: Yes, Weak-Yes, Weak-No, and No. We report the e-ViL score from
Kayser et al. (2021) combining results for each option. We only consider NLEs
for correct predictions and collect 250 random such examples for each model
and each dataset. Finally, for each of the datasets, ComVE, e-SNLI, COSe,
e-SNLI-VE, and VCR, the inter-annotator agreement Cohen (1960) was 0.72, 0.76,
0.79, 0.81, and 0.74, respectively.

For NL tasks, subsection 3.1 shows that RExC is clearly preferred over the
previous SOTA models. Similar to the trend in automatic metrics, RExC without
knowledge selection shows large drops, which indicates that the knowledge
selection has positive effects on the quality of the NLEs. While Neg-Heu for
ComVE gets higher eViL score as compared to other baselines, the NLEs are (as
expected) rated far more trivial than those from other models by humans (15%
vs. 3% for RExC).

For VL tasks, NLEs from previous SOTA models were rated far lower than gold
references, indicating an even bigger need for improvement. We observe
substantial gains for NLEs from RExC as compared to competitive models that
already use external commonsense knowledge, such as RVT Marasovic et al.
(2020). This strengthens our hypothesis that commonsense knowledge about
rationales plays an important role in our framework.

Figure 4: Main limitations of the generated NLEs obtained from user study. All
numbers are in % and are averaged by systems and datasets for both NL and VL
tasks. Human annotators could choose multiple limitations for an NLE.

Error analysis. Figure 4 summarizes the main drawbacks of generated NLEs (in
average) across models and datasets. As main observation, we see that adding
commonsense knowledge and knowledge selection in RExC gradually make NLEs more
comprehensive and more relevant to the input. While RExC\+ wins over all other
models across all datasets, human judges often found them too verbose due the
presence of supporting knowledge snippets, which might repeat information from
the generated NLEs.

Qualitative analysis. Figure 3 shows sample outputs from RExC for all five
tasks. Reflecting our observations from the human evaluation (Figure 4), the
NLEs generated from RExC are more grounded in commonsense than the NLEs from
previous SOTA models (e.g., ‘‘Music can alleviate boredom when you are alone
at home’’ in COSe). RExC learns to select a relevant set of knowledge to use
as supporting evidence while grounding NLEs in commonsense. Moreover, previous
SOTA models on generating NLEs fall short of generating comprehensive NLEs
(e.g., ‘‘People listen to music’’ for COSe), which could be because they do
not condition on extractive rationales (e.g., ‘‘boredom’’).

###  4.3 Discussion

####  RExC bridges the gap between task performance and explainability.

So far, the SOTA models in terms of task accuracy for all the five tasks were
models that do not offer any explainability (see Table 4). Models that attempt
to offer explanations (NLEs or extractive rationales) faced a drop in
accuracy. RExC bridges this important gap by matching SOTA task performance
for 4 out 5 tasks and even achieving a new SOTA for e-SNLI-VE, while providing
two types of explanations, both of which being of higher quality than the
previous SOTA models with explanations. As evident, RExC outperforms, in terms
of task performance, all previous best performing models that offer
explanations.

System | ComVE | SNLI | CQA | SNLI-VE | VCR
---|---|---|---|---|---
SOTA | 97.0 | 93.1 | 83.7 | 78.9 | 81.6
SOTA w expl. | 96.2 | 92.3 | 82.7 | 77.1 | 72.0
RExC | 97.1 | 92.9 | 83.5 | 79.5 | 79.8
w/o CS Sel. | 97.0 | 92.7 | 83.2 | 79.3 | 78.6
w/o CS | 96.3 | 92.2 | 81.0 | 79.0 | 77.1
w/o Rationales | 96.5 | 92.2 | 81.9 | 78.9 | 77.3
w/o both | 96.2 | 91.7 | 80.7 | 78.4 | 76.1

Table 4: For task performance, we compare RExC with SOTA models (do not
include ensemble approaches) Wang et al. (2020, 2021); Lan et al. (2020); Xie
et al. (2019); Yu et al. (2020) in order for each dataset) that do not produce
any explanation. New SOTAs are in bold. We also compare RExC with best
performing models that can produce some kind of explanations (SOTA w expl.)
and underline the best results.

#### Using selected knowledge as NLE in zero-shot settings.

Often there exists a high overlap between NLEs from RExC and its selected
knowledge snippets. This is expected since we want the NLEs and predictions to
rely on the selected knowledge in RExC. This raises the question whether the
selected snippets alone could form sufficient NLEs. We argue that, in general,
this is not the case because the information in a commonsense resource may not
be the whole reasoning behind a prediction. This information is only meant to
add value but not replace the generated NLE. However, in particular cases
where the ground-truth NLEs consist mainly of pieces of commonsense knowledge,
selected snippets may be sufficient explanations. To investigate for our
datasets, we have the baseline RExC-ZS, where relevant knowledge were selected
only using task prediction loss and concatenated thereafter to be used as
NLEs. Sections 3.1 and 2 show that this baseline performs poorly in automatic
metrics due to lack of fluency and compactness. However, in human evaluation,
we see that even if the RExC-ZS NLEs were not preferred over the generated
NLEs from RExC, they were consistently preferred over the NLEs from all other
baselines. These results indicate: (1) the generative module in RExC acts as
an important conditional generation step that makes NLEs fluent and more
comprehensible; (2) despite being less fluent, concatenated knowledge snippets
could act as plausible NLEs in cases where ground-truth NLEs are not present.
This shows the potential of RExC for zero-shot rationalization.

#### Ablation study for RExC.

To pinpoint the contributing factor behind the improved performance in NLE
generation (Sections 3.1 and 2) and in the predictive task (Table 4), we
individually drop modules responsible for rationale extraction and commonsense
expansion and study relative performance changes. For both NL and VL tasks, we
find that an ablative baseline (BART/T5 for NL and RVT for VL) that does not
use external commonsense resources consistently lags in NLE quality compared
to RExC. Similarly, in Table 4, we observe performance drops in all prediction
tasks (e.g. 2.7 and 2.5 points in VCR) when we ablate with commonsense and
rationale extraction, respectively. Without knowledge selection, performance
of RExC drops both for NLEs and task predictions. Hence, we can infer that (1)
NLEs (and not just the commonsense) can enhance a model’s predictive
performance and (2) knowledge selection acts as a useful inductive bias in
effectively utilizing a large pool of knowledge.

Figure 5: Robustness equivalence: In (a) and (b), we analyze the robustness
equivalence between output labels and NLEs. In (a), the solid lines denote %
of stable (unflipped) labels under different noise levels ($\sigma^{2}$) in
the input. The dashed line indicating accuracy of RExC should follow the solid
line for better label-NLE association. In (b), each solid line corresponds to
the simulatability (defined in Section 5) of NLEs for each dataset. For better
label-NLE association, the sharpest drop in simulatability should align with
the sharpest drop in % of stable labels. Feature importance agreement: In (c)
and (d), we occlude % of input units (tokens or super-pixels) that are
important for either label prediction or NLE generation. In (c), solid lines
indicate the accuracy for predicted labels when tokens (or pixels) that are
important for NLEs are occluded. The dotted lines indicate the prediction
accuracy when random tokens (or super-pixels) are dropped. Similarly, in (d),
solid lines indicate the simulatability (NLE quality) when tokens (or super-
pixels) that are important for the predicted labels are occluded. Dotted line
indicates the simulatabilities for random occlusions. For better label-NLE
association, the solid lines both in (c) and (d) should have lower values than
the dotted lines. Refer to Wiegreffe et al. (2020) for more details.

#### Use of generative commonsense module.

One of the main reasons for choosing a generative commonsense knowledge module
(COMET and VisualCOMET) is to avoid the no-hit issue of indexed knowledge
bases or databases. For example, when we replaced COMET with ConceptNet, for
the e-SNLI dataset, we found 23% of instances do not retrieve any commonsense
snippets for all rationale-based queries. We also compared RExC with a
retrieval-augmented generative (RAG) framework trained using Maximum Inner
Product Search Lewis et al. (2020b) that uses ConceptNet and Visual
Commonsense Graphs instead of generative counterparts. As expected, RAG
performed worse than RExC (see Sections 3.1 and 2), possibly due to no-hit
issues and lack of diversity of the retrieved knowledge.

##  5 Faithfulness of RExC Explanations

We are interested in assessing the faithfulness of the two types of
explanations provided by RExC.

| ComVE | e-SNLI | COSe | e-SNLI-VE | VCR
---|---|---|---|---|---
Comp. | 0.32 | 0.45 | 0.24 | 0.28 | 0.33
Suff. | 0.14 | 0.08 | 0.05 | 0.10 | 0.13

Table 5: Comprehensiveness (Comp.) and Sufficiency (Suff.) metrics that
indicate the faithfulness of the extractive rationales for RExC.

#### Faithfulness of NLEs.

Evaluating faithfulness of NLEs is a challenging open question Jacovi and
Goldberg (2021). Kumar and Talukdar (2020) evaluated faithfulness in NLEs
using metrics that are used for extractive rationales, but those measures are
specific to their architecture. Recently, Wiegreffe et al. (2020) looked at
the degree of association between NLEs and output labels, as a necessary (but
not sufficient) condition for achieving faithfulness. We use their metrics,
namely robustness equivalence and feature importance agreement to sanity check
the faithfulness of the NLEs in RExC. For this, we analyze the model behavior
on both output prediction and NLE generation in various input conditions. To
capture a change in model behavior, we observe the change in task accuracy and
change in NLEs using simulatability\---the difference between task accuracy
when the NLE is given as input vs. when it is not (more details in Wiegreffe
et al. (2020)).

In Fig. 5a, b, we see the robustness equivalence between output labels and
NLEs. We observe that for all datasets, task outputs and NLEs are similarly
stable (or unstable) for a range of input noise. For example, for e-SNLI, we
see that the point of minimum contribution of NLEs to the prediction coincides
with the sharpest drop to the task accuracy at $\sigma^{2}=25$. In Fig. 5c, d,
we see the feature importance agreement---whether input parts (tokens or
super-pixels) that are important for task prediction are also important for
NLE generation and vice versa. In Fig. 5c, we see, for all datasets, that the
occlusion of the input parts important for NLE generation makes significant
drops in task accuracy. Similarly, in Fig. 5d, the occlusion of the input
parts that are important for task prediction contributes to large drops in NLE
simulatability across datasets. Thus, our experiments confirm that RExC
exhibits a strong association between task outputs and NLEs, passing the
faithfulness sanity check as proposed in Wiegreffe et al. (2020).

#### Faithfulness of extractive rationales.

We also investigate if RExC honors or ignores the extracted rationales for the
prediction. We measure the comprehensiveness and sufficiency metrics for the
extractive rationales from DeYoung et al. (2020).

Comprehensiveness measures whether the extractive rationales contain all the
necessary signals for the prediction. It is measured as the change in accuracy
between cases when the full input was used for the prediction vs. when the
extractive rationales were explicitly dropped (or masked for images) from the
input before making the prediction. A higher difference indicates a higher
extent of faithfulness. Sufficiency measures whether the extractive rationales
are enough for the model to make the decision. This is calculated as the
difference in accuracy between cases when the full input was used for the
prediction vs. when only the extactive rationales were used. A closer to zero
value indicates a higher degree of faithfulness. Table 5 shows that extractive
rationales in RExC are both comprehensive and sufficient.

##  6 Related Work

NLEs. A growing number of works in natural language processing and computer-
vision are focusing on designing neural models that produce NLEs for their
predictions to make these models accessible to their users Hendricks et al.
(2016); Camburu et al. (2018); Park et al. (2018); Kim et al. (2018); Ling et
al. (2017); Marasovic et al. (2020). A recent work Narang et al. (2020) has
achieved SOTA on NLEs for NL tasks by using a transformer encoder-decoder pre-
trained as a language model. Marasovic et al. (2020) show the importance of
semantics in connecting low-level features to an NLE in the VL domain.

The current datasets of NLEs in NL and VL have been proposed in Wang et al.
(2019); Camburu et al. (2018); Rajani et al. (2019); Kayser et al. (2021);
Zellers et al. (2019). We benchmark RExC on these datasets and achieve SOTA in
both automatic and human evaluation of NLEs.

Extractive rationales. Another form of machine explanation are extractive
rationales, i.e., a set of predictive input features. An early work Zaidan and
Eisner (2008) investigated rationale extraction directly from inputs (e.g.,
tokens indicating sentiment in reviews) and later was successfully followed by
works for both NL DeYoung et al. (2020); Lei et al. (2016); Bastings et al.
(2019); Sha et al. (2021) and VL Strout et al. (2019) tasks. We model both the
extractive rationales and NLEs jointly in a novel framework that improves
their quality.

Commonsense in text generation. Commonsense is a crucial component in free-
text generation. Representative scenarios where commonsense is used are dialog
generation Majumder et al. (2020), creative text generation Chakrabarty et al.
(2020), story generation Mao et al. (2019), and counterfactual generation
Bhagavatula et al. (2020). Recently, Marasovic et al. (2020) used commonsense
resources as semantic understanding tools to connect low-level features to
NLEs in the VL domain. In this work, we establish that commonsense plays a
critical role in connecting extractive rationales and NLEs, and help to
achieve NLEs that are more grounded in commonsense (Fig. 4).

##  7 Conclusion

In this work, we proposed RExC, a self-rationalizing framework that
incorporates commonsense resources and provides two representative type of
explanations: extractive rationales and NLEs. Using five tasks, from natural
language and vision-language domains, we show that RExC obtains a new SOTA
performance for both NLE generation and rationales extraction. We also reduce
the important trade-off between task performance and NLE generation, and even
obtain a new SOTA for one of the tasks. While currently we use only
commonsense resources, future work could look into adding other types of
knowledge resources, including more specialized ones, such as legal and
medical. RExC also opens up the possibility of NLE generation in few-shot and
zero-shot settings.

## Acknowledgments

Bodhisattwa Prasad Majumder was partly supported by a Qualcomm Innovation
Fellowship (2020) and NSF Award #1750063. Thomas Lukasiewicz and Oana-Maria
Camburu were supported by the Alan Turing Institute under the UKRI EPSRC grant
EP/N510129/1 and by the UKRI EPSRC grant EP/R013667/1. Thomas Lukasiewicz was
additionally supported by the AXA Research Fund and by the ESRC grant
“Unlocking the Potential of AI for English Law”.

## References

  * Alufaisan et al. (2021) Yasmeen Alufaisan, Laura R. Marusich, Jonathan Z. Bakdash, Yan Zhou, and Murat Kantarcioglu. 2021.  Does explainable artificial intelligence improve human decision-making? In _AAAI_.
  * Banerjee and Lavie (2005) Satanjeev Banerjee and Alon Lavie. 2005.  METEOR: an automatic metric for MT evaluation with improved correlation with human judgments.  In _Workshop on Intrinsic and Extrinsic Evaluation Measures for Machine Translation and/or Summarization@ACL_.
  * Bastings et al. (2019) Jasmijn Bastings, Wilker Aziz, and Ivan Titov. 2019.  Interpretable neural predictions with differentiable binary variables.  In _ACL_.
  * Bhagavatula et al. (2020) Chandra Bhagavatula, Ronan Le Bras, Chaitanya Malaviya, Keisuke Sakaguchi, Ari Holtzman, Hannah Rashkin, Doug Downey, Wen-tau Yih, and Yejin Choi. 2020.  Abductive commonsense reasoning.  In _ICLR_.
  * Bosselut et al. (2019) Antoine Bosselut, Hannah Rashkin, Maarten Sap, Chaitanya Malaviya, Asli Celikyilmaz, and Yejin Choi. 2019.  COMET: commonsense transformers for automatic knowledge graph construction.  In _ACL_.
  * Bowman et al. (2015) Samuel R. Bowman, Gabor Angeli, Christopher Potts, and Christopher D. Manning. 2015\.  A large annotated corpus for learning natural language inference.  In _EMNLP_.
  * Camburu et al. (2021) Oana-Maria Camburu, Eleonora Giunchiglia, Jakob Foerster, Thomas Lukasiewicz, and Phil Blunsom. 2021.  The struggles of feature-based explanations: Shapley values vs. minimal sufficient subsets.  In _AAAI Workshop on Explainable Agency in Artificial Intelligence_.
  * Camburu et al. (2018) Oana-Maria Camburu, Tim Rocktäschel, Thomas Lukasiewicz, and Phil Blunsom. 2018.  e-SNLI: Natural language inference with natural language explanations.  In _NeurIPS_.
  * Camburu et al. (2020) Oana-Maria Camburu, Brendan Shillingford, Pasquale Minervini, Thomas Lukasiewicz, and Phil Blunsom. 2020.  Make up your mind! adversarial generation of inconsistent natural language explanations.  In _ACL_.
  * Chakrabarty et al. (2020) Tuhin Chakrabarty, Debanjan Ghosh, Smaranda Muresan, and Nanyun Peng. 2020.  R^3: Reverse, retrieve, and rank for sarcasm generation with commonsense knowledge.  In _ACL_.
  * Chen et al. (2020) Yen-Chun Chen, Linjie Li, Licheng Yu, Ahmed El Kholy, Faisal Ahmed, Zhe Gan, Yu Cheng, and Jingjing Liu. 2020.  UNITER: universal image-text representation learning.  In _ECCV_.
  * Cohen (1960) Jacob Cohen. 1960.  A coefficient of agreement for nominal scales.  _Educational and psychological measurement_ , 20(1):37--46.
  * DeYoung et al. (2020) Jay DeYoung, Sarthak Jain, Nazneen Fatema Rajani, Eric Lehman, Caiming Xiong, Richard Socher, and Byron C. Wallace. 2020.  ERASER: A benchmark to evaluate rationalized NLP models.  In _ACL_.
  * Hendricks et al. (2016) Lisa Anne Hendricks, Zeynep Akata, Marcus Rohrbach, Jeff Donahue, Bernt Schiele, and Trevor Darrell. 2016.  Generating visual explanations.  In _ECCV_.
  * Holtzman et al. (2020) Ari Holtzman, Jan Buys, Li Du, Maxwell Forbes, and Yejin Choi. 2020.  The curious case of neural text degeneration.  In _ICLR_.
  * Jacovi and Goldberg (2021) Alon Jacovi and Yoav Goldberg. 2021.  Aligning faithful interpretations with their social attribution.  _TACL_.
  * Kaur et al. (2020) Harmanpreet Kaur, Harsha Nori, Samuel Jenkins, Rich Caruana, Hanna M. Wallach, and Jennifer Wortman Vaughan. 2020.  Interpreting interpretability: Understanding data scientists’ use of interpretability tools for machine learning.  In _CHI_.
  * Kayser et al. (2021) Maxime Kayser, Oana-Maria Camburu, Leonard Salewski, Cornelius Emde, Virginie Do, Zeynep Akata, and Thomas Lukasiewicz. 2021.  e-ViL: A dataset and benchmark for natural language explanations in vision-language tasks.  _CoRR_ , abs/2105.03761.
  * Kim et al. (2018) Jinkyu Kim, Anna Rohrbach, Trevor Darrell, John F. Canny, and Zeynep Akata. 2018\.  Textual explanations for self-driving vehicles.  In _ECCV_.
  * Kingma and Welling (2014) Diederik P. Kingma and Max Welling. 2014.  Auto-encoding variational bayes.  In _ICLR_.
  * Kumar and Talukdar (2020) Sawan Kumar and Partha P. Talukdar. 2020.  NILE : Natural language inference with faithful natural language explanations.  In _ACL_.
  * Lan et al. (2020) Zhenzhong Lan, Mingda Chen, Sebastian Goodman, Kevin Gimpel, Piyush Sharma, and Radu Soricut. 2020.  ALBERT: A lite BERT for self-supervised learning of language representations.  In _ICLR_.
  * Lei et al. (2016) Tao Lei, Regina Barzilay, and Tommi S. Jaakkola. 2016.  Rationalizing neural predictions.  In _EMNLP_.
  * Lewis et al. (2020a) Mike Lewis, Yinhan Liu, Naman Goyal, Marjan Ghazvininejad, Abdelrahman Mohamed, Omer Levy, Veselin Stoyanov, and Luke Zettlemoyer. 2020a.  BART: denoising sequence-to-sequence pre-training for natural language generation, translation, and comprehension.  In _ACL_.
  * Lewis et al. (2020b) Patrick S. H. Lewis, Ethan Perez, Aleksandra Piktus, Fabio Petroni, Vladimir Karpukhin, Naman Goyal, Heinrich Küttler, Mike Lewis, Wen-tau Yih, Tim Rocktäschel, Sebastian Riedel, and Douwe Kiela. 2020b.  Retrieval-augmented generation for knowledge-intensive NLP tasks.  In _NeurIPS_.
  * Ling et al. (2017) Wang Ling, Dani Yogatama, Chris Dyer, and Phil Blunsom. 2017.  Program induction by rationale generation: Learning to solve and explain algebraic word problems.  In _ACL_.
  * Majumder et al. (2020) Bodhisattwa Prasad Majumder, Harsh Jhamtani, Taylor Berg-Kirkpatrick, and Julian J. McAuley. 2020.  Like hiking? you probably enjoy nature: Persona-grounded dialog with commonsense expansions.  In _EMNLP_.
  * Mao et al. (2019) Huanru Henry Mao, Bodhisattwa Prasad Majumder, Julian J. McAuley, and Garrison W. Cottrell. 2019.  Improving neural story generation by targeted common sense grounding.  In _EMNLP-IJCNLP_.
  * Marasovic et al. (2020) Ana Marasovic, Chandra Bhagavatula, Jae Sung Park, Ronan Le Bras, Noah A. Smith, and Yejin Choi. 2020.  Natural language rationales with full-stack visual reasoning: From pixels to semantic frames to commonsense graphs.  In _EMNLP Findings_.
  * Narang et al. (2020) Sharan Narang, Colin Raffel, Katherine Lee, Adam Roberts, Noah Fiedel, and Karishma Malkan. 2020.  Wt5?! training text-to-text models to explain their predictions.  _CoRR_ , abs/2004.14546.
  * Park et al. (2018) Dong Huk Park, Lisa Anne Hendricks, Zeynep Akata, Anna Rohrbach, Bernt Schiele, Trevor Darrell, and Marcus Rohrbach. 2018.  Multimodal explanations: Justifying decisions and pointing to the evidence.  In _CVPR_.
  * Park et al. (2020) Jae Sung Park, Chandra Bhagavatula, Roozbeh Mottaghi, Ali Farhadi, and Yejin Choi. 2020.  Visualcomet: Reasoning about the dynamic context of a still image.  In _ECCV_.
  * Radford et al. (2019) Alec Radford, Jeffrey Wu, Rewon Child, David Luan, Dario Amodei, and Ilya Sutskever. 2019.  Language models are unsupervised multitask learners.  _OpenAI blog_ , 1(8):9.
  * Rajani et al. (2019) Nazneen Fatema Rajani, Bryan McCann, Caiming Xiong, and Richard Socher. 2019.  Explain yourself! leveraging language models for commonsense reasoning.  In _ACL_.
  * Sap et al. (2019) Maarten Sap, Ronan Le Bras, Emily Allaway, Chandra Bhagavatula, Nicholas Lourie, Hannah Rashkin, Brendan Roof, Noah A. Smith, and Yejin Choi. 2019.  ATOMIC: an atlas of machine commonsense for if-then reasoning.  In _AAAI_.
  * Sellam et al. (2020) Thibault Sellam, Dipanjan Das, and Ankur P. Parikh. 2020.  BLEURT: learning robust metrics for text generation.  In _ACL_.
  * Sha et al. (2021) Lei Sha, Oana-Maria Camburu, and Thomas Lukasiewicz. 2021.  Learning from the best: Rationalizing predictions by adversarial information calibration.  In _AAAI_.
  * Strout et al. (2019) Julia Strout, Ye Zhang, and Raymond J. Mooney. 2019.  Do human rationales improve machine explanations? _CoRR_ , abs/1905.13714.
  * Talmor et al. (2019) Alon Talmor, Jonathan Herzig, Nicholas Lourie, and Jonathan Berant. 2019.  Commonsenseqa: A question answering challenge targeting commonsense knowledge.  In _NAACL-HLT_.
  * Wang et al. (2020) Cunxiang Wang, Shuailong Liang, Yili Jin, Yilong Wang, Xiaodan Zhu, and Yue Zhang. 2020.  SemEval-2020 task 4: Commonsense validation and explanation.  In _SemEval_.
  * Wang et al. (2019) Cunxiang Wang, Shuailong Liang, Yue Zhang, Xiaonan Li, and Tian Gao. 2019.  Does it make sense? and why? a pilot study for sense making and explanation.  In _ACL_.
  * Wang et al. (2021) Sinong Wang, Han Fang, Madian Khabsa, Hanzi Mao, and Hao Ma. 2021.  Entailment as few-shot learner.  _CoRR_ , abs/2104.14690.
  * Wiegreffe et al. (2020) Sarah Wiegreffe, Ana Marasovic, and Noah A. Smith. 2020.  Measuring association between labels and free-text rationales.  _CoRR_ , abs/2010.12762.
  * Wu and Mooney (2018) Jialin Wu and Raymond J. Mooney. 2018.  Faithful multimodal explanation for visual question answering.  _CoRR_ , abs/1809.02805.
  * Xie et al. (2019) Ning Xie, Farley Lai, Derek Doran, and Asim Kadav. 2019.  Visual entailment: A novel task for fine-grained image understanding.  _CoRR_ , abs/1901.06706.
  * Yu et al. (2020) Fei Yu, Jiji Tang, Weichong Yin, Yu Sun, Hao Tian, Hua Wu, and Haifeng Wang. 2020\.  Ernie-vil: Knowledge enhanced vision-language representations through scene graph.  _CoRR_ , abs/2006.16934.
  * Zaidan and Eisner (2008) Omar Zaidan and Jason Eisner. 2008.  Modeling annotators: A generative approach to learning from annotator rationales.  In _EMNLP_.
  * Zellers et al. (2019) Rowan Zellers, Yonatan Bisk, Ali Farhadi, and Yejin Choi. 2019.  From recognition to cognition: Visual commonsense reasoning.  In _CVPR_.
  * Zhang et al. (2020) Tianyi Zhang, Varsha Kishore, Felix Wu, Kilian Q. Weinberger, and Yoav Artzi. 2020\.  Bertscore: Evaluating text generation with BERT.  In _ICLR_.