# Accurate, yet inconsistent? Consistency Analysis on Language Understanding
Models

Myeongjun Jang1, Deuk Sin Kwon211footnotemark: 1 equal contribution Thomas
Lukasiewicz1
1Department of Computer Science, University of Oxford
{myeongjun.jang<EMAIL_ADDRESS>
2Language Super Intelligence Labs, SK Telecom
<EMAIL_ADDRESS>
###### Abstract

Consistency, which refers to the capability of generating the same predictions
for semantically similar contexts, is a highly desirable property for a sound
language understanding model. Although recent pretrained language models
(PLMs) deliver outstanding performance in various downstream tasks, they
should exhibit consistent behaviour provided the models truly understand
language. In this paper, we propose a simple framework named _c onsistency
analysis on language understanding models (CALUM)_ to evaluate model’s lower-
bound consistency ability. Through experiments, we confirmed that current PLMs
are prone to generate inconsistent predictions even for semantically identical
inputs. We also observed that multi-task training with paraphrase
identification tasks is of benefit to improve consistency, increasing the
consistency by 13% on average.

##  1 Introduction

Large-sized pretrained language models (PLMs), such as BERT Devlin et al.
(2019) and GPT2 Radford et al. (2019), have entered the mainstream in natural
language processing (NLP). They delivered outstanding performance on many
downstream tasks through fine-tuning and in-context learning Brown et al.
(2020a). Based on these results, claims that such PLMs understand language
have been introduced in the literature Devlin et al. (2019); Ohsugi et al.
(2019); Qiu et al. (2020) and popular press, such as Google Blog
post111https://www.blog.google/products/search/search-language-understanding-
bert/ accessed 2021/07/14 and Toward Data Science
website222https://towardsdatascience.com/pre-trained-language-models-
simplified-b8ec80c62217 accessed 2021/07/14.

However, recent studies cast doubts on the language understanding capacity of
PLMs. Nuemerous studies revealed that PLMs are incapable of capturing the
semantic meaning of sentences but rely on the excessive exploitation of
statistical cues or syntactic patterns Habernal et al. (2018); Niven and Kao
(2019); McCoy et al. (2019); Bender and Koller (2020). Another line of works
found that PLMs memorise frequent word/phrase/knowledge presented in
pretraining data but hardly understand unseen expressions and knowledge
Kassner et al. (2020); Ravichander et al. (2020); Hofmann et al. (2021).
Moreover, many works observed that PLMs lack understanding of negated phrase
Naik et al. (2018); Hossain et al. (2020); Kassner and Schütze (2020);
Ettinger (2020); Hosseini et al. (2021) or number-related commonsense
knowledge Lin et al. (2020).

The lexical definition of the word understand is to know or realise the
meaning of words and a
language333https://www.oxfordlearnersdictionaries.com/definition-/english/understand?q=understand
accessed 2021/07/14. In this regard, consistency, which refers to the
capability of making coherent decisions on semantically equivalent contexts
Elazar et al. (2021), is an important property that a good language
understanding model should satisfy. Language models should exhibit consistent
behaviour provided they truly understand human language. In this context, the
performance of PLMs should be illuminated and evaluated in terms of
consistency, aside from other evaluation metrics such as accuracy.

Many recent studies deliver indications that PLMs lack consistency. In a zero-
shot knowledge retrieval task, BERT made different predictions for
semantically similar queries ; queries that subjects are replaced by their
plural forms Ravichander et al. (2020) or paraphrased queries Elazar et al.
(2021). Research regarding text adversarial attacks also revealed that fine-
tuned PLMs misclassify adversarial examples where human-indiscernible noises
are added to the original text Morris et al. (2020); Li et al. (2020a); Garg
and Ramakrishnan (2020).

In this paper, we propose a framework named Consistency Analysis on Language
Understanding Models (CALUM) to evaluate the consistency of PLMs after fine-
tuned on language understanding tasks. The framework measures consistency by
leveraging marginal perturbations that guarantee perfectly identical semantic
meanings. The major contributions of our work could be summarised as follows:

  * •

We propose a framework for evaluating PLM’s lower-bound ability of consistency
on language understanding tasks.

  * •

Through experiments, we reveal that PLMs are inconsistent even for input text
conveying identical semantic meanings regardless of models and languages.

  * •

Our finding suggests that training a multi-task model with semantic textual
similarity tasks can improve consistency.

##  2 Related Works

##### Consistency

There have been several attempts to analyse the consistency of language models
in various NLP domains. For zero-shot knowledge retrieval tasks, Ravichander
et al. (2020) found that PLMs generate different answers if an object of the
original query is replaced with its plural form (e.g. ‘A robin is a [MASK]’ to
‘robins are [MASK]’). Elazar et al. (2021) observed discrepancy in the
predictions of PLMs for paraphrase queries and alleviated the issue by fine-
tuning the model on the generated paraphrase queries. In question answering
(QA), Ribeiro et al. (2019) showed that state-of-the-art QA and visual QA
models generate inconsistent outputs for queries with the same context. They
used data augmentation to improve consistency. To train a consistent QA model,
Asai and Hajishirzi (2020) also used data augmentation and, additionally,
inconsistency loss, which is designed to penalise inconsistent predictions.
Ribeiro et al. (2020) proposed Invariance test to evaluate consistency. For a
sentiment analysis task, they changed the named entity presented in a given
sentence because such perturbation does not change the polarity of the
sentence. However, it is difficult to apply this approach to other language
understanding tasks because it requires human inspection since the method does
not guarantee semantic equivalence. For instance, "How many people are there
in London?" and "How many people are there in Seoul?" convey entirely
different meaning and, therefore, there exist the possibility for a model to
make different decisions. Research on consistency in other domains includes
text summarisation Kryscinski et al. (2020), explanation generation Camburu et
al. (2020), and dialog generation Li et al. (2020b). Li et al. (2020b)
employed unlikelihood training Welleck et al. (2019) to improve consistency of
a dialog model.

##### Text Adversarial Attack

After the advent of PLMs, there have been several works to attack the models
by using adversarial examples. Jin et al. (2020) proposed a black-box attack
approach called TextFooler that replace important words in an input sentence
with their synonyms. Li et al. (2020a) used BERT for generating adversarial
samples. They first extracted important words for decision-making and replaced
them by using BERT masked language model (MLM). Garg and Ramakrishnan (2020)
also used BERT MLM not only for replacing important tokens but also for
inserting new tokens. Li et al. (2021) employed MLM for three strategies;
replace, insert, and merge that mask bi-gram and replace it with a single
word.

Text adversarial attacks have a commonality with consistency in that
adversarial examples are designed to have a similar meaning with their
original counterparts. However, text adversarial attacks exhibit a critical
difference to our work in that they do not guarantee semantic identicalness
due to the unnatural looking, grammatical errors, and insecurity of PLM’s MLM
performance Ravichander et al. (2020); Ettinger (2020); Kassner and Schütze
(2020); Elazar et al. (2021). On the contrary, our framework perfectly assures
identical meaning, which is an essential property to evaluate a lower-bound
consistency of PLMs.

##### Prompt Engineering

Prompt refers to constructing an input text with a job description or some
examples prepended Lester et al. (2021). Recently, there has been an upsurge
of research interest in prompt engineering, with the advent of GPT3 showing
its powerful performance on zero-shot/few-shot tasks only through variants of
prompts without further fine-tuning Brown et al. (2020b). Considering how to
effectively search prompts that optimally control the fixed pre-trained
language model, several studies have been conducted on automating prompt
design or tuning the prompt with learnable parameters Shin et al. (2020);
Reynolds and McDonell (2021). Lester et al. (2021) proposed a prompt tuning
method where some tunable tokens presenting each downstream task are
prepeneded to the original input text with the frozen pre-trained model,
showing its competitiveness with a typical fine-tuning method. Li and Liang
(2021) also suggested a novel approach for prompt engineering called prefix-
tuning, which prepends the task-specific prefix consisting of tunable
parameters to the inputs in each transformer layer and optimises only the
prefix instead of updating all Transformer parameters. In line with these
prompt engineering techinques, Hambardzumyan et al. (2021) purturbed inputs as
a way of Adversarial Reprogramming by inserting learnable prompt tokens to a
specific location in the input text, training the prompt parameters during
optimization of the specific downstream task objective.

However, these studies which highlight different approaches of prompt
engineering and subsequent variations of performance, raise questions about
whether language models have consistency capability. In addition, although the
methods proposed in these works find the optimal for solving downstream tasks
through prompt tuning, there are still doubts on whether the consistency of
LMs is improved by these methods. Moreover, a majority of these studies focus
only on the improvement of the performance of downstream tasks. Therefore,
there certainly is a need for evaluating the language understanding ability of
LMs from a consistency point of view.

##  3 CALUM: Consistency Analysis on Language Understanding Models

(a) REVERSE case

(b) SIGNAL case

Figure 1: Example of CALUM framework for MNLI task. The changes in the
original free-text inputs are marked in blue.

Our framework evaluates a model’s consistency on language understanding tasks
that infer the relation of two input sentences, such as natural language
inference (NLI) and semantic textual similarity (STS) tasks. In our
experiments, it is crucial to ensure semantic equivalence after perturbation.
To achieve this, we first insert a free-text sentence-type indicator at the
beginning of each sentence (e.g. ‘Premise:’ and ‘Hypothesis:’ for the NLI
task). Each model is trained on this original form. Next, we applied two
perturbation methods: REVERSE and SIGNAL.

##### REVERSE

This method changes the order of the two input sentences. The meaning of
inputs remains identical because of the sentence-type indicator. An example
case of this method is illustrated in Figure 1(a).

##### SIGNAL

This method changes a special symbol in the sentence-type indicator. In our
experiments, we replaced a colon with brackets. This ensures semantic
equivalence because such symbols convey no specific meanings. An example case
of this mehod is illustrated in Figure 1(b).

Finally, we measure a model’s consistency by calculating the accuracy between
its predictions on the original and perturbed inputs. The overall framework of
our proposed method is illusrtated in Figure 1.

##  4 Experiment Design

###  4.1 Datasets

As the two task types (i.e. NLI & STS) are mentioned in the previous section,
we select the related tasks from the GLUE Benchmark Wang et al. (2019). For
the NLI task, we use MNLI (MultiNLI, Multi-Genre Natural Language Inference,
Williams et al., 2018), QNLI (Question Natural Language Inference, Rajpurkar
et al., 2016) and RTE (Recognising Textual Entailment, Candela-Quinonero et
al., 2006) for the evaluation of our framework; they are composed of two
sentence pairs and a label indicating whether the sentence pairs are entailed
or not in common. In addition, we also use QQP (Quora Question
Pairs444https://www.kaggle.com/c/quora-question-pairs/data) and MRPC
(Microsoft Research Paraphrase Corpus, Dolan and Brockett, 2005) for the STS
task type, which consist of two sentence pairs and a label related to sentence
equivalence.

Meanwhile, in order to show the general applicability of our framework, we
perform the evaluation not only on the above English tasks, but also on Korean
versions of the same task type. For the NLI task, KorNLI Ham et al. (2020) &
KLUE-NLI Park et al. (2021) are selected and for the STS task, KLUE-STS Park
et al. (2021) is used. The three Korean datasets do not provide test sets.
Therefore, we randomly sampled test sets from the validation set for KLUE
datsets and from training set for KorNLI dataset. Descriptions of the datasets
are illustrated in Table 1.

Table 1: Descriptions of datasets for the experiments. |  # of classes |  Train set size |  Validation set size |  Test set size
---|---|---|---|---
MNLI | 3 | 393K | 9.8K | 9.8K
QNLI | 2 | 105K | 5.5K | 5.5K
RTE | 2 | 2.5K | 277 | 3K
QQP | 2 | 364K | 40K | 391K
MRPC | 2 | 3.7K | 408 | 1.7K
KorNLI | 3 | 53K | 10K | 10K
KLUE-NLI | 3 | 25K | 1.5K | 1.5K
KLUE-STS | 2 | 1.2K | 260 | 259

###  4.2 Model candidates

To measure the consistency of PLMs on language understanding capability, we
conduct experiments on various types and sizes of PLMs. For English tasks, we
perform experiments with the Encoder models ($RoBERTa_{base}$,
$RoBERTa_{large}$, $Electra_{small}$, $Electra_{large}$), the Decoder models
($GPT2_{base}$, $GPT2_{large}$), and the Seq2Seq models ($T5_{base}$,
$T5_{large}$, $BART_{base}$). For Korean tasks, $KoBERT$ and $KoElectra$ are
used as the Encoder models. For the Decoder and Seq2Seq models, $KoGPT2$, and
$KoBART$ are employed, respectively. All PLMs implemented in our experiments
are from huggingface transformers Wolf et al. (2020) library and used as fine-
tuning backbone models.

###  4.3 Training details

Regardless of the model type except for $T5$ models , a classification head is
added on the top of the model, and all weights of the model are updated while
optimising the classification objective function. We finetune each of our
candidate language models on individual task datasets. Meanwhile, finetuning
for $T5$ models is not performed in this study since the finetuned version of
T5 models is used.

At finetuning, we use the AdamW optimiser with weight decay 1e-3, Loshchilov
and Hutter (2017) and a linear learning rate scheduler with warm-up. We
finetune models for 10 epochs with learning rate of 1e-5 and batch size of 64,
applying an early stopping method during the training.

###  4.4 Human Performance

We also evaluate human’s consistency ability. For English and Korean tasks,
five human annotators who are native to each language are asked to solve the
language understanding tasks we used for the experiments. For each annotator,
we provide the original input format. Each annotator is given 30 samples
extracted from the validation data, and their corresponding perturbed
examples.

Model | MNLI | QNLI | RTE | QQP | MRPC
---|---|---|---|---|---
$Acc_{val}$ | $C_{R}$ | $C_{S}$ | $Acc_{val}$ | $C_{R}$ | $C_{S}$ | $Acc_{val}$ | $C_{R}$ | $C_{S}$ | $Acc_{val}$ | $C_{R}$ | $C_{S}$ | $Acc_{val}$ | $C_{R}$ | $C_{S}$
$RoBERTa_{base}$ | 87.2 | 60.3 | 98.6 | 92.4 | 75.5 | 98.5 | 66.7 | 66.4 | 92.2 | 90.8 | 97.3 | 99.1 | 87.0 | 94.9 | 97.7
$RoBERTa_{large}$ | 90.0 | 64.3 | 98.9 | 94.1 | 81.8 | 99.0 | 74.7 | 59.6 | 90.0 | 91.2 | 96.7 | 99.3 | 84.4 | 93.9 | 96.4
$Electra_{small}$ | 81.3 | 52.9 | 94.5 | 87.2 | 64.6 | 94.8 | 55.4 | 86.6 | 92.0 | 88.5 | 97.1 | 97.5 | 68.4 | 100.0 | 100.0
$Electra_{large}$ | 90.7 | 63.3 | 98.6 | 94.7 | 55.4 | 99.0 | 82.2 | 59.2 | 94.8 | 91.4 | 97.1 | 99.1 | 87.7 | 92.6 | 96.4
$GPT2_{base}$ | 80.4 | 44.0 | 92.2 | 87.4 | 49.0 | 94.1 | 61.0 | 62.5 | 83.4 | 87.9 | 93.1 | 95.7 | 70.1 | 92.2 | 86.8
$GPT2_{large}$ | 85.9 | 56.8 | 96.9 | 91.4 | 52.7 | 97.6 | 70.4 | 40.1 | 93.7 | 90.3 | 94.1 | 98.8 | 80.9 | 89.7 | 90.0
$BART_{base}$ | 85.5 | 54.2 | 98.5 | 91.4 | 50.2 | 98.5 | 58.1 | 68.7 | 91.5 | 89.9 | 96.8 | 98.9 | 70.8 | 99.8 | 99.2
$T5_{base}$ | 85.9 | 60.3 | 6.4 | 93.2 | 87.4 | 0.1 | 66.4 | 82.1 | 0.0 | 90.6 | 97.4 | 63.6 | 85.8 | 96.4 | 0.0
$T5_{large}$ | 89.8 | 85.7 | 83.2 | 93.9 | 94.5 | 53.7 | 79.4 | 87.1 | 0.0 | 91.3 | 97.7 | 70.5 | 87.7 | 97.5 | 0.0
Human | 77.3 | 96.0 | 96.0 | 85.5 | 98.3 | 98.3 | 79.3 | 94.0 | 96.0 | 80.5 | 98.3 | 98.3 | 59.3 | 91.9 | 100.0
Table 2: Results for the consistency evaluation on English datasets.
$Acc_{val}$ denotes an accuracy on the validation dataset. $C_{R}$ and $C_{S}$
stands for the consistency for REVERSE and SIGNAL cases, respectively. We
trained each model five times and recorded the average of each metric The best
values are in bold.

##  5 Experimental Results

###  5.1 Experiments on English Datasets

The experimental results for English datasets are summarised in Table 2. We
repeated the experiment for each model and dataset five times, except for the
$T5$ model, since the models provided by HuggingFace are already trained on
the five tasks through multi-task training.

In general, the models are highly consistent in SIGNAL case but fall short of
expectation in REVERSE case. The only exceptions were $T5_{base}$ and
$T5_{large}$ model. On the contrary, humans achieved a high consistency level
on both REVERSE and SIGNAL, even though they showed a lower level of accuracy
than the models in several tasks. We observed that, although a model generates
a high consistency, it is not trustworthy provided the accuracy is
significantly low. For instance, $Electra_{small}$ model trained on the MRPC
dataset predicts all instances as ‘equivalent’. Despite 100% consistency, the
model is incapable of understanding language. We also describe several
examples of inconsistent predictions in Tables 3 and 4. More examples are
available in Tables 7, 8 and 9 in Appendix. Further detailed analyses of the
results apart from the $T5$ models are described below. The analysis on the
results of $T5$ model is provided separately in section 5.1.5 since they
exhibited entirely different results compared to the others.

####  5.1.1 Analysis on Task Types

For each model, we performed a t-test on the results according to the task
type, i.e. NLI and STS. For the REVERSE case, the consistency of STS tasks
outperformed that of NLI tasks under a significance level of 0.01. The margin
was considerable, and the consistency of STS tasks is almost close to the
human performance. A possible reason for these results is that the objective
of STS tasks is identifying whether two sentences with different wordings
convey the same meaning. Therefore, models trained on such tasks can capture
the intrinsic meaning of sentences better and thus, more robust to the
meaning-preserving perturbations. Our results are colinear with the work of
Elazar et al. (2021) that improved a model’s consistency by paraphrase data
augmentation.

For the SIGNAL case, however, the difference of consistency between NLI and
STS tasks was marginal. Instead, the number of training data played a more
important role in improving consistency. The consistency performance of the
RTE and MRPC tasks is worse than the others, and the difference was
statistically significant with a significance level of 0.01. From these
results, we gained an insight that STS tasks and the number of training data
are important contributing factors to the improvement of consistency.

####  5.1.2 Analysis on Consistency Types

We confirmed that all models exhibited consistent behaviours in SIGNAL case
(i.e. higher than 90%) and close to, or even better than human’s performance.
On the contrary, the consistency for REVERSE case is considerably lower than
that of the SIGNAL case in the majority of cases. The performance for the
REVERSE case shows a huge difference with that of humans. The results reveal
that the PLMs are sensitive to changes in the order of input sentences.

####  5.1.3 Analysis on Model Types

In our results, the encoder-based models (e.g. $RoBERTa$, $Electra$, $BART$,
$T5$) showed better consistency results in all tasks than the generative
decoder-based model (e.g. $GPT2$), based on the size of the $base$ model. This
implies that the bidirectional encoder & MLM objective are more effective than
the unidirectional decoder & general LM objective in terms of consistency,
which is limited to the classification task. Meanwhile, the T5 large model
showed the best consistency results for the REVERSE case in all tasks except
for a poorly trained case (i.e. $Electra_{small}$ \- MRPC task). We conjecture
a leading cause is that the $T5$ model used in our experiment was fine-tuned
with a multi-task including STS tasks, and this is the result of functioning
as paraphrase identification tasks.

Dataset | Type | Input sentence1 | Input sentence2 | Prediction
---|---|---|---|---
RTE | Original |  Sentence1: Microsoft was established in Italy in 1985. |  Sentence2: Microsoft was established in 1985. | entailment
Signal |  [Sentence1] Microsoft was established in Italy in 1985. |  [Sentence2] Microsoft was established in 1985. | not_entailment
MRPC | Original |  Sentence1: Spinnaker employs roughly 83 people ; NetApp employs 2,400. |  Sentence2: Spinnaker employs 83 people, most of whom are engineers. | equivalent
Reverse |  Sentence2: Spinnaker employs 83 people, most of whom are engineers. |  Sentence1: Spinnaker employs roughly 83 people ; NetApp employs 2,400. | not_equivalent
QNLI | Original |  Question: With what word was Tesla’s sociability described? |  Sentence: Tesla was asocial and prone to seclude himself with his work. | entailment
Reverse |  Sentence: Tesla was asocial and prone to seclude himself with his work. |  Question: With what word was Tesla’s sociability described? | not_entailment
Table 3: Examples of inconsistent predictions of $RoBERTa_{large}$ model.
Original Inputs: mrpc sentence1: "I felt that if I disagreed with Rosie too
much I would lose my job," she said. sentence2: Cavender did say : "I felt
that if I disagreed with Rosie too much I would lose my job.
---
Signal Inputs: mrpc [sentence1] "I felt that if I disagreed with Rosie too
much I would lose my job," she said. [sentence2] Cavender did say : "I felt
that if I disagreed with Rosie too much I would lose my job.
Original Prediction |  Signal Prediction
equivalent |  <extra_id_0>.[sentence1] [sentence2] [sent
Original Inputs: mrpc sentence1: The bishop told police he thought he had hit
a dog or a cat or that someone had thrown a rock at his vehicle. sentence2:
Bishop O ’Brien, aged 67, had told police he thought he had hit a dog or cat.
Signal Inputs: mrpc [sentence1] The bishop told police he thought he had hit a
dog or a cat or that someone had thrown a rock at his vehicle. [sentence2]
Bishop O ’Brien, aged 67, had told police he thought he had hit a dog or cat.
Original Prediction |  Signal Prediction
not_equivalent |  <extra_id_0>] [sentence2] [sentence3] [sentence
Original Inputs: mrpc sentence1: John Jacoby, the fire department’s battalion
chief, arrived. sentence2: Fire Chief John Jacoby arrived, joining Moriarty at
the top of the embankment.
Signal Inputs: mrpc [sentence1] John Jacoby, the fire department’s battalion
chief, arrived. [sentence2] Fire Chief John Jacoby arrived, joining Moriarty
at the top of the embankment.
Original Prediction |  Signal Prediction
not_equivalent |  <extra_id_0>, arrived.<extra_id_1>’s battalion chief
Table 4: Examples of inconsistent predictions of $T5_{large}$ model on the
Signal case of MRPC dataset. The changes made in Signal case inputs are in
orange.

####  5.1.4 Analysis on the Model-size

In the performance comparison of the $large$ model and the $base$ ($small$)
model, The large models significantly improved the accuracy in all tasks. They
also showed a tendency to increase overall consistency for tasks (MNI, QNLI,
QQP) with large data, but this varied depending on models since there were a
few cases of decreased consistency in the REVERSE case. In the other two tasks
(RTE, MRPC), rather, the smaller-sized model showed better consistency
performance. We conjecture that over-fitting is likely to occur when fine-
tuning a large model with small data, causing a decrease in generalisation
ability which makes a model generate incorrect predictions for the perturbed
inputs.

These results suggest that a model with high accuracy cannot always fully
understand the language, and raise the need to evaluate the model’s
performance from other lenses such as consistency.

####  5.1.5 Analysis on the T5 Models

Compared to other models that showed robust and high performance in the SIGNAL
case of all tasks, the performance of $T5$ models in the SIGNAL case falls
short of expectation; evaluation was performed with text generated by the $T5$
models. One of the strong reasons is that during the fine-tuning of the $T5$
model, the template of all training data contains the colon, which is the same
form with that of our original case, but does not include any brackets.
Therefore, our SIGNAL case inputs with brackets became a completely new
distribution to the model, and as a result, the desired results (label) were
not properly generated.Several generated examples of the $T5$ models are
provided in Table 4. More examples are available in Table 9 in Appendix.

Model | KorNLI | KLUE-NLI | KLUE-STS
---|---|---|---
$Acc_{val}$ | $C_{R}$ | $C_{S}$ | $Acc_{val}$ | $C_{R}$ | $C_{S}$ | $Acc_{val}$ | $C_{R}$ | $C_{S}$
$KoBERT$ | 85.6 | 55.2 | 96.4 | 75.7 | 50.1 | 94.4 | 79.2 | 92.3 | 94.2
$KoElectra$ | 86.3 | 53.5 | 98.0 | 78.6 | 56.3 | 96.3 | 72.8 | 93.5 | 97.0
$KoGPT2$ | 84.0 | 49.1 | 89.1 | 64.5 | 50.9 | 88.1 | 77.3 | 84.9 | 79.1
$KoBART$ | 85.2 | 54.6 | 97.4 | 71.5 | 53.9 | 93.1 | 76.9 | 86.1 | 97.3
Human | 87.3 | 94.0 | 96.0 | 86.0 | 98.0 | 98.0 | 88.0 | 100.0 | 100.0
Table 5: Results for the consistency evaluation on Korean datasets.
$Acc_{val}$ denotes an accuracy on the validation dataset. $C_{R}$ and $C_{S}$
stand for the consistency for REVERSE and SIGNAL cases, respectively. We
trained each model 5 times and recorded the average of each metric. The best
values are in bold.

###  5.2 Experiments on Korean Datasets

The experimental results for Korean datasets are provided in Table 5. It is
interesting that the results for Korean datasets exhibited a similar trend
with those for English datasets. The consistency of the SIGNAL case is
considerably higher than that of the REVERSE case. Also, models trained on STS
tasks recorded high consistency in both REVERSE and SIGNAL case, while those
trained on NLI tasks completely failed in REVERSE case. Finally, encoder-based
models, such as KoBERT and KoElectra, generally delivered higher consistency
than KoGPT2, which is a decoder-based model. The results indicate that the
inconsistency problem of PLMs is not to blame languages but the models
themselves.

Model | MNLI | QNLI | RTE
---|---|---|---
$Acc_{val}$ | $C_{R}$ | $C_{S}$ | $Acc_{val}$ | $C_{R}$ | $C_{S}$ | $Acc_{val}$ | $C_{R}$ | $C_{S}$
$RoBERTa_{base}{\text{-}}Single$ | 87.2 | 60.3 | 98.6 | 92.4 | 75.5 | 98.5 | 66.7 | 66.4 | 92.2
$RoBERTa_{base}{\text{-}}Para$ | 85.7 | 65.4 | 98.0 | 90.1 | 76.1 | 97.9 | 67.9 | 86.5 | 96.1
$RoBERTa_{base}{\text{-}}All$ | 85.6 | 66.7 | 97.9 | 90.4 | 72.9 | 98.2 | 72.9 | 89.0 | 96.9
$Electra_{large}{\text{-}}Single$ | 90.7 | 63.3 | 98.6 | 94.7 | 55.4 | 99.0 | 82.2 | 59.2 | 94.8
$Electra_{large}{\text{-}}Para$ | 90.6 | 65.2 | 98.1 | 94.3 | 58.7 | 98.6 | 81.6 | 71.0 | 93.1
$Electra_{large}{\text{-}}All$ | 90.6 | 66.0 | 98.1 | 94.6 | 55.8 | 98.5 | 86.3 | 77.8 | 97.7
$GPT2_{base}{\text{-}}Single$ | 80.4 | 44.0 | 92.2 | 87.4 | 48.9 | 94.1 | 61.0 | 62.5 | 83.4
$GPT2_{base}{\text{-}}Para$ | 77.3 | 54.1 | 92.8 | 85.6 | 58.4 | 93.6 | 63.5 | 65.9 | 90.1
$GPT2_{base}{\text{-}}All$ | 77.6 | 49.5 | 92.0 | 86.3 | 51.3 | 95.9 | 60.2 | 70.3 | 88.1
Table 6: Results for the consistency evaluation on multi-task training.
$Acc_{val}$ denotes an accuracy on the validation dataset. $C_{R}$ and $C_{S}$
stands for the consistency for REVERSE and SIGNAL cases, respectively. We
trained each model five times and recorded the average of each metric. The
best value is in bold.

##  6 Multi-task Training with STS task Improves Consistency

From the earlier experiments, we observed that models fine-tuned on STS tasks
exhibit high consistency. Also, $T5$ models, which are trained in multi-task
settings including STS tasks, are more consistent in REVERSE case, compared to
the single-task trained models. Based on these results, we made the following
assumption:

Assumption. Using STS tasks as an auxiliary training objective contributes to
the improvement of consistency.

We conduct an additional experiment to verify the aformentioned assumption.

###  6.1 Experimental Design

To train a model on multiple datasets simultaneously, we used the structure of
MT-DNN Liu et al. (2019), which shares the encoder but have individual
classifiers for each task. We train the following two variants.

##### Multitask-Para

A model is trained on three tasks: one for the main task (e.g. MNLI, QNLI, or
RTE), and the others for auxillary STS tasks (i.e. QQP and MRPC).

##### Multitask-All

A model is trained on all five tasks. We implement this variant as a control
group to check whether including none-STS datasets as auxiliary tasks could
also improve consistency.

As backbone model candidates, we select $RoBERTa_{base}$ and $Electra_{large}$
because $Electra_{small}$ is not trained well on MRPC dataset. We apply the
CALM framework to these models: first train the models under the original
input format and then measure consistency for the REVERSE and SIGNAL cases.
For training, we use the same training options described in section 4.3.

###  6.2 Results

The experimental results are summarised in Table 6. For all types of models,
accuracy and consistency of SIGNAL case in MNLI & QNLI tasks decreased
slightly compared to the original model ($Single$), but the differences were
marginal. Meanwhile, for the REVERSE case, multitask models ($Para$ & $ALL$)
showed significant improvement of consistency in all tasks by 13% on average.
In MNLI task, the multitask $ALL$ model of encoder-based models ($RoBERTa$,
$Electra$) showed higher consistency in REVERSE case than that of the $Para$
model, but there was no significant difference. Rather, in the decoder-based
model ($GPT2$), the $Para$ model showed the highest consistency in the REVERSE
case, showing a significant difference with the $ALL$ model. In the QNLI task,
the $PARA$ models showed a higher consistency improvement in the REVERSE case
than the $ALL$ models, regardless of the model type. These results indicate
that consistency can be improved regardless of the task type by only using the
STS tasks as the auxiliary training objective.

On the contrary, in the RTE task, as consistent with the results in MT-DNN Liu
et al. (2019), the accuracy of encoder-based models improved when the size of
the training data was small. Additionally, we confirmed that the consistency
for the REVERSE and SIGNAL cases also improved dramatically. Especially,
although both the accuracy and consistency performance of the $ALL$ models
were higher that those of the $Para$ models, even leveraging only paraphrase
data showed a significant improvement in the REVERSE case. In the decoder-
based model, the accuracy and consistency for the SIGNAL case of the $Para$
model were higher than the $All$ model, indicating that encoder-based and
decoder-based models certainly work differently.

Our work is distinguished from the previous studies Ribeiro et al. (2019);
Asai and Hajishirzi (2020); Elazar et al. (2021) for consistency improvement
in that there is no need for augmentation of customised data for a specific
task. We figured out that multitask learning with a well-known STS tasks can
improve consistency.

##  7 Summary and Outlook

Unsupervised pretraining and then fine-tuning framework has become a
predominant approach in NLP. The outstanding performance of PLMs on diverse
NLP tasks is indisputable. However, their language understanding ability is
questionable considering the evidence presented in many recent works.

Consistency is a highly desirable property that a good language understanding
model should possess to achieve human-level language understanding capability.
In this paper, we propose a simple framework named CALUM that measures
consistency by adding perturbations that preserve identical meaning. Through
experiments, we observed two important findings. First, PLMs exhibit
inconsistent behaviours, i.e., they are prone to make different decisions for
inputs conveying the same meaning. Second, we revealed that leveraging STS
tasks as an auxiliary training objective is of benefit to improve consistency.
Our findings suggest that focusing on semantic meaning could be a key for
training high-level language understanding models.

Although we confirmed the effect of leveraging STS tasks, it is still far from
reaching human-level consistency. In our experiments, we only used paraphrase
data for improving consistency. As future work, leveraging other meaning-
understanding datasets, such as negated sentences Kassner and Schütze (2020)
and word definition Senel and Schütze (2021), for better consistency would be
an interesting research direction.

## References

  * Asai and Hajishirzi (2020) Akari Asai and Hannaneh Hajishirzi. 2020.  Logic-guided data augmentation and regularization for consistent question answering.  In _Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics_ , pages 5642–5650, Online. Association for Computational Linguistics.
  * Bender and Koller (2020) Emily M. Bender and Alexander Koller. 2020.  Climbing towards NLU: On meaning, form, and understanding in the age of data.  In _Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics_ , pages 5185–5198, Online. Association for Computational Linguistics.
  * Brown et al. (2020a) Tom Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared D Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, Sandhini Agarwal, Ariel Herbert-Voss, Gretchen Krueger, Tom Henighan, Rewon Child, Aditya Ramesh, Daniel Ziegler, Jeffrey Wu, Clemens Winter, Chris Hesse, Mark Chen, Eric Sigler, Mateusz Litwin, Scott Gray, Benjamin Chess, Jack Clark, Christopher Berner, Sam McCandlish, Alec Radford, Ilya Sutskever, and Dario Amodei. 2020a.  Language models are few-shot learners.  In _Advances in Neural Information Processing Systems_ , volume 33, pages 1877–1901. Curran Associates, Inc.
  * Brown et al. (2020b) Tom B Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, et al. 2020b.  Language models are few-shot learners.  _arXiv preprint arXiv:2005.14165_.
  * 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 _Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics_ , pages 4157–4165, Online. Association for Computational Linguistics.
  * Candela-Quinonero et al. (2006) Joaquin Candela-Quinonero, Ido Dagan, Bernardo Magnini, and Florence d’Alché Buc. 2006.  Evaluating predictive uncertainty, visual objects classification and recognising textual entailment: selected proceedings of the first pascal machine learning challenges workshop.
  * Devlin et al. (2019) Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. 2019.  BERT: Pre-training of deep bidirectional transformers for language understanding.  In _Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long and Short Papers)_ , pages 4171–4186, Minneapolis, Minnesota. Association for Computational Linguistics.
  * Dolan and Brockett (2005) William B Dolan and Chris Brockett. 2005.  Automatically constructing a corpus of sentential paraphrases.  In _Proceedings of the Third International Workshop on Paraphrasing (IWP2005)_.
  * Elazar et al. (2021) Yanai Elazar, Nora Kassner, Shauli Ravfogel, Abhilasha Ravichander, Eduard Hovy, Hinrich Schütze, and Yoav Goldberg. 2021.  Measuring and improving consistency in pretrained language models.  _arXiv preprint arXiv:2102.01017_.
  * Ettinger (2020) Allyson Ettinger. 2020.  What bert is not: Lessons from a new suite of psycholinguistic diagnostics for language models.  _Transactions of the Association for Computational Linguistics_ , 8:34–48.
  * Garg and Ramakrishnan (2020) Siddhant Garg and Goutham Ramakrishnan. 2020.  BAE: BERT-based adversarial examples for text classification.  In _Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing (EMNLP)_ , pages 6174–6181, Online. Association for Computational Linguistics.
  * Habernal et al. (2018) Ivan Habernal, Henning Wachsmuth, Iryna Gurevych, and Benno Stein. 2018.  The argument reasoning comprehension task: Identification and reconstruction of implicit warrants.  In _Proceedings of the 2018 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long Papers)_ , pages 1930–1940, New Orleans, Louisiana. Association for Computational Linguistics.
  * Ham et al. (2020) Jiyeon Ham, Yo Joong Choe, Kyubyong Park, Ilji Choi, and Hyungjoon Soh. 2020.  Kornli and korsts: New benchmark datasets for korean natural language understanding.  _arXiv preprint arXiv:2004.03289_.
  * Hambardzumyan et al. (2021) Karen Hambardzumyan, Hrant Khachatrian, and Jonathan May. 2021.  Warp: Word-level adversarial reprogramming.  _arXiv preprint arXiv:2101.00121_.
  * Hofmann et al. (2021) Valentin Hofmann, Janet B Pierrehumbert, and Hinrich Schütze. 2021.  Superbizarre is not superb: Improving bert’s interpretations of complex words with derivational morphology.  _arXiv preprint arXiv:2101.00403_.
  * Hossain et al. (2020) Md Mosharaf Hossain, Venelin Kovatchev, Pranoy Dutta, Tiffany Kao, Elizabeth Wei, and Eduardo Blanco. 2020.  An analysis of natural language inference benchmarks through the lens of negation.  In _Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing (EMNLP)_ , pages 9106–9118, Online. Association for Computational Linguistics.
  * Hosseini et al. (2021) Arian Hosseini, Siva Reddy, Dzmitry Bahdanau, R Devon Hjelm, Alessandro Sordoni, and Aaron Courville. 2021.  Understanding by understanding not: Modeling negation in language models.  _arXiv preprint arXiv:2105.03519_.
  * Jin et al. (2020) Di Jin, Zhijing Jin, Joey Tianyi Zhou, and Peter Szolovits. 2020.  Is bert really robust? a strong baseline for natural language attack on text classification and entailment.  In _Proceedings of the AAAI conference on artificial intelligence_ , volume 34, pages 8018–8025.
  * Kassner et al. (2020) Nora Kassner, Benno Krojer, and Hinrich Schütze. 2020.  Are pretrained language models symbolic reasoners over knowledge? In _Proceedings of the 24th Conference on Computational Natural Language Learning_ , pages 552–564, Online. Association for Computational Linguistics.
  * Kassner and Schütze (2020) Nora Kassner and Hinrich Schütze. 2020.  Negated and misprimed probes for pretrained language models: Birds can talk, but cannot fly.  In _Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics_ , pages 7811–7818, Online. Association for Computational Linguistics.
  * Kryscinski et al. (2020) Wojciech Kryscinski, Bryan McCann, Caiming Xiong, and Richard Socher. 2020.  Evaluating the factual consistency of abstractive text summarization.  In _Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing (EMNLP)_ , pages 9332–9346, Online. Association for Computational Linguistics.
  * Lester et al. (2021) Brian Lester, Rami Al-Rfou, and Noah Constant. 2021.  The power of scale for parameter-efficient prompt tuning.  _arXiv preprint arXiv:2104.08691_.
  * Li et al. (2021) Dianqi Li, Yizhe Zhang, Hao Peng, Liqun Chen, Chris Brockett, Ming-Ting Sun, and Bill Dolan. 2021.  Contextualized perturbation for textual adversarial attack.  In _Proceedings of the 2021 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies_ , pages 5053–5069, Online. Association for Computational Linguistics.
  * Li et al. (2020a) Linyang Li, Ruotian Ma, Qipeng Guo, Xiangyang Xue, and Xipeng Qiu. 2020a.  BERT-ATTACK: Adversarial attack against BERT using BERT.  In _Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing (EMNLP)_ , pages 6193–6202, Online. Association for Computational Linguistics.
  * Li et al. (2020b) Margaret Li, Stephen Roller, Ilia Kulikov, Sean Welleck, Y-Lan Boureau, Kyunghyun Cho, and Jason Weston. 2020b.  Don’t say that! making inconsistent dialogue unlikely with unlikelihood training.  In _Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics_ , pages 4715–4728, Online. Association for Computational Linguistics.
  * Li and Liang (2021) Xiang Lisa Li and Percy Liang. 2021.  Prefix-tuning: Optimizing continuous prompts for generation.  _arXiv preprint arXiv:2101.00190_.
  * Lin et al. (2020) Bill Yuchen Lin, Seyeon Lee, Rahul Khanna, and Xiang Ren. 2020.  Birds have four legs?! NumerSense: Probing Numerical Commonsense Knowledge of Pre-Trained Language Models.  In _Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing (EMNLP)_ , pages 6862–6868, Online. Association for Computational Linguistics.
  * Liu et al. (2019) Xiaodong Liu, Pengcheng He, Weizhu Chen, and Jianfeng Gao. 2019.  Multi-task deep neural networks for natural language understanding.  In _Proceedings of the 57th Annual Meeting of the Association for Computational Linguistics_ , pages 4487–4496, Florence, Italy. Association for Computational Linguistics.
  * Loshchilov and Hutter (2017) I. Loshchilov and F. Hutter. 2017.  Fixing weight decay regularization in adam.  _ArXiv_ , abs/1711.05101.
  * McCoy et al. (2019) Tom McCoy, Ellie Pavlick, and Tal Linzen. 2019.  Right for the wrong reasons: Diagnosing syntactic heuristics in natural language inference.  In _Proceedings of the 57th Annual Meeting of the Association for Computational Linguistics_ , pages 3428–3448, Florence, Italy. Association for Computational Linguistics.
  * Morris et al. (2020) John Morris, Eli Lifland, Jin Yong Yoo, Jake Grigsby, Di Jin, and Yanjun Qi. 2020\.  TextAttack: A framework for adversarial attacks, data augmentation, and adversarial training in NLP.  In _Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing: System Demonstrations_ , pages 119–126, Online. Association for Computational Linguistics.
  * Naik et al. (2018) Aakanksha Naik, Abhilasha Ravichander, Norman Sadeh, Carolyn Rose, and Graham Neubig. 2018.  Stress test evaluation for natural language inference.  In _Proceedings of the 27th International Conference on Computational Linguistics_ , pages 2340–2353, Santa Fe, New Mexico, USA. Association for Computational Linguistics.
  * Niven and Kao (2019) Timothy Niven and Hung-Yu Kao. 2019.  Probing neural network comprehension of natural language arguments.  In _Proceedings of the 57th Annual Meeting of the Association for Computational Linguistics_ , pages 4658–4664, Florence, Italy. Association for Computational Linguistics.
  * Ohsugi et al. (2019) Yasuhito Ohsugi, Itsumi Saito, Kyosuke Nishida, Hisako Asano, and Junji Tomita. 2019\.  A simple but effective method to incorporate multi-turn context with bert for conversational machine comprehension.  In _Proceedings of the First Workshop on NLP for Conversational AI_ , pages 11–17.
  * Park et al. (2021) Sungjoon Park, Jihyung Moon, Sungdong Kim, Won Ik Cho, Jiyoon Han, Jangwon Park, Chisung Song, Junseong Kim, Yongsook Song, Taehwan Oh, et al. 2021.  Klue: Korean language understanding evaluation.  _arXiv preprint arXiv:2105.09680_.
  * Qiu et al. (2020) Xipeng Qiu, Tianxiang Sun, Yige Xu, Yunfan Shao, Ning Dai, and Xuanjing Huang. 2020\.  Pre-trained models for natural language processing: A survey.  _Science China Technological Sciences_ , pages 1–26.
  * Radford et al. (2019) Alec Radford, Jeffrey Wu, Rewon Child, David Luan, Dario Amodei, Ilya Sutskever, et al. 2019.  Language models are unsupervised multitask learners.  _OpenAI blog_ , 1(8):9.
  * Rajpurkar et al. (2016) Pranav Rajpurkar, Jian Zhang, Konstantin Lopyrev, and Percy Liang. 2016.  SQuAD: 100,000+ questions for machine comprehension of text.  In _Proceedings of the 2016 Conference on Empirical Methods in Natural Language Processing_ , pages 2383–2392, Austin, Texas. Association for Computational Linguistics.
  * Ravichander et al. (2020) Abhilasha Ravichander, Eduard Hovy, Kaheer Suleman, Adam Trischler, and Jackie Chi Kit Cheung. 2020.  On the systematicity of probing contextualized word representations: The case of hypernymy in BERT.  In _Proceedings of the Ninth Joint Conference on Lexical and Computational Semantics_ , pages 88–102, Barcelona, Spain (Online). Association for Computational Linguistics.
  * Reynolds and McDonell (2021) Laria Reynolds and Kyle McDonell. 2021.  Prompt programming for large language models: Beyond the few-shot paradigm.  In _Extended Abstracts of the 2021 CHI Conference on Human Factors in Computing Systems_ , pages 1–7.
  * Ribeiro et al. (2019) Marco Tulio Ribeiro, Carlos Guestrin, and Sameer Singh. 2019.  Are red roses red? evaluating consistency of question-answering models.  In _Proceedings of the 57th Annual Meeting of the Association for Computational Linguistics_ , pages 6174–6184, Florence, Italy. Association for Computational Linguistics.
  * Ribeiro et al. (2020) Marco Tulio Ribeiro, Tongshuang Wu, Carlos Guestrin, and Sameer Singh. 2020.  Beyond accuracy: Behavioral testing of NLP models with CheckList.  In _Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics_ , pages 4902–4912, Online. Association for Computational Linguistics.
  * Senel and Schütze (2021) Lutfi Kerem Senel and Hinrich Schütze. 2021.  Does he wink or does he nod? a challenging benchmark for evaluating word understanding of language models.  _arXiv preprint arXiv:2102.03596_.
  * Shin et al. (2020) Taylor Shin, Yasaman Razeghi, Robert L Logan IV, Eric Wallace, and Sameer Singh. 2020.  Autoprompt: Eliciting knowledge from language models with automatically generated prompts.  _arXiv preprint arXiv:2010.15980_.
  * Wang et al. (2019) Alex Wang, Amanpreet Singh, Julian Michael, Felix Hill, Omer Levy, and Samuel R. Bowman. 2019.  GLUE: A multi-task benchmark and analysis platform for natural language understanding.  In _International Conference on Learning Representations_.
  * Welleck et al. (2019) Sean Welleck, Ilia Kulikov, Stephen Roller, Emily Dinan, Kyunghyun Cho, and Jason Weston. 2019.  Neural text generation with unlikelihood training.  _arXiv preprint arXiv:1908.04319_.
  * Williams et al. (2018) Adina Williams, Nikita Nangia, and Samuel Bowman. 2018.  A broad-coverage challenge corpus for sentence understanding through inference.  In _Proceedings of the 2018 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long Papers)_ , pages 1112–1122, New Orleans, Louisiana. Association for Computational Linguistics.
  * Wolf et al. (2020) Thomas Wolf, Julien Chaumond, Lysandre Debut, Victor Sanh, Clement Delangue, Anthony Moi, Pierric Cistac, Morgan Funtowicz, Joe Davison, Sam Shleifer, et al. 2020.  Transformers: State-of-the-art natural language processing.  In _Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing: System Demonstrations_ , pages 38–45.

