SlowGuess/NAACL_2021_OCR huggingface dataset:
Rowan Zellers\* Ari Holtzman\* Elizabeth Clark\*
Lianhui Qin\* Ali Farhadi\* Yejin Choi
$^{\star}$ Paul G. Allen School of Computer Science & Engineering, University of Washington
$^{\diamond}$ Allen Institute for Artificial Intelligence
rowanzellers.com/advice
We propose TURINGADVICE, a new challenge task and dataset for language understanding models. Given a written situation that a real person is currently facing, a model must generate helpful advice in natural language. Our evaluation framework tests a fundamental aspect of human language understanding: our ability to use language to resolve open-ended situations by communicating with each other.
Empirical results show that today's models struggle at TURINGADVICE, even multibillion parameter models finetuned on 600k in-domain training examples. The best model, a finetuned T5, writes advice that is at least as helpful as human-written advice in only  $14\%$  of cases; a much larger non-finetunable GPT3 model does even worse at  $4\%$ . This low performance reveals language understanding errors that are hard to spot outside of a generative setting, showing much room for progress.
Language models today are getting ever-larger, and are being trained on ever-increasing quantities of text. For an immense compute cost, these models like T5 (Raffel et al., 2019) and GPT3 (Brown et al., 2020) show gains on a variety of standard NLP benchmarks – often even outperforming humans.
Yet, when a giant model like T5 generates language, we observe clear gaps between machine-level and human-level language understanding - even after it has been finetuned for the task at hand. Consider Figure 1, in which a woman asks for advice. She is assigned to dissect an animal for her class project, but has extreme anxiety about dead animals - and her teacher refused to give her another assignment. Humans can respond with helpful advice, reflecting our unique ability of real-world language use: to communicate and tackle open-ended issues. The helpful advice in this ex
Figure 1: TURINGADVICE. Humans are natural experts at using language to successfully address situations that arise, such as giving advice. We introduce a new framework, dataset, and leaderboard to generatively evaluate real-world language use. Today's most powerful models - which obtain near-human or superhuman performance on core NLP benchmarks for reading comprehension, natural language inference, and commonsense reasoning - struggle with all of these capabilities when generating advice, as highlighted in red.
ample - but not the only one possible - suggests that she send a short email to her guidance counselor.
On the other hand, not only is T5's advice unhelpful, it also reveals key misunderstandings of the situation. It seems to believe that the student is asking the teacher to do a class project involving dead animals. This reading comprehension error is particularly strange, as T5 outperforms humans on a variety of reading comprehension benchmarks. Others in the community have observed similar issues, raising concerns about what today's benchmark datasets measure (Yogatama et al., 2019; Kryscinski et al., 2019; McClelland
Association for Computational Linguistics: Human Language Technologies, pages 4856-4880
et al., 2019; Gardner et al., 2019).
We argue that there is a deep underlying issue: a gap between how humans use language in the real world, and what benchmarks today can measure. Today's dominant paradigm is to study static datasets, and to grade machines by the similarity of their output with predefined correct answers. For example, we score multiple choice exams by how often the correct answers are chosen, and evaluate generative tasks like machine translation by similarity with respect to correct translations. However, when we use language in the real world to communicate with each other – such as when we give advice, or teach a concept to someone – there is rarely a universal correct answer to compare with, just a loose goal we want to achieve.
We introduce a framework to narrow this gap between benchmarks and real-world language use. We propose to evaluate machines by their success in using language to (1) communicate with humans in (2) tackling complex, open-ended, real-world situations. Our goal is a machine that, like a human, can generate language that is useful and helpful. Doing so necessarily requires a deep understanding of language and the world, as per a line of thought that the complete meaning representation is one that suffices to complete a task (Artzi et al., 2013).
As a case-study of our framework, we introduce TURINGADVICE as a new grand challenge for AI systems. A machine reads a situation written by a person seeking advice, like Figure 1, and must then write advice that is helpful to the advice-seeker. Like a Turing Test (Turing, 1950), we establish a simple condition required for a model to 'pass': model-generated advice must be at least as helpful to the advice-seeker as human-written advice.
We make our challenge concrete by introducing a new dataset, REDDITADVICE, and accompanying leaderboard. We tie our dataset to the Reddit community, which resolves two additional sources of bias. First, Reddit users are intrinsically motivated, seeking advice about highly complex real issues - which past work suggests differ from hypothetical issues that crowd workers might come up with (e.g. Kwiatkowski et al., 2019; Gurari et al., 2018). Second, we make our dataset dynamic, not static - models are evaluated over Reddit situations posted over the previous two weeks at the time of submission. Models therefore, like humans, must generalize to new situations and patterns of language.
Experimental results show that TURINGADVICE is
incredibly challenging for NLP models. Today's largest finetunable model, T5 with 11 billion parameters, produces advice that is preferable to human-written advice  $14.5\%$  of the time - after being finetuned on 600k examples. GPT3, an even larger model with 175 billion parameters that was not released for finetuning, does even worse at  $4\%$ . Even more concerning, our evaluation finds that it often generates hateful and toxic language.
We also study our task from the perspective of today's standard 'core' NLP tasks. Broadly, we find that machines frequently confuse who is who, are self-contradictory, or seem to miss important world knowledge. However, these mistakes tend not to fall into the neat categories defined by standard task definitions. We address this by introducing diagnostic questions, which systematically measure these language understanding errors.
In summary, our paper makes three contributions. First, we introduce a new framework for measuring language understanding through directly tackling real-world language problems. Second, we introduce TURINGADVICE as a new challenge for AI systems, along with a dynamic dataset and leaderboard. Third, we connect our task to existing atomic NLP tasks, introducing a new setting that reveals where progress is still needed.
2 Real World Language Use
We propose to evaluate machines by their success at real-world language use: using language to communicate with a human, in response to a naturally occurring situation, in order to achieve a desired outcome. This is how educators often measure (human) language understanding of a second language – by how well the learner can use the language (Council of Europe, 2001). Our approach is also inspired by Wittgenstein's notion of semantics, that "meaning is use:" language is grounded in our desire to make sense of one another and cooperate to meet our needs (Wittgenstein, 1953).
As machines do not have humanlike needs or desires, we propose to evaluate machines' success at a task by how well it serves a human who is interested in the outcome. For example, if a machine orders food on my behalf, then I can evaluate it based on whether I enjoy the dish it ordered. Though this requires careful task selection in order to make things feasible for current models, as we will show in Section 3, it results in a powerful and reliable human evaluation.
2.1.1 Pragmatics in NLP
Our evaluation relates to pragmatics in NLP, where communication is modeled also through listeners and speakers (Golland et al., 2010; Frank and Goodman, 2012). One approach is to introduce a communication game, with an explicit objective. For example, Wang et al. (2016) study a blocks world where humans give commands to a block-placing machine. The machine is then graded on accuracy. Our proposed evaluation instead covers complex everyday scenarios faced by a human, where the objective is to help them as much as possible.
Pragmatics can also be studied through machine-machine communication; e.g., through emergent language (Lazaridou et al., 2017). Recent work uses pretrained question-answering models to evaluate summarization models (Chen et al., 2018; Scialom et al., 2019; Eyal et al., 2019; Vasilyev et al., 2020). However, ensuring that machines communicate in standard English is difficult, as there is usually a more efficient machine-language coding scheme for the task (Kottur et al., 2017).
2.1.2 Two major approaches for evaluation
Today, we see two major approaches for NLP evaluation, which we discuss below.
Quality of generations. The first approach studies generative tasks like chit-chat dialogue or storytelling, and measures the inherent quality of generations, often through attributes such as "sensibility" and "specificity" (e.g., Venkatesh et al., 2018; Hashimoto et al., 2019; Adiwardana et al., 2020). This approach is orthogonal to ours: though these attributes might be desirable, they are often insufficient to guarantee success at a task.
Correctness. The second (and perhaps more common) approach is to evaluate models through correctness over static datasets. For example, machines can be graded by the similarity of their generated translation to correct translations, or, by how often they choose the correct answer on a multiple choice exam. Many goal-oriented dialogue and semantics tasks are also evaluated in this way, as a model is evaluated by whether it makes the correct API call, or produces a correct parse.
Since many language tasks cannot be evaluated through correctness, researchers often introduce
proxy tasks that are easy to evaluate, while (hopefully) correlating with the underlying true task. For example, SWAG (Zellers et al., 2018) is a multiple-choice proxy task and dataset introduced to study the true task of commonsense reasoning.
However, there are gaps between datasets for proxy tasks (e.g. multiple choice), and the core tasks they seek to represent (e.g. commonsense reasoning), which we discuss in the next sections.
2.2 Can language use really be measured through correctness over proxy tasks?
When we reduce a complex language task to a simplified setup, with a small label space (like multiple-choice classification), we run the risk of introducing artifacts and biases: patterns that can be exploited in the simplified setup, but that are not representative of the true task (Gururangan et al., 2018; Zellers et al., 2019a). Artifacts can enable machines to even outperform humans at the final benchmark, without solving the underlying task.
While the problem of artifacts has recently taken the spotlight in the NLP community, partially because large Transformers (Vaswani et al., 2017) excel at picking up on artifacts, there is a deeper underlying issue. One way to view simplified tasks is that in order to correctly map inputs  $X$  to labels  $Y$ , a machine must learn a set of attributes  $A$  that are representative of the 'true' task. We can upperbound the information contained by  $A$  through the information bottleneck principle of Tishby et al. (1999). An efficient model minimizes the following, for some  $\beta > 0$ :
$$
\min  _ {p (a \mid x)} I (X; A) - \beta I (A; Y), \tag {1}
$$
where  $I$  is mutual information. In other words, the model will learn attributes  $A$  that maximally compress the inputs  $X$  (minimizing  $I(X;A)$ ), while also remaining good predictors of the labels  $Y$  (maximizing  $I(A;Y)$ ). However, the label prediction term is bounded by the information (or entropy,  $H$ ) of the label space:
$$
I (A; Y) = H (Y) - H (Y | A) \leqslant H (Y). \tag {2}
$$
Thus, for a task with a small label space, there is no guarantee that a model will learn high-information content attributes. Models are in fact encouraged to overfit to dataset artifacts, and to unlearn linguistically useful information that is not directly relevant to predicting  $Y$  (Pereira, 2000).
<sup>1</sup>Models submitted to the 2019 Conference on Machine Translation were evaluated (by humans) on how well the model's translations agreed with either (1) human-written translations, or, (2) original source text (Barrault et al., 2019).
An alternate approach is to make datasets harder adversarially, so as to have fewer artifacts (Zellers et al., 2018, 2019a; Le Bras et al., 2020). However, it might be impossible to make a dataset with no artifacts, or to know if one has been created.
Our proposal, to evaluate models by their real-world language use, addresses the information bottleneck issue in two ways. First, when we use language in the real world, the mapping between possible inputs and outputs is often highly complex. For example, the space of possible advice is vast, and many pieces of advice might be equally helpful given a situation. Second, we directly tackle language problems, without introducing a correctness-based proxy that machines might overfit to.
2.3 Static datasets in a dynamic world
To evaluate performance on a real-world task by means of a dataset, we (implicitly) assume that the dataset is a good representation of the world (Torralba and Efros, 2011). This might be questionable when it comes to real-world language use, as static datasets necessarily capture historic patterns of language. For instance, syntactic understanding is often evaluated using the Penn Treebank, with news articles from 1989 (Marcus et al., 1993). However, the world is constantly evolving, along with the language that we use.
To bridge this gap, we propose to evaluate machines by their interactions with humans in the present. Models therefore must learn to perform the underlying language task, even for novel situations, rather than fitting to the historic distribution of a fixed test set. We make this notion concrete in the next section, where we introduce a dynamic dataset and leaderboard for evaluating advice.
3 TURINGAdvice: a New Challenge for Natural Language Understanding
As a case study of our framework, we introduce TURINGADVICE, a new challenge task for AI systems to test language understanding. The format is simple: given a situation expressed in natural language, a machine must respond with helpful advice. To pass the challenge, machine-written advice must be at least as helpful to the advice-seeker as human-written advice, in aggregate.
We focus on advice for a few reasons. First, advice-giving is both an important and an everyday task. People ask for and give advice in settings as diverse as relationship advice and tech support
(Bonaccio and Dalal, 2006). Thus, we as humans have inherent familiarity with the task, and what it means for advice to be helpful – making it easy to evaluate, as we later show empirically. Moreover, because there are many internet communities devoted to advice-giving, training data is plentiful.
Second, the framework of advice-giving allows us to study subtasks such as reading comprehension and natural language inference (Section 5.3); we argue both of these are needed to consistently give good advice. Learning to recognize advice has recently been studied as an NLP task on its own (Govindarajan et al., 2020), though we are not aware of past work in learning to generate advice.
3.1 REDDITADVICE: A dynamic dataset for evaluating advice
We propose to evaluate models dynamically, through new situations and advice that are posted to Reddit. We call our dynamic dataset REDDIT-AdVICE. Many of Reddit's subcommunities (or 'subreddits') are devoted to asking for and giving advice, with subreddits for legal, relationship, and general life advice. During evaluation time, we will retrieve new situations from Reddit as a new test set for models. Workers on Mechanical Turk then grade the model-written advice versus the Reddit-endorsed human-written advice.
3.1.1 How advice-giving works on Reddit
Suppose a Reddit user faces an issue that they are seeking advice about. First, they write up situation and post it to an advice-oriented subreddit. Users then reply to the situation, offering advice.
Importantly, any user can 'upvote' or 'downvote' the advice as well as the situation itself - changing its score slightly. Top-scoring advice is deemed by the wisdom of the crowd as being the most helpful.<sup>3</sup>
3.1.2 The ideal evaluation - through Reddit?
In a sense, human advice-givers are 'evaluated' on Reddit by the score of their advice - representing how well their advice has been received by the community. Similarly, the ideal model evaluation might be to post advice on Reddit directly. If the model writes helpful advice, it should be upvoted.
2We use advice from the following subreddits: Love, Relationships, Advice, NeedAdvice, Dating_Advice, Dating, Marriage, InternetParents, TechSupport, and LegalAdvice.
This is somewhat of a simplification, as other factors also influence what gets upvoted (Anderson et al., 2012; Lakkaraju et al., 2013; Muchnik et al., 2013; Jaech et al., 2015).
Figure 2: Crowdsourcing workflow. Mechanical Turk Workers are given a situation, and two pieces of advice. First, they choose which is more helpful (here, B). Second, they rate the helpfulness of the worse advice (A); last, they answer a diagnostic question.
However, there is a significant ethical problem with this approach. The users who post advice questions are real people, with real problems. A user might read advice that was originally written by a machine, think it was human-endorsed, and do something harmful as a result. For this reason, we take an alternate crowdsourcing approach.
3.1.3 A crowdsourced, hybrid evaluation - through Mechanical Turk
We propose a hybrid approach for dynamic evaluation of models. While the situations, and reference advice come from Reddit, we hire workers on Mechanical Turk to rate the relative helpfulness of machine-written advice. Not only is this format more ethical, it also lets us collect diagnostic ratings, allowing us to quantitatively track the natural language understanding errors made by machines. We made our crowdsourcing task as fulfilling as possible - using popular situations from Reddit, and pitching the work in terms of helping people. We received feedback from many workers that our tasks were entertaining and fun, suggesting that our workers are to some degree intrinsically motivated.
3.1.4 Mechanical Turk annotation setup
In a single round of evaluation, we retrieve 200 popular Reddit situations that were posted in the last two weeks. For each situation, we retrieve the top-rated advice from Reddit, and generate one piece of advice per model. Workers on Mechanical Turk then compare the helpfulness of the model-generated advice with human-written advice, and provide diagnostic ratings.
We show an overview of our Mechanical Turk task in Figure 2. A worker is given a situation and two pieces of advice. One is the top-scoring advice from Reddit, and the other is model-generated advice; the worker is not told which is which.
The worker first chooses the more helpful piece of advice, then provides diagnostic information for the less helpful advice – rating it Slightly helpful, Not helpful, or Dangerous. If the worse piece of advice was Slightly helpful, they choose whether it is worse due to a Meaning problem or a Writing problem. Otherwise, they choose if the worse advice could be Possibly helpful in some other situation, or Never helpful in any situation.
Three workers rate each model-situation pair, and ratings are combined using a majority vote. We follow best practices on Mechanical Turk, using a qualification exam, paying workers at least  $15 per hour, and giving feedback to workers. Still, evaluation is highly economical at$ 1.86 per example-model pair, or roughly $400 per model evaluated.
3.2 A large static dataset for training
We present RedditAdvice2019, a large static dataset for training advice-giving models. Because today's models have extreme reliance on data for finetuning, we collect data that is in the exact same format as REDDITADVICE, yet we expand our selection criteria, optimizing for recall rather than precision (Supp A.2). In total, we extract 616k pieces of advice, over 188k situations.
To mirror the dynamic nature of the evaluation, in which models are evaluated on situations posted in 2020 and beyond, we split our dataset into static training and validation sets by date.4
4 Experimental Results on REDDITADVICE
In this section, we report results from one round of dynamic evaluation on REDDITADVICE. We evaluate the following strong NLP models and baselines:
a. Rule-based: a templated system to give legal, relationship, or life advice. The system first chooses randomly empathetic sentence from ten choices, for example "I'm sorry you're facing this." It then chooses a random piece of advice that is loosely related to the situation's topic; we infer this from the subreddit the situation was posted on. For example, for
Our training set contains 600k pieces of advice from July 2009 to June 14, 2019; validation contains 8k from June 14 to July 9th 2019.
% Frequency that model advice is preferred over best Reddit advice
Figure 3: Helpfulness of models relative to top-scoring Reddit advice. We show results over 200 shared situations; we also show bootstrapped  $95\%$  confidence intervals. Advice from the best-scoring model, T5-11B, is preferred  $14.5\%$  over top-scoring Reddit advice. We also compare the second-top scoring piece of Reddit advice, which scores  $41\%$  - worse than the best advice  $(50\%)$  by definition), but better than any model.
LegalAdvice the model might write "I'd suggest getting a lawyer immediately."
b. TF-IDF retrieval: for a new situation, we compute its TF-IDF bag-of-word vector and use it to retrieve the most similar situation from the training set. We then reply with the top-scoring advice for that situation.
c. Grover-Mega (Zellers et al., 2019b): a left-to-right transformer model with 1.5 billion parameters. Grover was pretrained on news articles with multiple fields, perhaps making it a good fit for our task, with multiple fields of context (like the subreddit, date, and title). Our situation-advice pairs are often quite long, so we adapt Grover for length; pretraining it on sequences of up to 1536 characters.
d. T5 (Raffel et al., 2019): a sequence-to-sequence model with a bidirectional encoder and a left-to-right generator, with 11 billion parameters. T5 was trained on a large dataset of cleaned web text. At the time of writing, T5 is the top-scoring model on the Glue and SuperGlue benchmarks (Wang et al., 2019b,a), scoring above human performance on Glue and near human-performance on SuperGlue.
e. GPT3 (Brown et al., 2020): a left-to-right transformer model with 175 billion parameters. GPT3 must be "prompted" to generate advice since it has not been released for finetuning. We cannot provide few-shot examples in the
Figure 4: Improvement (in absolute percentage %) between pairs of models, along with statistical significance from a paired t-test. The improvement of T5-11B over smaller models like Grover-Mega is highly statistically significant (10% gap,  $p < .01$ ), while being far worse than human performance. Our evaluation thus meaningfully grades varying levels of performance.
prompt due to the length of situation-advice pairs; we instead mimic the formatting of a website quoting from Reddit (Appendix B.5).
Last, to quantify the measurement error of our evaluation, we additionally evaluate:
f. the second-highest rated Reddit advice for each situation. We send this advice through the same pipeline as machine-written advice.
We finetune all models (except GPT3) and generate using Nucleus Sampling (Holtzman et al., 2020); more details in Appendix B.