SlowGuess/NAACL_2021_OCR huggingface dataset:
Sarik Ghazarian, $^{1}$  Zixi Liu, $^{1}$  Akash SM, $^{2}$
Ralph Weischedel, $^{1}$  Aram Galstyan, $^{1}$  Nanyun Peng $^{1,3}$
<sup>1</sup>University of Southern California / Information Sciences Institute
$^{2}$ Indian Institute of Technology Roorkee
<sup>3</sup>Computer Science Department of University of California, Los Angeles {sarik, zixiliu, weisched, galstyan} @isi.edu, akashsm@ce.iitr.ac.in, violetpeng@cs.ucla.edu
With the recent advances of open-domain story generation, the lack of reliable automatic evaluation metrics becomes an increasingly imperative issue that hinders the fast development of story generation. According to conducted researches in this regard, learnable evaluation metrics have promised more accurate assessments by having higher correlations with human judgments. A critical bottleneck of obtaining a reliable learnable evaluation metric is the lack of high-quality training data for classifiers to efficiently distinguish plausible and implausible machine-generated stories. Previous works relied on heuristically manipulated plausible examples to mimic possible system drawbacks such as repetition, contradiction, or irrelevant content in the text level, which can be unnatural and oversimplify the characteristics of implausible machine-generated stories. We propose to tackle these issues by generating a more comprehensive set of implausible stories using plots, which are structured representations of controllable factors used to generate stories. Since these plots are compact and structured, it is easier to manipulate them to generate text with targeted undesirable properties, while at the same time maintain the grammatical correctness and naturalness of the generated sentences. To improve the quality of generated implausible stories, we further apply the adversarial filtering procedure presented by Zellers et al. (2018) to select a more nuanced set of implausible texts. Experiments show that the evaluation metrics trained on our generated data result in more reliable automatic assessments that correlate remarkably better with human judgments compared to the baselines.
The surge of downstream applications for open-domain natural language generation (NLG), such as dialog systems (Zhang et al., 2020) and story
Human Written Story: jenny liked fresh fish. she decided to go fishing to catch her own. she brought her worms and pole and a chair. she sat there all day but didn't catch anything. she packed it up and went home disappointed.
Sentence Manipulation: jenny liked fresh fish. she decided to go fishing to catch her own. she wrote songs every single day. she sat there all day but didn't catch anything. she packed it up and went home disappointed.
Keyword Manipulation: jenny liked fresh fish. she decided to go fishing to catch her own. she brought her worms and pole and a chair. she sat there all day but didn't catch anything. she unpacked it up and went home disappointed.
UNION: jenny liked fresh fish. jim has a very structured workout program to help him achieve goals. she brought her worms and pole and a relaxer. she sat there all day but didn't catch anything. she unpack it up and went home disappointed.
Plot: jenny fresh fish -> decided
fishing catch -> brought worms chair
-> sat -> packed home disappointed	Manipulated Plot: jenny fresh fish -> tasha offered woman store -> brought worms chair -> sat -> got wet packed home disappointed
Manipulated Plot Guided Generation (Ours): jenny was out of fresh fish. tasha offered to buy her some from the woman at the store. she brought her worms and a chair and decided to play with them. jenny sat down and laid down on the chair. when she got wet, she packed up and went home disappointed.
Figure 1: Heuristically generated implausible stories (the second block) for a given human-written story (the first block) using sentence, keyword and UNION manipulations versus injecting implausible sources into the story plot (the third block, from the left plot to the right one) and generating a more natural implausible story (the last story). Blue highlights show the implausible sections.
generators (Rashkin et al., 2020a) necessitates automatic evaluation metrics for quality assessment. The existence of accurate automatic evaluation metrics can accelerate the development cycle by facilitating the process of model comparison and hyperparameter search. Many existing reference-based approaches such as BLEU (Papineni et al., 2002) or ROUGE (Lin, 2004) fail to correlate well with human judgment in open-domain settings due to the fact that there can be potentially many plausible generations that do not have significant overlap with the limited set of given references. This failure invites research on more sophisticated and reliable evaluation metrics.
Recently, learning-based approaches have been proposed to overcome this limitation by training classifiers to distinguish between plausible and implausible texts (Li and Jurafsky, 2016; Holtzman et al., 2018). The choice of training data for learning such classifiers is a key determinant of the metric effectiveness. Existing works take human-written texts as plausible (positive) examples, while
Proceedings of the 2021 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, pages 4334-4344 June 6-11, 2021. ©2021 Association for Computational Linguistics
the negative samples are heuristically generated by randomly substituting keywords or sentences (See Figure 1) (Li and Jurafsky, 2016; Guan and Huang, 2020). Guan and Huang (2020) further improved the quality of evaluators by applying heuristic rules such as adding repetition, reordering and negation (See the UNION story in Figure 1).
In this work, we hypothesize that heuristically generated data cannot adequately reflect the characteristics of the implausible texts generated by language models, thus result in suboptimal trained evaluation metrics. This deficiency can be mitigated by generating high-quality implausible examples that are closer to the test data. Toward this goal, we propose an approach based on the manipulation of plots, which are high-level structured representations of generated texts originally used as a content-planning tool for better text generation (Fan et al., 2019; Goldfarb-Tarrant et al., 2020). Specifically, we propose to manipulate plots by injecting incoherence sources into them. The generation models conditioned on such manipulated plots lead to implausible texts that have pertinent similarities with implausible machine-generated texts and thus can serve as good negative examples for training evaluation metrics.
We further improve the quality of training data by incorporating the adversarial filtering technique proposed by Zellers et al. (2018) to select more challenging negative samples generated from the manipulated plots (See Figure 1). Eventually, these samples result in more reliable evaluation metrics. The contributions of this work are four-fold:
- We study the importance of training data for learnable automatic evaluation metrics in open-domain story generation task and show the inadequacy of heuristically generated negative examples in this setting.
- We propose a novel technique to generate negative samples by introducing plot-level incoherence sources that guide generation models to produce implausible texts.
- We show the affirmative role of adversarial filtering techniques in constructing training data for learnable open-domain story generation evaluation metrics.
- We demonstrate that the evaluation metrics trained on our generated data have a significantly higher correlation with human judgments compared to strong baselines.
Existing work on automatic evaluation of generation models can be classified into two subgroups, non-learning-based and learning-based methods, which we briefly summarize below.
Non-learning-based Metrics. Some metrics in this group consider the centrality of a text around a specific topic as a proxy for measuring its quality. The transitions of entities in neighbor sentences and their distribution across text have been served as a measurement for quality assessment (Miltsakaki and Kukich, 2004; Lapata and Barzilay, 2005). Perplexity is another commonly used metric to evaluate the quality of text and story generation models (Fan et al., 2018; Peng et al., 2018).
Learning-based Metrics. This group of metrics is based on neural-based classifiers trained on a set of positive (plausible) and negative (implausible) texts. The common point between these metrics is using random sentence substitution to construct training examples, while the architectures are slightly different. Li and Jurafsky (2016) trained a neural network with a sigmoid function on top of sentence embeddings extracted from LSTM. Lai and Tetreault (2018) designed SENTAVG that gets the sentence vectors from LSTM, takes the average of these vectors to represent the whole text, and then passes it through a hidden layer.
Recently, Guan and Huang (2020) proposed a more accurate automatic evaluation metric called UNION. This metric achieved better performance by using BERT (Devlin et al., 2019) as a more effective classification model and have a broader set of negative samples coming from different heuristics. For all learning-based metrics, the simplicity of heuristically generated data samples makes them inadequate for an accurate evaluation of plausibility in open-domain generated texts.
3 Implausible Text Construction
We formulate the evaluation of open-domain story generation as a binary classification task where the goal is to distinguish plausible and implausible generated stories, also referred to as positive and negative examples. Clearly, the availability of high-quality positive and negative examples is essential for training reliable and generalizable metrics. While human-generated stories can be considered as positive examples, what constitutes good negative examples is a non-trivial question. Specifically, consider a hypothetical decision boundary
that separates positive and negative stories. While any point on one side of the boundary will be a negative example, intuitively we want examples that are not too far away from that boundary. To achieve this, we will start from positive examples, and modify them in a controllable manner to generate corresponding negative samples.
3.1 Heuristic Negative Samples
There are some widely-used approaches to heuristically manipulate positive examples and change their structure to generate negative examples.
Sentence Substitution. Sentence substitution (briefly HEUR_SENT_SUB) replaces a fraction of sentences in the plausible text with random ones (See Figure 1). This breaks the discourse-level coherence, making a story not interpretable (Li and Jurafsky, 2016; Holtzman et al., 2018).
Keyword Substitution. Guan and Huang (2020) proposed to apply random substitutions at the keyword-level (briefly HEUR_KEY_SUB), where a fraction of keywords are randomly substituted with their corresponding antonyms from a commonsense knowledge base such as ConceptNet (Speer and Havasi, 2012) to corrupt the plausibility in the text. ConceptNet consists of (object, relation, subject) triplets. For each selected keyword that exists as an object or subject in the ConceptNet, its counterpart is extracted from one of the contradiction-type relations; Antonym, NotDesires, NotCapableOf, or NotHasProperty. For instance, packed word in the second example of the implausible text in Figure 1 is substituted by its antonym unpacked.
UNION Manipulations. Alongside the keyword and sentence substitutions, Guan and Huang (2020) proposed to use repetition, reordering, and negation techniques to generate a more complete and nuanced set of implausible examples. The sentences and keywords are repeated throughout the text to reflect the repetition issue of language models. The order of sentences is changed and negation words are added to make texts implausible due to wrong causal dependencies and conflicted logic. They simultaneously apply some of these techniques to human-written texts to construct negative examples (See third negative story in Figure 1). We refer to this data as UNION_DATA. Despite the demonstrated effectiveness of UNION_DATA in open-domain story evaluation, heuristically constructed negative samples are quite far from machine
generated texts, and thus inadequate to represent a broad set of machine-generated implausible texts.
3.2 Proposed Approach
As we stated above, applying heuristic rules at the utterance level result in negative examples that are usually unnatural and do not reflect the complex characteristics of machine-generated texts. Instead, we propose to introduce perturbations at a more abstract plot level. Namely, we seek to improve the quality of negative samples using plot-controlled generation with adversarial filtering techniques.
3.2.1 Plot Manipulations
Studies have shown that high-quality fluent stories can be generated by planning in advance and leveraging lucrative plots (Yao et al., 2019; Fan et al., 2019; Goldfarb-Tarrant et al., 2019, 2020; Rashkin et al., 2020b; Brahman et al., 2020). Yao et al. (2019) leverage a sequence of keywords as the plot representation (also called storyline). Fan et al. (2019) use semantic role labeling tool to extract plots as abstract presentation of stories over actions and entities. Their experiments affirm that plots have positive effects on generating high-quality stories.
Here we leverage this idea for generating implausible texts, by controllable injection of implausibility sources, or perturbations, into the ground-truth plots. The resulting plot-level manipulations will force the model to reflect applied implausibility in the generated text and will negatively impact the text's plausibility. In contrast to Guan and Huang (2020), our proposed plot-level manipulations (MANPLTS) do not directly change the text at the token level instead, we inject incoherence into language at the concept level. The plot-guided generation guarantees the naturalness of generations since it leverages a well-trained conditional language model. The generated samples are also anticipated to be closer and congruous to the machine-generated texts that will be assessed during the inference time. Concept-level incoherence creates implausible factors that guide models to include that implausible sources. Figure 2 demonstrates various proposed plot-level manipulations in dotted boxes. $^{1}$  All proposed manipulations are described in the following sections. We refer this data as ManPlts.
<sup>1</sup>Our proposed data, trained models and code is released at https://github.com/PlusLabNLP/Plot-guided-Coherence-Evaluation
Figure 2: The plot-level manipulations applied to a human-written story's plot (presented in the black box) to create an implausible story. Each dotted box with a specific color shows a distinct manipulation technique. The manipulated plots are passed through a generation model to generate implausible samples for the evaluation task.
Non-logically Ordered Plots. Logical conflict is one of the sources for implausibility that results from not-logically ordered concepts in the text. While Guan and Huang (2020) covered this type of implausibility by changing the order of sentences, we hypothesize that disrupting the logical order at the concept-level is more efficient. To accomplish concept reordering, we first randomly choose verbs from the plot and leverage the COMET (Bosselut et al., 2019) model to predict their subsequent events. Then we dislocate the resulted concept pairs. COMET, which is trained on tuples of the form (subject, relation, object), can be used to predict an object given a pair of subject and relation. As an example, given the pair (work, causes) COMET will predict get pay to show that work causes to get paid. We focus on COMET relations HasPrerequisite, HasFirstSubevent, Causes and HasLastSubevent that imply ordering. In the first two relations, object should appear before subject, while in the other two the order is reversed. Therefore, subject work comes before get pay due to the causes relation that holds between them. We flip the correct order of concepts and attach them with or without randomly selected connection words such as then, later, subsequently to generate implausible texts (the purple box in Figure 2).
Contradiction Insertion. The plausibility of a text is supported in part by the logical and correct
relationship between its words. It can be harmed by accompanying words with their antonyms or other conflicting concepts that add contradiction to the text and make it hard to grasp. In order to add such kind of implausibility, we propose to insert contradictory sources of randomly selected plots in consecutive positions. For each selected plot, we use ConceptNet (Speer and Havasi, 2012) to extract concepts that hold negation relations such as Antonym, NotDesires, NotCapableOf, and NotHasProperty with it and insert them as neighbor plots. In the navy blue box of Figure 2, purse has been added before wallet as its antonym. This guides the generation model to include consecutive contradictory elements in the generated text that harms the coherence of sections and makes it difficult to interpret.
Repetition Insertion. Repetition is one of the common issues that many generative models suffer from. Recently proposed top-k (Fan et al., 2018) and top-p (Holtzman et al., 2020) sampling techniques partially mitigated but not completely solved this issue. Guan and Huang (2020) proposed to replicate this problem in negative implausible text construction by repeating N-grams in consecutive positions. These heuristically constructed outputs only mirror local repetition issues, while the state-of-the-art generative models produce more complex and subtle repetitions throughout the whole text.
Manipulated Plots	Manipulation Type	Generated Implausible Stories
1. waiting airport cousin jimmie	Random_Subs.	1. tobias was waiting at the airport to see his cousin jimmie.
2. ended practiced month	Repetition	2. although his parents ended up being unwanted, he practiced with his dad every day for a month.
3. ended unwanted wanted parents proud	Contr INSERT.	3. his parents ended up being unwanted, but he really wanted to make his parents proud.
4. ended losing	-	4. he ended up losing to his cousin jimmie because he didn't practice enough.
5. parents ended proud	-	5. but his parents ended up being proud of him anyway.
1. finished friend turned assign-ment	Repetition	1. i finished my job , and my friend and i turned in our homework assignment.
2. friend	-	2. my friend and i went to the mall.
3. vendors games rides	Random_Subs.	3. we went to vendors, played many games, and had rides.
4. turned	-	4. when we got home, i turned in the assignment.
5. went to class later teacher called home office	Logic_Reorder. Contr Insert.	5. when we went to class later teacher called us home from the office.
1. made gina nervous perform	Random_Subs.	1. gina's mom made gina get nervous about having to perform.
2. pained ended scared missing	Repetition Logic_Reorder.	2. she was pained that she ended up scared of missing her bus
3. bus scared allie	Repetition	3. she was on the bus and scared of allie.
4. one	-	4. no one was on the bus and she didn't know where they were.
5. allie scared	Repetition	5. therefore gina and allie were too scared to ride on the bus together.
1. billy noticed billy	Repetition	1. billy noticed that his buddy billy was out of gas.
2. grandpa loved recall	Random_Subs.	2. billy's grandpa had just loved to recall a car recall he didn't want to recall.
3. billy finished filling drove	Repetition	3. billy got in his car, finished filling it up, and drove away.
4. unsuddenly suddenly	Contr INSERT.	4. suddenly, suddenly, suddenly, billy's car was out of gas.
5. billy noticed billy driven	Repetition	5. billy noticed later that billy had driven off with that car recall.
Table 1: Examples of implausible stories generated based on manipulated plots. Bold italic keywords represent manipulated plots resulted from different proposed manipulations shown in the middle column.
We propose to repeat random plots of each text in various positions that would force the language model to duplicate them throughout the text and exhibit more realistic machine-generated repetitive examples. In Figure 2, the repetition of floor and jake decided compels the model to generate boring and repetitive sentences.
Random Substitution. Random sentence substitutions employed by many evaluation models amplify the implausibility sources in the text by inserting completely off-topic sentences that could potentially result in topical inconsistency throughout the text. Such scenarios are less likely for state-of-the-art high-quality generation models that use encoded context to generate tokens.
Once again, we propose to do the replacement at the plot level. Within our approach, even though the inserted random plots are completely irrelevant, the model would attempt to incorporate them into the text as much as possible by using encoded context sentences. This can be seen in the third sentence of Figure 2. Even if this sentence's plots are randomly inserted, the model is able to generate a sentence that does not have significant topical
inconsistency, thanks to the contextualized nature of the generative process.
Table 1 depicts four different machine-generated stories, each containing five sentences that are conditioned on the manipulated plots. Bold italic keywords represent manipulated plots resulted from the proposed approaches shown in the middle column.
3.2.2 Adversarial Filtering
Adversarial filtering (AF) technique was originally proposed to generate high-quality negative examples for a grounded commonsense inference task (Zellers et al., 2018). AF uses a committee of trained models to identify more appropriate negative endings from a pool of candidate samples generated for a given context. For each human-written text, there are  $N$  machine-generated endings. The goal is to select the most unbiased subset  $(A)$  of generated endings with similar stylistic features to the human-written ones.
AF starts by randomly specifying the best endings in the assignment set  $(A)$  from all  $N$  endings of each context (Zellers et al., 2018). In each iteration, the data is divided into two parts. The first part is
used for training a classifier to distinguish high/low quality endings, and the second part is used for replacing easy endings in  $A$  with adversarial endings from  $N$ . Easy endings are the ones that a trained classifier assigns a much lower score compared to human-written texts, e.g., due to their significantly different writing styles. Adversarial texts have a higher positive probability than easy texts indicating the challenge for a classifier to distinguish them from human-written texts. The replacement of easy texts with adversarial ones maximizes the empirical error of the trainable classifier. The steps outlined above are repeated till the assignment set is filled with high-quality endings for each context.
We use AF on top of the plot-based manipulations for generating implausible texts (briefly call AF_MANPLTS). Our approach for negative texts construction has two main stages: 1) generate a set of  $N$  implausible texts conditioned on manipulated plots 2) pick out the  $A$  most challenging high-quality implausible texts without stylistic biases based on applied adversarial filtering technique to increase the quality of negative samples.
4 Learnable Evaluation Models
We assess the plausibility of a text by training a classification model on the data that consists of human-written texts (positive examples) and constructed implausible stories (negative examples). Binary classifiers trained on this data can produce the probability of plausible/implausible labels for each text. The predicted probability of the positive class is interpreted as the text's plausibility score.
4.1 Fine-tuning Language Models