Humans (e.g., crowdworkers) have a remarkable ability in solving different tasks, by simply reading textual instructions that define them and looking at a few examples. Despite the success of the conventional supervised learning on individual datasets, such models often struggle with generalization across tasks (e.g., a question-answering system cannot solve classification tasks). A long-standing challenge in AI is to build a model that learns a new task by understanding the human-readable instructions that define it. To study this, we introduce NATURALINSTRUCTIONS , a dataset of 61 distinct tasks, their human-authored instructions, and 193 k task instances (input-output pairs). The instructions are obtained from crowdsourcing instructions used to create existing NLP datasets and mapped to a unified schema. Using this meta-dataset, we measure cross-task generalization by training models on seen tasks and measuring generalization to the remaining unseen ones. We adopt generative pre-trained language models to encode task-specific instructions along with input and generate task output. Our results indicate that models benefit from instructions when evaluated in terms of generalization to unseen tasks (19% better for models utilizing instructions). These models, however, are far behind an estimated performance upperbound, indicating significant room for more progress in this direction. 1 1 Introduction We have witnessed great progress in solving many NLP datasets through fine-tuning pre-trained language models (LMs) (Peters et al., 2018; Brown et al., 2020). More recent studies show tremendous promise in generalization within the set of observed tasks through multi-task training and unified encoding (Khashabi et al., 2020; Aghajanyan et al.,  Work done while interning at Allen Institute for AI. 1 Dataset is available at https://instructions. apps.allenai.org grammarcheck tagging essentialphrases questiontyping answering questions Input: She chose to make a salad for lunch on Sunday. Question: how long did it take for her to make a salad? Crowdsourcing Instruction: List all the words that are essential for answering it correctly. [...] Crowdsourcing Instruction: Label the type of the temporal phenomena in the question. Example are [...] Output: 30mins Output: making salad Output: no ? supervision with seen tasks Output: Event duration ? evaluation on unseen tasks Crowdsourcing Instruction: Label "yes" if the sentence contains any grammatical issues. Otherwise, [...] Crowdsourcing Instruction: Answer the provided question based on a given [...] Figure 1: We construct the NATURALINSTRUCTIONS dataset from crowdsourcing instructions and instances of different NLP datasets. We study if models can learn from seen tasks and generalize to unseen tasks given their natural crowdsourcing instructions. 2021). However, cross-task generalization  generalization to unseen tasks  has generally remained under-explored. For example, can we supervise a model with instances of grammar checking or question answering tasks, yet expect it to solve a different task like question typing (Fig.1). Evidently, humans are capable of such generalizations; an average human can follow natural language instructions to solve a variety of problems, as evident by the success of crowdsourcing platforms (also argued in Efrat and Levy (2020)). In this paper, we study if models can generalize to unseen tasks given their crowdsourcing instructions (Fig.1). We build NATURALINSTRUCTIONS , a dataset consisting of natural crowdsourcing instructions for various tasks and their instances. Training on seen tasks T seen in our dataset, we build a model that learns to follow natural instructions that define a task and perform tasks (i.e., mapping input to out-put). Testing on unseen tasks T unseen , we evaluate if the model can perform unseen tasks solely from 3470 Task Instance-LevelGeneralization Task-LevelGeneralization Trainingdata X train ,Y train p I t ,X train t ,Y train t q t P T seen Evaluation x  y where: p x,y q P p X test ,Y test q p x,I t q  y where: p x,y q P p X test t ,Y test t q t P T unseen (a) A comparison of task vs instance -level generalization I t , X t and Y t indicate natural language instructions, input, and output sets respectively for task t . In the conventional setup, training and evaluation are done on the instances of the same task. However, in task-level generalization, a model is expected to generalize to unseen tasks, where T unseen XT seen  H . (b) BART evaluation on unseen tasks ( y -axis is perf. on T unseen ) when supervised with seen tasks ( x -axis is | T seen | ). A model using instructions ( I t ) consistently improves with more observed tasks. In contrast, models with no access to the instructions show no sign of improved generalization. Details in 6.3. their instructions and without any task-specific labeled data (Table 2a; right). In contrast to the instance-level generalization (Table 2a; left), our model uses instruction as additional input, and evaluations are done on tasks that were not observed in the training stage. We compile NATURALINSTRUCTIONS from task instructions written by researchers for crowdsourcing existing NLP datasets. Such crowdsourcing instructions often elaborate a variety of details about how a task should (and should not) be done. To provide a systematic study of various elements of crowdsourcing instructions, we map them to a unified schema to cover the most important elements of task descriptions  such as definition, constraints, positive and negative examples. We collect tasks in NATURALINSTRUCTIONS as minimal stand-alone steps provided to crowdworkers to complete a downstream NLP task. For example, tasks collected from QASC (Khot et al., 2020) include sub-tasks about generating topic words or combining facts, as well as answering multi-hop questions. Therefore our dataset not only contains typical downstream tasks in NLP, but also the intermediate subtasks that are not well-represented in the common benchmarks. The unified schema and the collection of minimal subtasks enable training LMs that can generalize across different tasks by learning from instructions. In total, our dataset consists of 61 distinct NLP tasks and 193 k instances. Our experimental results indicate that LMs learn to leverage natural language instructions as they show improved generalization to new tasks. For example, a BART (Lewis et al., 2019) achieves a 19% gain in terms of cross-task generalization compared to a model not using instructions (6). Importantly, LMs can generalize better to unseen tasks if they observe more tasks in training (Fig.2b). This upward trajectory suggests the potential for stronger cross-task generalizable models upon scaling up the diversity of tasks represented in a meta-dataset of task instructions. Despite the benefits of instructions, we observe a sizable gap between models' generalization and their estimated upperbounds (6.4), encouraging the community to work on this challenging problem. Contributions: In summary, the contributions of this work are as follows: (a) we introduce NATURALINSTRUCTIONS , a dataset of human-authored instructions curated from existing wellknown datasets mapped to a unified schema, providing training and evaluation data for learning from instructions; (b) we build models that can encode instructions and show: (b.1) the benefit of cross-task generalization by leveraging instructions; (b.2) the importance of different elements of instructions in the performance; (b.3) noteworthy headroom for improvement on our benchmark, which hopefully will motivate further work in this direction. Learning from instructions. There is recent literature on the extent to which models follow language instructions (Hase and Bansal, 2021; Ye and Ren, 2021; Gupta et al., 2021; Zhong et al., 2021). For example, Efrat and Levy (2020) examine if language models can follow crowdsourcing instructions with no further training. On the contrary, our work is pursuing a fundamentally different goal: creating a dataset of crowdsourcing instructions and task instances and formulating cross-task generalization by training models on seen tasks and 3471 measuring generalization to the remaining unseen ones. Weller et al. (2020) construct a crowdsourced dataset with short question-like task descriptions. Compared to this work, our instructions are longer, more complex and natural since they were used to collect datasets through crowdsourcing. PromptSource and FLAN (Wei et al., 2022; Sanh et al., 2022) are two concurrent works that pursue a similar goal as ours. A key difference between our work to these works is in terms of data collection strategy. Our work uses natural instructions created by NLP researchers before the dataset instances were created by crowd workers, and hence it contains the complete definition of each task (defini-tion, things to avoid, negative examples, etc.). On the other hand, instructions in the concurrent work are collected retroactively based on the already-available task instances. Our natural instructions enable evaluating models on how they learn tasks given different elements of task descriptions. (See A.5 for further comparisons.) Nevertheless, we believe that all these approaches to constructing instructions and task categories are complementary and the community will benefit from considering both towards solving the challenging problem of cross-task generalization. Prompt engineering. Constructing effective discrete prompts for language models to perform NLP tasks is an active area of research (Schick and Schtze, 2021; Reynolds and McDonell, 2021; Liu et al., 2021). Such prompts are often extremely short and may not include a complete definition of complex tasks. In contrast, our instructions encode detailed instructions as they were used to collect the datasets. Moreover, the goals are different: Most prompt-engineering approaches seek prompts with higher performance on a particular task, typically through assumptions about their target task which make them non-trivial to generalize to any other task. However, our introduced meta dataset enables the measurement of generalization to unseen tasks. Beyond standard multi-task learning. Multitask learning is a long-standing goal for AI (Caru-ana, 1997) and has led to successful models that can support a wider range of tasks (McCann et al., 2018; Raffel et al., 2020; Khashabi et al., 2020; Mishra et al., 2020; Aghajanyan et al., 2021; Ye et al., 2021). Most of the conventional setups in the multi-tasking literature evaluate on instances that belong to the tasks that are seen, i.e., their labeled instances were observed during training (1st column of Table 2a). We augment this setup by introducing natural language instructions which enable our models to bridge to tasks that were not seen during training. Here we formally define the problem setup for generalization across tasks. Each task t consists of input/output instances p X t , Y t q and is described in terms of its natural language instructions I t . Task-specific models. Standard supervised learning algorithms use task-specific labeled instances to learn a mapping from input x to output y : M p x q  y for p x, y q P p X train t , Y train t q and is evaluated on the test instances of the same (or similar) task p X test t , Y test t q . We refer to this as the instance-level generalization (Table 2a; left). Cross-task models. In this setup, the goal is to learn a model M that at inference obtains the output y given the input x and the task instruction I t : M p I t , x q  y, for p x, y q P p X t , Y t q . In contrast to the task-specific models, no task-specific training data is used to learn the mapping M . We collect NATURALINSTRUCTIONS (4) to study this question: can a model be trained to follow instructions via training tasks T seen and be generalized to follow instructions for a task t 1 PT unseen . We refer to this as a task -level generalization (Table 2a; right). 4 NATURALINSTRUCTIONSNATURALINSTRUCTIONS consists of instructions that describe a task (e.g., question answering) and instances of that task (e.g., answers extracted for a given question). Fig.3 shows an example instruction for the task of generating questions that require an understanding of event duration' accompanied with positive and negative examples that contextualize the task. Here we introduce a schema for representing instructions (4.1) and then describe how existing datasets (their crowdsourcing templates) are mapped into our schema (4.2). 4.1 Instruction Schema Instructions used in crowdsourcing various datasets, are written by distinct authors for different purposes, and they are different in a variety of ways (see Appendix A.2 for their differences.) We introduce a unified schema (Fig.4) to consistently represent these diverse forms of instructions. Our instruction schema is the result of our pilot 3472 Instructions for MC-TACO question generation task -Title: Writing questions that involve commonsense understanding of "event duration". -Definition: In this task, we ask you to write a question that involves ?event duration", based on a given sentence. Here, event duration is defined as the understanding of how long events typically last. For example, ?brushing teeth?, usually takes few minutes. -Emphasis & Caution: The written questions are not required to have a single correct answer. -Things to avoid: Don't create questions which have explicit mentions of answers in text. Instead, it has to be implied from what is given. In other words, we want you to use "instinct" or "common sense". -Input: Sentence: Jack played basketball after school, after which he was very tired. -Output: How long did Jack play basketball? -Reason: the question asks about the duration of an event; therefore it's a temporal event duration question. Positive Example -Input: Sentence: He spent two hours on his homework. -Output: How long did he do his homework? -Reason: We DO NOT want this question as the answer is directly mentioned in the text. -Suggestion: Negative Example -Prompt: Ask a question on "event duration" based on the provided sentence. Example task instances -Input: Sentence: It's hail crackled across the comm, and Tara spun to retake her seat at the helm. -Expected Output: How long was the storm? Instance -Input: Sentence: During breakfast one morning, he seemed lost in thought and ignored his food. -Expected Output: How long was he lost in thoughts? Instance ... Figure 3: An example from our dataset. Note that it follows the schema provided in Fig.4. See Fig .11 for more examples. study conducted on a subset of datasets. Below we describe the ingredients of this schema:  TITLE provides a high-level description of a task and its associated skill (such as question generation, answer generation).  PROMPT is a single sentence command that often appears before the input instance and connects it to the instructions.  DEFINITION provides the core detailed instructions for a task.  THINGS TOAVOID contain instructions regarding undesirable annotations that must be avoided. These help to define the scope of a task and the space of acceptable responses.  EMPHASIS ANDCAUTION are short, but important statements highlighted in the crowdsourcing templates which were intended to be emphasized or warned against.  POSITIVEEXAMPLES contain inputs/outputs similar to the input given to a worker/system and its expected output, helping crowdworkers better understand a task (Ali, 1981).  NEGATIVEEXAMPLES contain inputs/outputs Instructions Title Definition Things to avoid Emphasis/caution Prompt # of positive examples Input Output Reason # of negative examples Input Output Reason Suggestion Positive Example Negative Example Instances # of i nstances Input Output Task Instance Figure 4: The schema used for representing instruction in NATURALINSTRUCTIONS (4.1), shown in plate notation. to emphasize THINGS TOAVOID by providing examples that must not be produced.  REASON provides explanations behind why an example is positive or negative.  SUGGESTION contains suggestions on how a negative example could be modified to turn it into a positive example. The next section describes the process of mapping the raw instructions (designed for crowdworkers) to our instruction schema. 4.2 Constructing NATURALINSTRUCTIONS 4.2.1 Collecting Data Collecting raw instructions and instances. We use existing, widely adopted NLP benchmarks that are collected via crowdsourcing platforms and hence, come with crowdsourcing templates. In the first step, we identified several datasets and engaged with their authors to get their crowdsourcing templates and raw data. This yields the following datasets: CosmosQA (Huang et al., 2019), DROP (Dua et al., 2019), Essential-Terms (Khashabi et al., 2017), MCTACO (Zhou et al., 2019), MultiRC (Khashabi et al., 2018), QASC (Khot et al., 2020), Quoref (Dasigi et al., 2019), ROPES (Lin et al., 2019) and Winogrande (Sakaguchi et al., 2020). 2 Splitting crowdsourcing instructions into minimal tasks. Almost all the crowdworking instructions include sequences of steps to guide crowdworkers in creating task instances. For example, QASC and MCTACO include 7 and 19 steps in the data creation process, respectively. We divide 2 We only focus on textual instructions and avoid datasets that involve visual or auditory steps, mostly focusing on QA datasets that were available to the authors. 3473 source dataset task Quoref (Dasigi et al., 2019) question generation answer generation QASC (Khot et al., 2020) topic word generation fact generation combining facts question generation answer generation incorrect answer generation Table 1: Examples of the datasets and the tasks formed from them. The extracted tasks are independent annotation assignments in the crowdsourcing templates of the datasets. The complete list is in Table 10 in Appendix. category # of tasks # of instances question generation 13 38 k answer generation 16 53 k classification 12 36 k incorrect answer generation 8 18 k minimal modification 10 39 k verification 2 9 k Total 61 193 k Table 2: Task categories and their statistics. crowdsourcing instructions into their underlying steps and generate multiple subtasks that are minimal and standalone. 3 Table 1 shows subtasks extracted for Quoref and QASC. For example, the main task in Quoref is to answer a question given a context paragraph, but the crowdsourcing template consists of two sub-tasks of question generation and answer generation with their separate instructions. This process results in a more consistent definition of tasks, enabling a successful mapping of instructions into our schema, in contrast to the work of Efrat and Levy (2020) that uses crowdsourcing instructions as-is. In total, there are 61 tasks, which are categorized into 6 semantic categories (Table 2). We assigned these broad categories to the tasks to understand their collective behavior in the experiments. It is noteworthy that, despite the apparent resemblance of the tasks included in the same category, any pair of tasks are distinct. For example, while question generation is part of Quoref, CosmosQA, and QASC, each has its own separate variant of the question generation task (see Fig.10 in Appendix). 4.2.2 Mapping Raw Instructions to Schema We manually fill in the fields of our instruction schema with the content from the crowdsourcing 3 We eliminate tasks that involve model-in-the-loop. instructions. For instance, parts of the raw instructions that are highlighted for emphasis are incorporated as part of our emphasis/caution field. The modifications suggested in this step were applied by one author and were verified by another author. 4 Improving description quality and consistency. We edit raw instructions to ensure their quality. Particularly, we fix writing issues (typos, ambiguities, etc.) and redact repetitions. While repetition often helps in augmenting human understanding, short and concise instructions are often more effective for computers due to their limited attention span (Beltagy et al., 2020). Augmenting examples and reasons. There is a large variance in the number of examples provided in the raw instructions. Instructions often include more positive examples, or some instructions do not include any negative examples (e.g., QASC). Whenever possible, we add negative examples such that each task has at least two negative examples. Furthermore, not all raw instructions contain REASONS or SUGGESTIONS for each of their examples. For example, positive examples are usually not accompanied by explanations, and most datasets do not include suggestions. We add them, wherever such information is missing in the instructions. Collecting input/output instances for subtasks. Most of our tasks are the intermediate steps in the crowdsourcing process. Therefore, to extract input/output instances for each task, we need to parse the raw annotations of crowdworkers for every step. Since each dataset stores its annotations in a slightly different format, extracting and unifying such intermediate annotations can be non-trivial. Verification. An annotator verified the quality of the resulting data in consultation with dataset authors. The annotator iterated on the authors' feedback (avg of 3 iters) until they were satisfied. Quality assessment. We ask independent human annotators to answer 240 random instances (20 instances from 12 random tasks, used later for our evaluation 5.1). The subsequent evaluation of the human-generated responses results in more than 96% accuracy, which indicates that humans can effortlessly understand and execute our instructions. 4.2.3 NATURALINSTRUCTIONS Statistics In summary, NATURALINSTRUCTIONS consists of subtasks each with a set of instructions and in-4 On average, the process of data curation for each task takes around 5 hrs-34 hrs (details in Appendix; Table 9). 3474 put/output instances (Fig.3 and 4). The complete list of instructions is included in the appendix. In total, the dataset includes 61 tasks and 193 k instances. Table 2 shows data statistics for each task category. 5 On average, instructions contain 4.9 positive examples and 2.2 negative examples. The longest element of instructions is usually DEFINITIONS with 65.5 tokens and the shortest is TITLE with 8.3 tokens (more statistics in Table 3). statistic value title length 8.3 tokens prompt length 12.6 tokens definition length 65.5 tokens things to avoid length 24.1 tokens emphasis/caution length 45.0 tokens reason length 24.9 tokens suggestion length 19.6 tokens num of positive examples 4.9 num of negative examples 2.2 Table 3: Statistics of NATURALINSTRUCTIONS 5 Problem Setup and Models Here we define different cross-task generalization settings (5.1) and the models (5.2). Random split. This setup follows the common practice in benchmarking NLP models with random data splits. Here, two tasks from each task category (Table 2) in NATURALINSTRUCTIONS are randomly selected for evaluation, and the rest of the tasks are used for training. This leads to 12 tasks in T unseen and 49 tasks in T seen . 6 Leave-one-out generalization. To better understand the nature of cross-task generalization, we study more restrictive settings of dividing training and evaluation tasks. leave-one-category: evaluates how well a model generalizes to a task category if it is trained on others  no task of that category is in T seen . leave-one-dataset: evaluates how well a model can generalize to all tasks in a particular dataset if it is trained on all other tasks  no task of that dataset is in T seen . This split prevents any leakage across tasks that belong to the same source datasets. leave-one-task: evaluates how well a model can learn a single task by training on all other tasks. We build models using pre-trained LMs with encoder-decoder architectures BART (Lewis et al., 2019) for fine-tuning and GPT3 (Brown et al., 2020) for few-shot experiments. Encoding instructions and instances. For every problem setup, we map a given instruction I t and an input instance x into a textual format and decode an output y and obtain enc p I t , x q . This encoding function is then fed to an encoder-decoder model to predict y : M : enc p I t , x q  y . Encoding instances follows a standard NLP paradigm of mapping an input instance to text. Each instruction I t consists of multiple elements as described in our instruction schema (4.1). Here, we map each element of the instruction to a textual format and append it before the input instance. Fig.5 shows how we encode the full instruction. To study the impact of each instruction element for cross-task generalization, we compare these encodings: (1) PROMPT , (2) POS . EXAMPLES , (3) PROMPT + DEFINITION , (4) PROMPT + THINGS TO AVOID , (5) PROMPT + EMPHASIS , (6) PROMPT + POS . EXAMPLES , (7) PROMPT + + DEFINITION + POS . EXAMPLES , and (8) FULL INSTRUCTION . Each of these (e.g., PROMPT and POS . EXAMPLES ) correspond to prompting setups in the recent literature (Le Scao and Rush, 2021; Lu et al., 2021). BART. We use BART (base) (Lewis et al., 2019) which allows us to fine-tune its model parameters. This is an encoder-decoder architecture with 140 m parameters. For each setup, the input is encoded 3475 model  evaluation set T unseen  random split of tasks leave-onecategory (QG) leave-onedataset (QASC) leave-onetask (QASC QG) BART (fine-Tuned) NO INSTRUCTIONS 13 6 37 20 FULL INSTRUCTIONS 32 17 51 56 GPT3 (not fine-tuned) FULL INSTRUCTIONS 24 33 22 33 Table 4: Cross-task generalization of BART under various splits (5.1). T seen tasks, and evaluated on T unseen (5.1). GPT3. As a comparison, we evaluate GPT3 (Brown et al., 2020) which is a 175 B parameter autoregressive LM (  1 . 2 k larger than BART) and has shown promising results in mimicking demonstrations provided in its prompt. We cannot fine-tune the parameters of this massive model and use it as-is under its default setting on the evaluation tasks in T unseen (5.1) using the encoding introduced earlier. Evaluation metrics. We treat all of our tasks as text generation problems and evaluate them with automated evaluation metrics for text generation. In particular, we use ROUGE-L (Lin, 2004) to automatically evaluate the generated outputs. 7 Implementation details. For BART, our models are trained for 3 epochs with a learning rate of 5e-5 for a given training split and input encoding. For GPT3, we use the davinci-instruct engine and produce outputs with greedy decoding, generating up to a maximum number of tokens of 16 (the default value). We use the default stop condition which is 2 newline tokens. 8 6.1 Generalization Under Various Task Splits Table 4 reports the results of the BART model train and evaluated with various task splits (5.1). For comparison, we evaluate GPT3 which uses no fine-tuning, unlike BART that is fine-tuned with the T seen tasks. The first column corresponds to random split of tasks, while the remaining columns report cross-task generalization results of the BART model under leave-onex splits (5.1). For x  category, the tasks in question-generation category 7 Our experiments show that other metrics, e.g. BLEURT (Sellam et al., 2020) are also correlated with ROUGE-L, which has also been used in generative QA tasks. 8 The relevant code is available at: https://github. com/allenai/natural-instructions-v1 are held out during training. For x  dataset, the tasks that were extracted from the QASC dataset were excluded from training. For x  task, we train a model on all tasks, except QASC question generation task which is used for evaluation. Instructions benefit cross-task generalization. The results indicate that BART benefits from instructions in generalizing to new tasks, regardless of task splits. For example, under random split, the model using FULLINSTRUCTIONS results in +19% gains over a model that is not using instructions. This is particularly interesting for leave-one-cat-egory-out split since the trained model can generalize to the tasks of a particular semantic category, without being exposed to it. In comparison to GPT3, the fine-tuned BART model that utilizes instructions achieves a stronger performance despite being  1 k smaller than GPT3. For example, a BART models using FULLINSTRUCTIONS achieves 8% higher performance than GPT3 under random split of tasks. Note that the absolute values in leave-one-category are lower due to the difficulty of this setup compared to, for example, the random split setup. While all settings involve evaluating on tasks not seen during training, the leave-one-category setting enforces more dissimilarity among training and evaluation tasks. 6.2 Generalization Under Instruction Encoding and Task Categories Table 5 reports the results of the BART model per encodings of different instruction elements (5.2) and for different task categories. The table shows that encoding more elements of the instructions generally achieves better results than just using PROMPT or POSITIVE EXAMPLES . It additionally shows that the benefit of the instruction elements seems to depend on the target task category. We observe that the question-generation (QG) tasks benefit the most from POSITIVE EXAMPLES , whereas in classification (CF), POSITIVE EXAMPLES are of 3476 model  task category  QG AG CF IAG MM VF avg BART (fine-tuned) NOINSTRUCTION 26 6 0 21 33 7 13 PROMPT 27 22 7 22 34 9 20 + DEFINITION 35 24 50 25 36 7 30  (+50) + THINGS TO AVOID 33 24 4 24 58 9 25  (+25) + EMPHASIS 38 23 16 26 49 3 26  (+30) + POS . EXAMPLES 53 22 14 25 17 7 23  (+15) + DEFINITION + POS . EXAMPLES 51 23 56 25 37 6 33  (+65) POS . EXAMP . 55 6 18 25 8 6 20 FULLINSTRUCTION 46 25 52 25 35 7 32  (+60) GPT3 (not fine-tuned) FULLINSTRUCTION 33 18 8 12 60 11 24 (+11) Table 5: Cross-task generalization under random split (5.1). Models show improved results when provided with instructions. The numbers in parenthesis indicate absolute gains compared to N OINSTRUCTIONS ' baseline. Fine-tuned BART archives better performance than GPT3, despite being over 1 k times smaller. Category names: QG: Question Generation, AG: Answer Generation, CF: Classification, IAG: Incorrect Answer Generation, MM: Minimal Text Modification, VF: Verification. All numbers are ROUGE-L (in percentage). little help. We hypothesis this is because it is easier to mimic question-generation based on a few examples, whereas it is difficult to define classes via a few examples, where DEFINITION can be more helpful. The models show little improvement in verification (VF). We hypothesize these tasks are inherently more difficult, partially because of their distinctness from the rest of the tasks in the dataset. We hope future work on this line will study a wider variety of tasks and will improve our understanding of such failure cases. 6.3 Generalization vs. Number of Seen Tasks Fig.2b compares the impact of the number of seen tasks for cross-task generalization. For supervision, we randomly sample a few tasks as T seen and evaluate on 6 tasks (one from each category). (each point in the figure is averaged over 5 random subsamples.) The results show that with NOINSTRUCTION encoding there is no tangible value in observing more tasks. In contrast, the generalization of the models that encode instructions improves with observing more tasks. This is an exciting observation since it suggests that scaling up our dataset to more tasks may lead to stronger instruction-following systems. 6.4 Analyses Upperbound: Task-specific Models. For each task, we obtain a task-specific model ( 3) by training BART separately on each task's annotated training data. We evaluate these task-specific models to obtain a loose estimate of upperbounds for each task. On average, task-specific models score Model  Split  w/ neg. examples w/o neg. examples BART random 32 35 leave-onex  x  category (AG) 19 21  x  dataset (Quoref) 37 37  x  task (QASC QG) 56 57 GPT3 24 44 Table 6: Effect of excluding negative examples from FULLINSTRUCTION encoding. Negative instructions are surprisingly difficult for the models to learn from. 66% which is considerably higher than our models' best generalization (32%; Table 4). This indicates that there is considerable room for improving generalization-based models that use instructions. Impact of Negative Examples. Crowdsourcing instructions often include negative examples to exemplify undesirable responses. We study how negative examples in instructions affect cross-task generalization. Our cases study (Table 6) indicates that the models work better without (w/o) negative examples, contrary to the previously-observed benefits of other instructional elements (e.g., definition, positive examples). This is aligned with the previous studies (Xuan et al., 2020; Lin et al., 2003) that discuss the challenges of learning from negative examples. Interestingly, GPT3's drop (44 vs 24) is more significant than BART (35 vs 32), showing that BART can partly recover through the training step. Error Analysis. We randomly sample 30 erroneous predictions of our fine-tuned BART on 3 distinct tasks (Winogrande answer generation; QASC 3477 Category Helpful Fields Explanation Question Generation (QG) 1. DEFINITIONProvides a holistic picture of the task. 2. EMPHASIS & CAUTIONProvides key information for solving the task. 3. POSITIVEEXAMPLES -Thisgivesanideaofwhatisexpectedintheoutput. 4. NEGATIVEEXAMPLESGood to know the common mistakes people do. Answer Generation (AG) 1. PROMPTIt limits the exploration space to question spans. 2. DEFINITIONProvides a general understanding of the task. 3. POSITIVEEXAMPLESReason field is very helpful. Classification (CF) 1. DEFINITIONThe task is unclear without this field. Incorrect Answer Generation (IAG) 1. DEFINITIONHelps understand the utility of such a task. 2. EMPHASIS & CAUTIONSource of some useful shortcuts. 3. POSITIVEEXAMPLESHelps in understanding the type of questions asked. Minimal Text Modification (MM) 1. THINGS TOAVOIDProvides critical information. Verification (VF) 1. DEFINITIONMakes the task easy to understand. 2. THINGS TO AVOIDContains useful tips required for this task. 3. POSITIVEEXAMPLESExemplifies task understanding. 4. NEGATIVE EXAMPLESHelps avoid potential mistakes. Table 7: Results of humans' perceived importance of instruction elements. Our annotators, for example, find DEFINITION and THING TOAVOID to be helpful for Classification and Minimal Text Modification tasks, respectively. question generation; MC-TACO incorrect answer generation). We categorize the errors into common patterns (Table 8). error type BART Generates a nonsensical/vague question 47 Generate an invalid question 8 Generates a yes/no question 4 Copies the given fact or a subset of it 3 Generates unanswerable questions 3 Table 8: Percentage of errors on QASC QG task. The numbers do not sum to 100 since the error types are not mutually exclusive. Unlike GPT3 which generally suffers from generating redundant content irrelevant to instructions, our BART model provides more control, however, it can fail to generate proper output. Here are several erroneous predictions from our model: Generates a nonsensical/vague question BART input: [...]input: Fact: graduations are used for measuring the volume of substances. output: ? BART output: How many substances are there in volume? Copies the given fact or a subset of it BART input: [...] input: Fact: If someone is not breathing, begin with ventilation. output: ? BART output: If someone is breathing, begin with ventilation. Generates a yes/no question BART input: [...] input: Fact: Lack of saliva hinders the break down of food into components the body can absorb. output: ? BART output: Does saliva hinders the break down of food into components the body can absorb? Perceived Impact of Instruction Elements. We survey human annotators to find out the value of instruction elements to humans. Except for the negative examples which were shown to be difficult for models, we observe similar trends between humans' perceived value of those elements (Ta-ble 7) and their contributions to the model performance (Table 5). For example, humans viewed DEFINITION and THINGS TOAVOID as necessary fields for classification and minimal text modification categories, respectively, which is compatible with our empirical observations (e.g., PROMPT + DEFINITION has the highest score on CF category in Table 5). 7 Conclusion In this paper, we studied the goal of building models that generalize to new tasks by encoding and understanding crowdsourcing instructions. We introduced NATURALINSTRUCTIONS , which is built based on existing crowdsourced datasets, that enables building such models and systematically evaluate them. To the best of our knowledge, this is the first work to show the benefit of instructions towards improved cross-task generalization. Additionally, we observe that our proposed task has a large room for improvement, which we believe will bring more attention to building stronger models that can generalize to a wider range of tasks. Acknowledgements We thank OpenAI for providing access to the GPT3 API, authors who generously shared their dataset templates with us, Matt Peters and Nicholas Lourie for helpful input, the Beaker team for their support with experiments, and the anonymous reviewers for their helpful feedback. The support of DARPA SAIL-ON, DARPA CHESS program, NSF IIS-2044660, ONR N00014-18-1-2826, and Paul G. Allen Foundation is gratefully acknowledged. 3478 References Armen Aghajanyan, Anchit Gupta, Akshat Shrivastava, Xilun Chen, Luke Zettlemoyer, and Sonal Gupta. 2021. Muppet: Massive multi-task representations with pre-finetuning. In Proceedings of EMNLP , pages 57995811. Ali M Ali. 1981. The use of positive and negative examples during instruction. Journal of instructional development , 5(1):27. Iz Beltagy, Matthew E Peters, and Arman Cohan. 2020. Longformer: The long-document transformer. arXiv preprint arXiv:2004.05150 . 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. 2020. Language models are few-shot learners. In NeurIPS , volume 33, pages 18771901. Curran Associates, Inc. Rich Caruana. 1997. Multitask learning. Machine learning , 28(1):4175. Pradeep Dasigi, Nelson F Liu, Ana Marasovic, Noah A Smith, and Matt Gardner. 2019. Quoref: A reading comprehension dataset with questions requiring coreferential reasoning. In Proceedings of EMNLP-IJCNLP , pages 59275934. Dheeru Dua, Yizhong Wang, Pradeep Dasigi, Gabriel Stanovsky, Sameer Singh, and Matt Gardner. 2019. Drop: A reading comprehension benchmark requiring discrete reasoning over paragraphs. In Proceedings of NAACL , pages 23682378. Avia Efrat and Omer Levy. 2020. The turking test: Can language models understand instructions? arXiv preprint arXiv:2010.11982 . Tanmay Gupta, A. Kamath, Aniruddha Kembhavi, and Derek Hoiem. 2021. Towards general purpose vision systems. ArXiv , abs/2104.00743. Peter Hase and Mohit Bansal. 2021. When can models learn from explanations? a formal framework for understanding the roles of explanation data. arXiv preprint arXiv:2102.02201 . Lifu Huang, Ronan Le Bras, Chandra Bhagavatula, and Yejin Choi. 2019. Cosmos qa: Machine reading comprehension with contextual commonsense reasoning. In Proceedings of EMNLP-IJCNLP , pages 23912401. Daniel Khashabi, Snigdha Chaturvedi, Michael Roth, Shyam Upadhyay, and Dan Roth. 2018. Looking beyond the surface: A challenge set for reading comprehension over multiple sentences. In Proceedings of NAACL , pages 252262. Daniel Khashabi, Tushar Khot, Ashish Sabharwal, and Dan Roth. 2017. Learning what is essential in questions. In Proceedings of CoNLL , pages 8089. Daniel Khashabi, Sewon Min, Tushar Khot, Ashish Sabharwal, Oyvind Tafjord, Peter Clark, and Hannaneh Hajishirzi. 2020. UnifiedQA: crossing format boundaries with a single qa system. In Proceedings of EMNLP: Findings , pages 18961907. Tushar Khot, Peter Clark, Michal Guerquin, Peter Jansen, and Ashish Sabharwal. 2020. QASC: A dataset for question answering via sentence composition. In Proceedings of AAAI . Teven Le Scao and Alexander M Rush. 2021. How many data points is a prompt worth? In Proceedings of NAACL-HLT , pages 26272636. Mike Lewis, Yinhan Liu, Naman Goyal, Mar-jan Ghazvininejad, Abdelrahman Mohamed, Omer Levy, Ves Stoyanov, and Luke Zettlemoyer. 2019. BART: Denoising sequence-to-sequence pretraining for natural language generation, translation, and comprehension. In Proceedings of ACL . Chin-Yew Lin. 2004. Rouge: A package for automatic evaluation of summaries. In Text summarization branches out , pages 7481. Kevin Lin, Oyvind Tafjord, Peter Clark, and Matt Gardner. 2019. Reasoning over paragraph effects in situations. In Proceedings of the 2nd Workshop on Machine Reading for Question Answering , pages 58 62. Winston Lin, Roman Yangarber, and Ralph Grishman. 2003. Bootstrapped learning of semantic classes from positive and negative examples. In Proceedings of ICML Workshop on The Continuum from Labeled to Unlabeled Data , volume 1, page 21. Pengfei Liu, Weizhe Yuan, Jinlan Fu, Zhengbao Jiang, Hiroaki Hayashi, and Graham Neubig. 2021. Pretrain, prompt, and predict: A systematic survey of prompting methods in natural language processing. arXiv preprint arXiv:2107.13586 . Yao Lu, Max Bartolo, Alastair Moore, Sebastian Riedel, and Pontus Stenetorp. 2021. Fantastically ordered prompts and where to find them: Overcoming few-shot prompt order sensitivity. arXiv preprint arXiv:2104.08786 . Bryan McCann, Nitish Shirish Keskar, Caiming Xiong, and Richard Socher. 2018. The natural language decathlon: Multitask learning as question answering. 3479 Swaroop Mishra, Arindam Mitra, Neeraj Varshney, Bhavdeep Sachdeva, and Chitta Baral. 2020. Towards question format independent numerical reasoning: A set of prerequisite tasks. arXiv preprint arXiv:2005.08516 . Matthew E Peters, Mark Neumann, Mohit Iyyer, Matt Gardner, Christopher Clark, Kenton Lee, and Luke Zettlemoyer. 2018. Deep contextualized word representations. In Proceedings of NAACL-HLT , pages 22272237. Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li, and Peter J Liu. 2020. Exploring the limits of transfer learning with a unified text-to-text transformer. Journal of Machine Learning Research , 21(140):167. 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 17. Keisuke Sakaguchi, Ronan Le Bras, Chandra Bhagavat-ula, and Yejin Choi. 2020. Winogrande: An adversarial winograd schema challenge at scale. In Proceedings of the AAAI . Victor Sanh, Albert Webson, Colin Raffel, Stephen Bach, Lintang Sutawika, Zaid Alyafeai, Antoine Chaffin, Arnaud Stiegler, Arun Raja, Manan Dey, M Saiful Bari, Canwen Xu, Urmish Thakker, Shanya Sharma Sharma, Eliza Szczechla, Tae-woon Kim, Gunjan Chhablani, Nihal Nayak, De-bajyoti Datta, Jonathan Chang, Mike Tian-Jian Jiang, Han Wang, Matteo Manica, Sheng Shen, Zheng Xin Yong, Harshit Pandey, Rachel Bawden, Thomas Wang, Trishala Neeraj, Jos Rozen, Ab-heesht Sharma, Andrea Santilli, Thibault Fevry, Jason Alan Fries, Ryan Teehan, Teven Le Scao, Stella Biderman, Leo Gao, Thomas Wolf, and Alexander M Rush. 2022. Multitask prompted training enables zero-shot task generalization. In Proceedings of ICLR . Timo Schick and Hinrich Schtze. 2021. Few-shot text generation with natural language instructions. In Proceedings of EMNLP . Thibault Sellam, Dipanjan Das, and Ankur Parikh. 2020. Bleurt: Learning robust metrics for text generation. In Proceedings of ACL , pages 78817892. Jason Wei, Maarten Bosma, Vincent Zhao, Kelvin Guu, Adams Wei Yu, Brian Lester, Nan Du, Andrew M. Dai, and Quoc V Le. 2022. Finetuned language models are zero-shot learners. In Proceedings of ICLR . Orion Weller, Nicholas Lourie, Matt Gardner, and Matthew Peters. 2020. Learning from task descriptions. In Proceedings of EMNLP , pages 13611375. Hong Xuan, Abby Stylianou, Xiaotong Liu, and Robert Pless. 2020. Hard negative examples are hard, but useful. In Proceedings of ECCV , pages 126142. Springer. Qinyuan Ye, Bill Yuchen Lin, and Xiang Ren. 2021. Crossfit: A few-shot learning challenge for cross-task generalization in nlp. In Proceedings of EMNLP . Qinyuan Ye and Xiang Ren. 2021. Zero-shot learning by generating task-specific adapters. arXiv preprint arXiv:2101.00420 . Zihao Zhao, Eric Wallace, Shi Feng, Dan Klein, and Sameer Singh. 2021. Calibrate before use: Improving few-shot performance of language models. In Proceedings of ICML , pages 1269712706. Ruiqi Zhong, Kristy Lee, Zheng Zhang, and Dan Klein. 2021. Adapting language models for zero-shot learning by meta-tuning on dataset and prompt collections. In Proceedings of EMNLP: Findings , pages 28562878. Ben Zhou, Daniel Khashabi, Qiang Ning, and Dan Roth. 2019. going on a vacation takes longer than going for a walk: A study of temporal commonsense understanding.
abstain abstain abstain method abstain result method result abstain abstain other abstain objective abstain method method result result abstain abstain abstain abstain abstain abstain abstain abstain objective abstain abstain method method abstain abstain abstain abstain objective abstain abstain abstain result objective method objective other other other objective other method other abstain method other method other objective other other other objective other abstain other other other objective method abstain abstain other abstain abstain abstain abstain abstain method abstain abstain abstain abstain method abstain abstain abstain abstain abstain abstain abstain method abstain abstain abstain abstain abstain method abstain other abstain abstain abstain method abstain abstain abstain abstain abstain abstain abstain abstain result abstain other