##  Appendix A Appendix

###  A.1 Hyper Parameter Search

Based on the work of Devlin et al. (2019), we investigated the following range
of possible values to decide the hyperparameters for fine-tuning:

  * •

Batch size: 32, 64, 128

  * •

Learning rate: 5e-4, 1e-5, 5e-6,

Datasets with a large amount of training data, e.g. MNLI and QQP, were not
sensitive to the hyperparameter values. Therefore, we selected hyperparameter
values that generally performs well on small-sized datasets for all models.

Dataset | Type | Input sentence1 | Input sentence2 | Prediction
---|---|---|---|---
RTE | Original |  Sentence1: These folk art traditions have been preserved for hundreds of years. |  Sentence2: Indigenous folk art is preserved. | entailment
Signal |  [Sentence1] These folk art traditions have been preserved for hundreds of years. |  [Sentence2] Indigenous folk art is preserved. | not_entailment
MRPC | Original |  Sentence1: The initial report was made to Modesto Police December 28. |  Sentence2: It stems from a Modesto police report. | equivalent
Reverse |  Sentence2: It stems from a Modesto police report. |  Sentence1: The initial report was made to Modesto Police December 28. |  not_equivalent
QNLI | Original |  Question: What is essential for the successful execution of a project? |  Sentence: For the successful execution of a project, effective planning is essential. | entailment
Reverse |  Sentence: For the successful execution of a project, effective planning is essential. |  Question: What is essential for the successful execution of a project? | not_entailment
Table 7: Examples of inconsistent predictions of $Electra_{large}$ model. Dataset | Type | Input sentence1 | Input sentence2 | Prediction
---|---|---|---|---
RTE | Original |  Sentence1: In 1900 Berlin’s arterial roads ran across Potsdam Square - Potsdamer Platz. |  Sentence2: Postdam Square is located in Berlin. | not_entailment
Reverse |  Sentence2: Postdam Square is located in Berlin. |  Sentence1: In 1900 Berlin’s arterial roads ran across Potsdam Square - Potsdamer Platz. | entailment
MRPC | Original |  Sentence1: The study is being published today in the journal Science. |  Sentence2: Their findings were published today in Science. | equivalent
Signal |  [Sentence1] The study is being published today in the journal Science. |  [Sentence2] Their findings were published today in Science. |  <extra_id_0>…
QNLI | Original |  Question: What fueled Luther’s concept of Christ and His Salvation? |  Sentence: His railing against the sale of indulgences was based on it. | not_entailment
Signal |  [Question] What fueled Luther’s concept of Christ and His Salvation? |  [Sentence] His railing against the sale of indulgences was based on it. | entailment
Table 8: Examples of inconsistent predictions of $T5_{large}$ model. The
generated output of SIGNAL case in MRPC dataset is
‘<extra_id_0>1]<extra_id_1>. [sentence3] The study is being". Original Inputs:
rte sentence1: At least 50 animals died in a late December avalanche.
sentence2: Humans died in an avalanche.
---
Original Inputs: rte [sentence1] At least 50 animals died in a late December
avalanche. [sentence2] Humans died in an avalanche.
Original Prediction |  Signal Prediction
not_entailment |  <extra_id_0> <extra_id_1> [sentence1] At least 50 animals died in an
Original Inputs: rte sentence1: Microsoft denies that it holds a monopoly.
sentence2: Microsoft holds a monopoly power.
Signal Inputs: rte [sentence1] icrosoft denies that it holds a monopoly.
[sentence2] Microsoft holds a monopoly power.
Original Prediction |  Signal Prediction
not_entailment |  [sentence1] Microsoft denies that it holds a monopol
Original Inputs: rte sentence1: An earthquake has hit the east coast of
Hokkaido, Japan, with a magnitude of 7.0 Mw. sentence2: An earthquake occurred
on the east coast of Hokkaido, Japan.
Signal Inputs: rte [sentence1] An earthquake has hit the east coast of
Hokkaido, Japan, with a magnitude of 7.0 Mw. [sentence2] An earthquake
occurred on the east coast of Hokkaido, Japan.
Original Prediction |  Signal Prediction
entailment |  <extra_id_0>e<extra_id_1>e [sentence2] An earthquake has hit the east
Table 9: More examples of inconsistent predictions of $T5_{base}$ model on the
Signal case of RTE dataset. The changes made in Signal case inputs are in
orange.