Robustness of Learning from Task Instructions (2023)

Abstract: Traditional supervised learning mostly works on individual tasks and requires training on a large set of task-specific examples. This paradigm seriously hinders the development of task generalization since preparing a task-specific example set is costly. To build a system that can quickly and easily generalize to new tasks, task instructions have been adopted as an emerging trend of supervision recently. These instructions give the model the definition of the task and allow the model to output the appropriate answer based on the instructions and inputs. However, task instructions are often expressed in different forms, which can be interpreted from two threads: first, some instructions are short sentences and are pretrained language model (PLM) oriented, such as prompts, while other instructions are paragraphs and are human-oriented, such as those in Amazon MTurk; second, different end-users very likely explain the same task with instructions of different textual expressions. A robust system for task generalization should be able to handle any new tasks regardless of the variability of instructions. However, the system robustness in dealing with instruction-driven task generalization is still unexplored. This work investigates the system robustness when the instructions of new tasks are (i) manipulated, (ii) paraphrased, or (iii) from different levels of conciseness. To our knowledge, this is the first work that systematically studies how robust a PLM is when it is supervised by instructions with different factors of variability.

## introduction one goal of ai is to achieve cross-task generalization, i.e., the model can handle new tasks after being trained on existing tasks. to solve target tasks, the system needs task-specific supervision. 1 all code and data: https://github.com/jiashenggu/ tk-instruct/tree/main in the conventional machine learning paradigm, task-specific supervision means a large set of labeled examples particularly for this task. despite the progress of conventional machine learning, collecting task-specific examples of large volumes is costly and even infeasible if we want the system to cope with new tasks immediately. therefore, another form of task-specific supervision-task instructions-is attracting increasing attention in the community. task instructions, commonly a piece of text, describe the task semantics and tell the model how to approach the expected outputs for the inputs. a couple of recent studies @xcite @xcite have shown promising progress in cross-task generalization with only instructions as supervision. in the real world, task instructions are often presented in different forms, which can be interpreted from two dimensions: on the one hand, as @xcite defined, instructions have different degrees of conciseness and were created for different audiences-some instructions are short sentences and are plm-oriented, such as prompts like "translate from english to french", while other instructions are paragraphs and are human-oriented, e.g., those annotation guidelines in amazon mturk; on the other hand, the same task is likely to be explained by different end-users with instructions of varying textual expressions. for example, "translate from english to french" can also be expressed as "given an english sentence, translate it into french". therefore, a robust system for task generalization is expected to handle any new tasks regardless of the variability of instructions. however, despite the limited earlier work studying the plm robustness in terms of prompts @xcite , it is still unclear how robust a pretrained instruction learning system can handle broader types of instructions, including human-oriented as well as plm-oriented ones, and their cross-type generalization. this work focuses on human-oriented instructions and explores the system robustness when the instructions of new tasks are (i) manipulated, e.g., words removal, words replacement, sentence shuffle, etc., (ii) paraphrased with dramatic surface change, or (iii) from different levels of conciseness, e.g., training tasks have human-oriented instructions while testing tasks are equipped with plm-oriented prompts. to get the answers for the above three threads of instruction variability, we finetune a t5 (raffel et al., 2020) model on the train of super-naturalinstru @xcite , a dataset with the largest number of nlp tasks and each task is described by an amazon-mturk-style instruction, and test it on (i) the test of super-naturalinstru, where we modify the original instructions with word-level, sentence-level and instruction-level perturbations, (ii) a newly crowdsourced dataset, para-instructions, with 23 unseen tasks and each has 4 distinct human-oriented instructions in the same format as the test of super-naturalinstru, and (iii) a new dataset diverseprompt @xcite , in which each task has prompt-style instructions. to our knowledge, this is the first work that systematically studies how robust a plm is when it is supervised by instructions with different factors of variability. our experiments show that: our work is related to prompts (a special case of instruction learning), cross-task generalization, and the study of robustness under adversarial attack. prompt as instruction. brown et al. (2020a) attempted to unleash the power of plms, such as gpt-3 (brown et al., 2020b), through prompts. since they discovered prompts, many studies have followed that direction in various ways, with robustness being an aspect that cannot be ignored. liu et al. (2021) introduced the effectiveness of prompt learning and the wide application prospects. min et al. (2022) explored how the model learns prompts and what aspects of the prompt contribute to the final task performance. webson and pavlick (2022) tried to figure out whether promptbased models truly understand the meaning of their prompts. zhao et al. (2021) investigated ways to improve the stability of prompt-based models. bach et al. (2022) created a platform for the production, distribution, and use of natural language prompts. despite the large number of papers on prompts, little attention has been paid to studying the robustness of systems under prompt learning. our work has a broader vision that considers the robustness in terms of plm-oriented prompts as well as more natural human-oriented instructions. instruction-driven task generalization. recent work has worked on using the information in task instructions to allow plms to respond to inputs that match the task instructions after they have understood task instructions. efrat and levy (2020) tested gpt-2 @xcite to understand real-world mturk instructions to annotate some popular datasets, and concluded that gpt-2 works poorly. @xcite collected more than 60 distinct nlp tasks with mturk instructions consisting of items like title, definition, things to avoid, etc., and claimed that bart @xcite and gpt-3 benefit from instructions to generalize across tasks. @xcite further extended this dataset to cover over 1.6k crosslingual tasks, each with a piece of natural language instruction. more work in this thread can be found in @xcite , which provides a comprehensive survey for various instruction learning. the robustness studied in this work is also based on instruction-driven task generalization; however, our emphasis lies on analyzing the variability in system performance as opposed to actively enhancing overall system performance. robustness under adversarial attack. there is a lot of work on adversarial attacks in nlp systems, definition in this task, you will be shown an incorrect english sentence. you need to generate a corrected form of the input sentence. positive input the car's wheel are loose. output the car's wheel is loose. negative input this way is the way to go. output this way may be the way to go. ## experiment this work studies the robustness of learning from task instructions from three scenarios: (i) the system robustness when dealing with instructions that are deliberately perturbed (section 3.1); (ii) the system robustness when a task confronts diverse instructions that are written by different annotators (section 3.2); (iii) the system robustness when it tests on tasks that have instructions with distinct abstractiveness (section 3.3). the following subsections present our experiments about the three dimensions of robustness study, respectively. the pretrained instruction learning model. to test the robustness of a pretrained model that learned nlp tasks from instructions, we choose the t5 model @xcite with 3b and 11b parameters finetuned on the training set of super-naturalinstru @xcite . super-naturalinstru consists of 1,616 nlp tasks in total and each task is explained by four items: definition (a short paragraph describing the task semantics), positive examples (a couple of examples with inputs, correct outputs, and explanations), negative examples (a couple of examples with inputs, incorrect outputs, and explanations), and instances (a large set of instances with inputs and correct outputs). one sample is shown in original instruction in this task, you will be shown an incorrect english sentence. you need to generate a corrected form of the input sentence. word-level delete words in this ///// task, you //// will be /////// shown an incorrect english sentence. you need to generate a corrected ///// form of //// the input sentence. delete stopwords // in //// this task, //// you///// will//// be shown // an incorrect english sentence. ///// you need // to generate // a corrected form // of///// the input sentence. insert words in this , task, , you will be shown an incorrect ( english input sentence. you need to generate a corrected form of the english input sentence. replace words in this case, you will be shown an incorrect english language. you need to generate a corrected form of the input sentence. shuffle words a you generate english incorrect be need task, in the will this you sentence. shown to sentence. input an form of corrected sent-level repeat sentences in this task, you will be shown an incorrect english sentence. you need to generate a corrected form of the input sentence. you need to generate a corrected form of the input sentence. shuffle sentences you need to generate a corrected form of the input sentence. in this task, you will be shown an incorrect english sentence. instruction-level shuffle in this task, you are given a sentence and a question, you would be asked to create the answer which is contained in the sentence provided. as the data for training the instruction learning model, the train of super-naturalinstru has 1,462 tasks.