Auto-Instruct: Automatic Instruction Generation and Ranking for Black-Box Language Models
Authors: Zhihan Zhang
Shuohang Wang
Wenhao Yu
Yichong Xu
Dan Iter
Qingkai Zeng
Yang Liu
Chenguang Zhu
Meng Jiang
Venue: EMNLP 2023 Findings (2023)
Keywords: Large Language Model
Instruction Generation
Instruction Ranking
Multi-Task Learning
In-Context Learning
TL;DR: An automatic solution for instruction generation and ranking for in-context learning on black-box LLMs

Abstract: Large language models (LLMs) can perform a wide range of tasks by following natural language instructions, without the necessity of task-specific fine-tuning. Unfortunately, the performance of LLMs is greatly influenced by the quality of these instructions, and manually writing effective instructions for each task is a laborious and subjective process. In this paper, we introduce Auto-Instruct, a novel method to automatically improve the quality of instructions provided to LLMs. Our method leverages the inherent generative ability of LLMs to produce diverse candidate instructions for a given task, and then ranks them using a scoring model trained on a variety of 575 existing NLP tasks. In experiments on 118 out-of-domain tasks, Auto-Instruct surpasses both human-written instructions and existing baselines of LLM-generated instructions. Furthermore, our method exhibits notable generalizability even with other LLMs that are not incorporated into its training process.

Auto-Instruct:
Automatic Instruction Generation and Ranking for Black-Box Language Models
Zhihan Zhang
Shuohang Wang Wenhao Yu Yichong Xu Dan Iter, Qingkai Zeng*, Yang Liu Chenguang Zhu Meng Jiang"
University of Notre Dame
O Microsoft Azure Al zzhang23@nd. edu
Abstract
Seed Instruction
Candidate instructions
Under ectiveives courectiy English
diverse styles
one sentence Instruction
Large language models (LLMs) can perform wide range of tasks by following natural lan- guage instructions, without the necessity of lask-specific fine-tuning- Unfortunately, the performance of LLMs is greatly influenced by the quality of these instructions, and manually writing effective instructions for each task is laborious and subjective process. In this paper, we introduce Auto-Instruct, a novel method to automatically improve the quality of instruc- tions provided to LLMs. Our method lever- ages the inherent generative ability of LLMs to produce diverse candidate instructions for given task, and then ranks them using a scor- ing model trained ing NLP tasks. In experiments on 118 out- of-domain tasks, Auto-Instruct surpasses both human-written instructions and existing base- lines of I.I M--ennerated instructions. Further- more, our method exhibits notable generaliz- ability even with other LLMs that are not incor- porated into its training process.'
Input: Which sentence the correct ad edjeetive ooder.
Aanerate
onepaanggaph Instructio
(A) ruboer temble ship
step-bystep Instruction
(B) tom rubbes dlip
explapieeggalninng instr uction
Output: (B)
Demonstrations
Instruction Generation
Candidate instructions
575 training tasks
Selected Instruction
Which semoonor has the
FLAN-TS
Trank select
In this tosk, you will be given two sertincces with adjectioss...
correct afjective order
(A) grum chair
green
Instruction Ranking
Test Example
Selected instruction
Io you by pivea two seattences with adjectives...
Finference
Which senseriee has the cornect adjeztive coder. (A) yruu new chair greee clair Test Example
concatenate
a variety of 575 exist-
Downstream Inforence
The Auto-Instruct pipeline. We first prompt the LLM to generate diverse set of candidate instruc- tions with different styles, and then train a model to rank and select the most effective instruction for a given example. Finally, the selected instruction is used to prompt the LLM to infer the output for this example.
Figure I:
1 Introduction
examples at hand, a well-crafted instruction is im- perative in enabling the LLM to grasp the required input-output mapping to complete the task.
Instruction- tunded large language models (LLMs) have gained considerable popularity as solutions to a myriad of NLP tasks, owing to their proficiency in interpreting natural language instructions (Wei et al., a 2021; Chung et al., 2022; Ouyang et al., 2022; Taori et al., 2023). As fine-tuning LLMs often be- comes unfeasible, instructions play an increasingly crucial role in prompting such black-box LLMs. Especially in the true true few-shot 2 setting (Perez et al., 2021) where the user aims to tackle new task with only a basic task description and a few data
Despite the significance of instructions, the pre- vailing approach when using black-box LLM on new task remains to be manual prompt engineer- ing (White et al., 2023; Mishra et al., 2023). Such an approach, however, is not only time-consuming but also tends to yield suboptimal instructions. Against this backdrop, efforts have been made to empower LLMs to generate instructions automat- ically (Honovich et al., 2022; Zhou et al., 2022; Singh et al., 2022). These approaches feed the LLM a handful of examples and prompt it gen- erate an instruction based on these demonstrations. While such methods showease the L.LM's capa- bility to generate coherent instructions (Honovich et al., 2022), only generating a single instruction
This work was done when Zhiban was an intern at Mi- crosoft Azure AL.
"Model and code are available at hpt: com/ ytyz1 1 Saarchh/Atoo-Insttte
"A scenario where no additional training or validation data are available for hyperparameter tuning and prompt selection, in addition to the sew-shot examples (Perez et al., 2021).

---

cannot guarantee reliable performance for unseen examples in the given task. As a straightforward solution, validation sets have been used to evalu- ate the effectiveness of a set of sampled instruc- tions (Zhou et al., 2022; Singh et al., 2022), but this is impracticable for many tasks defined under the true few-shot setting (Suzgun et al., 2022). Be- sides, these approaches have primarily been tested simple tasks where basic instructions are already sufficient, such as arithmetic operations or senti- ment classification. More complex tasks in NLP benchmarks (Wang et al., 2022), which necessi- tate careful instruction engineering, remain largely unexamined for an automatic solution.
2 Related Work
The choice of instructions plays a pivotal role in effectively utilizing LLMs. To this end, range of approaches has been implemented, with parametric optimization and LLM-based generation standing out as prominent methods. Parametric optimiza- tion primarily involves utilizing parameters to tune instructions (Shin et al., 2020; Shi et al., 2022: Deng et al., 2022). For instance, Shin et al. (2020) employed a gradient-based search over a predeter- mined length of discrete tokens as the instruction. Shi et al. (2022) further improved this approach by preserving the readability of the sampled tokens through a perplexity constraint. As a more flexible approach, Deng et al. (2022) optimized instruction generation through reinforcement learning, with rewards computed based on the LLM output. How- ever, these strategies require access either LLM parameters
To address the aforementioned challenges, we propose Auto-Instruct, a novel approach to auto- matically generate and rank instructions for black- box LLMs across various NLP tasks, under the true few-shot setting. For each downstream task, we first prompt the LLM sample variety of candidate instructions, based on a basic seed in- struction and few-shot demonstrations. We collect a diverse candidate set by specifying the expected style of each instruction. Recognizing the variable performance of LLMs across different instructions, coupled with the lack of validation data for pre- emptive instruction selection, train scoring model to rank and select the most appropriate in- struction for each downstream test example. To ensure necessary generalizability in the few-shot setting, the model is trained on 575 exisiting NLP tasks before being deployed for out-of-domain test tasks. Finally, the selected instruction is used to prompt the LLM for downstream inference.
training set for optimization, mak- ing them less applicable to black-box LLMSs with only a limited number of available examples. More- over, instructions generated by these methods often lack fluency or even become gibberish, thereby compromising their interpretability.
In contrust, the LLM-based generation thread selects instructions by directly prompting the LLM (Honovich et al., 2022: Zhou et al., 2022; Singh et al., 2022). For example, Honovich et al. (2022) were among the first to reveal that LLMs could write an instruction for given task after ob- serving just few demonstrations, and Zhou et al. (2022) improved the quality of the generated in- structions by selecting the best performed one on the validation data. iPrompt (Singh et al., 2022) is the most capable method so far with its itera- tive generation and validation process for selecting instructions. Nevertheless, these approaches still necessitate validation set for instruction ranking. and the instructions they generate typically under- perform compared to those written by humans. Besides the choice of instructions, researchers have also explored other orthogonal directions of improving LLM prompts, such as the selection of in-context demonstrations. Some works focused on identifying the most suitable demonstrations from training examples (Rubin et al., 2022; Lu et al., 2022a; Wang et al., 2023a) and their optimal order- ing (Lu et al., 2022b) in the few-shot prompt. Other studies examined the engineering and selection of reasoning chains that are paired with the few-shot demonstrations on multi-step reasoning tasks (Wei
In experiments with OpenAl's fext-davinci-003, Auto-Instruce yields remarkable performance on 118 out-of-domain tasks from Super Natural In- structions (SuperNI; Wang et al., 2022) and Big Bench Hard (BBH; Suzgun al., 2022). Showing robust generalizability in out-of-domain scenarios, Anto-Instruct outperforms human- written seed in- structions, the state-of-the-art instruction genera- tion approach iPrompt (Singh et al., 2022), and vari- ous baselines of prompting the LLM for instruction selection. Moreover, Into-ustt exhibits impres- sive performance in the zero-shot setting and in generalization other LLMs (i.e., ChatGPT and GPT-4). Our study underlines that automatically generating and ranking instructions is promising approuch for leveraging the power of black-box LLMs effectively.
human-written

---

al., 2022; Zhang et al., 2022b; Ye and Durrett, 2023: Liang et al., 2023b). We reserve the explo- ration of integrating these orthogonal techniques with our approach to holistically optimize the entire LLM prompt for future work.
Write step-by-step Instruction on how to solve the following task.
Task: (seed instruction]
Examples:
Input: [input of demonstration #1]
Output: [output of demonstration #1]
3 Problem Formulation
Input: [input of demonstration #t]]
In this work, we focus on the true few-shot set- ting where a user aims to tackle a new task with a black-box LLM. While it is easy to come up with handful of examples and basic description, the user may not have insights into what kind of in- structions would be effective for unseen examples. Hence, given the few-shot examples as demonstra- tions and the basic description as a seed instruction, our goal is to automate the process of creating a more effective instruction for the given task.
Output:
[output demonstration #t]
Instruction:
Figure 2: The meta meta-promn prompt that guides the LLM to generate a step-by-step instruction for the given task. Other meta-prompts are shown in Appendix E.
4.1 Instruction Generation
As mentioned in $3, leverage basic human- written task description as the seed instruction 1 and prompt the black-box LLM to gener- ate a number of candidate instructions {1f))=1- Specifically, in the few-shot setting, we prompt the LLM to generate candidate instructions 1e ~ P(-IT, (a4, )=1) based on the seed in- struction and few-shot demonstrations, Previous approaches (Zhou et al., 2022; Singh al., 2022) only utilized a single meta-pronne meta-prompt and collected candidate instructions via token sampling. Usually, such sampled instructions only show minor vari- ations in phrasing rather than substantial content diversity. Moreover, their quality recursively rely on the arbitrary choice of the meta peeaaproomp, which transfers the unreliability of manual instruction en- gineering to manual meta-prompy engincering.
We formulate our problem following the con- ventional practices of in-context learning (Dong al., 2023). In the aforementioned few-shot set- ting, the prompt to query a black-box LLM com- prises an instruction the test input x, and a few input-output pairs as demonstrations { d12 Fi=1- The LLM is expected to generate an output rv P(-JI, { of "e .). This work aims to automat- ically find a superior instruction I' based on the human- written seed instruction 1", thereby circum- venting the need for substantial manual engineer- ing. Besides, we also explore the zero-shot setting where no demonstrations are given to the LLM. Despite the instruction potentially having mul- tiple ways of integrating with the demonstrations and the test input, to reduce the complexity of the problem, we format the whole prompt in the order x). This aligns with the
In our improved approach, we curate set of meta-prone reta-prompts stimulate the LLM to sample di- verse candidate instructions by defining different required styles of the instruction. These meta- prompts include:
of z1. vf.... Id va.z). convention of problem-solving where the task is first outlined, followed by the provision of data examples, and the test input is finally provided. In practice, we use n for all tasks.
1. Write instruction on how to solve the fol- lowing task in one sentence.
4 Auto-Instruct
2. Write an instruction on how to solve the fol- lowing task in one paragraph.
Auto-Instruct is composed two steps: instruction generation and instruction ranking. We first prompt the black-box LLM to generate a diverse set of can- didate instructions ($4.1) !) for each downstream task. Next, we train scoring model to rank all candidate instructions for each given test example, as differ- ent examples can benefit from different instructions ($4.2). Then, the top-ranked instruction is selected to prompt the black-box LLM on that specific test example for downstream inference.
3. Write step-by-step instruction on how solve the following task.
4. Write an instruction on how to solve the fol- lowing task. The instruction must include the explanations of the given examples.
Alongside these meta-prompts, we also bring in human-written instructions from existing NLP tasks as demonstrations to guide the generation of
"The prompt for the L.M to generate instructions.

---

tion will probably lead suboptimal performance due to the LLM's sensitivity to the phrasing of the instructions. This instability is particularly ev- ident in the zero-shot setting due to the lack of demonstrations to assist prediction. In Figure 3, we calculate the standard deviation of LLM per- formance using different instructions, after having evaluated all instructions for each downstream task. This indicates the expected performance fluctua- tion when substituting one instruction for another. The median standard deviation across all tasks are 3.1 and 4.2 points in ROUGE-L for few-shot and zero-shot settings respectively on SuperNI, and the upper quartiles are 5.7 and 6.9 points respectively. The choice of instruction even causes double-dige performance fluctuation many tasks. Therefore, the development of method rank and select instructions becomes an essential undertaking.
Standard Devistion of Performance
15
10-
SuperNi few-shot SuperN zem--hot
BBH few-shot
BBH zerowshot
Box plot showing how much the LLM per- formance varies with different instructions, tested on OpenAl's text-davinci-033. Performance is evaluated by ROUGE-L on SuperNI and Accuracy BBH. Each value represents the standard deviation of LLM perfor- mance across all generated instructions on single task.
Figure 3:
4.2 Instruction Ranking
instructions. Intuitively, prompt the LLM to emulate the style of human-written instructions in these demonstration tasks. We source demonstra- tion tasks with their instructions from our training tasks in SuperNI, grouping them into 3 clusters based on the length of their instructions, as to guide the LLM to generate instructions of different granularities. Figure 2 provides example of the meta-prompt #3. Other meta-prompts are detailed in Appendix E.
In true few-shot setting, demonstrations are in- adequate to reflect the effectiveness of candidate instructions due the small sample size. To cir- cumvent this limitation, we train a generalizable instruction ranking model across variety NLP tasks, and subsequently apply it to each test exam- ple in out-of-domain tasks. Intuitively, this model is trained to rank instructions against their down- stream performance on the LLM, i.e., to assign higher scores to more effective instructions.
Based on these distinct meta- meta-prommps (i.e., style-specific meta peotappoomps + groups of demon- stration tasks), we sample 3 instructions under each meta-prompt via nucleus sampling (Holtzman et al., 2020). Including the original seed instruction, collect total of 22 candidate instructions for each task. As result, we create a diverse and com- prehensive set of candidate instructions, thereby reducing the randomness brought by the nuances of different protpss
4.2.1 Model
Owing to the proven generalizibility of the T5 model family (Raffel et al., 2020; Sanh et al., 2022), we start from the instruction-tuned FLAN- T5-Large model (Chung et al., 2022) and train it with our instruction ranking objective. Given a specific example (r, y) where y the ground-truth output, as well as an arbi- trary candidate instruction Is, the model predicts score Qrs(I", x) as an estimate of the instruc- tion's 's effectiveness on the example. Leveraging the instraction-followingg
the input and
In the zero-shot setting, due to the absence of demonstrations, the LLM is prompted to generate the candidate instruction _ P(-[1*) based solely on the seed instruction. Besides, the example- explaining meta-prompl is removed. As we demon- strate in $5.4.5, even without the aid of demonstra- tions, our style-specific meta peta-proompss still enable the LLM to generate informative instructions.
instruction- following nature of FLAN-T5, we give the following prompt to the ranking model:
Example: x. Input: 15, Is this good instruction to solve the example?
Qrs(I9,x) x)) is then caleulated as the logit of the "yes" token at the starting position of the decoder. Additionally, we obtain the downstream perfor- mance of Ie by calculating the ROUGE-L score between the LLM's predicted output ÿ (when I" is
4.1.1 Instability Under Different Instructions
While LLMs are capable of generating meaningful instructions, relying on a single generated instruc-

---

used as the instruction) against the groud-truth out- put y, denoted r(y. (). The model is then trained with list-wise loss to align the scores QTs (7, a)) of all candidate instructions with their correspond- ing downstream performance r(y, ú), while consid- ering relative superiority among different instruc- tions. Specifically, we first normalize both the list of predicted scores (Is .x) and the list of down- stream performance r(y. 5) by applying softmax across all candidate instructions, and then compute the KL-divergence between these two normalized distributions as the training loss:
presents diverse set of tasks spanning common- sense QA and math problems. Average ROUGE- L and exact-match accuracy are used for evalua- tion on SuperNI and BBH, respectively. Our main experiments are conducted using OpenAl's text- davinci-003 for instruction generation and down- stream inference. We also explored the instructions generated by ChatGPT (gpt-3.5-turbo) GPT- 4 (OpenAI, 2023) in $5.4.1.
In the zero-shot setting. the ranking model is sep- arately trained on data where downstream ROUGE scores of candidate instructions are likewise ob- tained under zero-shot prompting. For zero-shot classification tasks, we append additional format- ting instructions to the seed instruction to narrow down the answer options in both instruction gener- ation and downstream inference. Additional exper- imental settings can be found in Appendix B.
Σ ILL IKL((L (o(r (v. 0)) || (Q1s (1" (.a.))):
c
B
(2,y)EB
where 9 PLLM(-H1 {2] oi +E
Note that B is batch of examples and is the softmax function. During testing, given spe- cific test example, among all candidate instructions, we select the 1 that achieves the highest score (Is x) as the final instruction, and prompt LLM with it to obtain the desired output.
5.2 Baselines
As baselines in our experiments, we first con- sider three alternative approaches based solcly on prompting the LLM:
4.2.2 Training Data
(1) Cross- Vols--Valiation.. We leverage the 3-shot demonstrations as validation data to rank the in- structions, with each one acting as the test example iteratively while the other two serve demonstra- tions. The ROUGE-L score (or accuracy for BBH) is used as the primary ranking criterion, and the peg-pobbability of the ground-truth output com- pared as tiebreaker. The instruction selected by the demonstrations is then applied on all test examples within the same task.
To train such a ranking model with generalizabil- ity to out-of-domain tasks. we categorize the tasks in the SuperNI benchmark by their task type (e.g., QA, sentiment analysis, etc.) and group these cate- gories into training and test sets. We exclude tasks involving non-English languages or those with ex- cessively long inputs. To avoid data leakage, we also exclude tasks from the training data which are sourced from the same dataset as any test task. This yields 575 tasks for training and 91 for testing. We sample up to 400 examples from each train- ing task, which leads to 122k in total. Additional data pre-processing and filtering methods utilized accelerate the training process can be found in Appendix A.
(2) LM Selection. We directly prompt the LLM itself to select instruction by enumerating all candidate instructions in a single prompt. We num- ber the instructions and ask the LLM to generate the number of the instruction it deems most suitable to each test example.
(3) On-the-fly Generation. As a simplified variant without instruction ranking, the model is asked to directly generate an instruction for each test ex- ample. The generated instruction is then used to prompt the LLM for the same example.
5 Experiments
5.1 Settings
To evaluate our approach under the true few-shot setting, we test it on a variety of out-of-domain tasks- - 91 from SuperNI (Wang et al., 2022) and 27 from BBH (Suzgun et al., 2022), where there is overlap between task categories in training and testing. The SuperNI test set comprises both clas- sification and generation tasks, e.g., commonsense classification, information extraction, etc*. BBH
Furthermore, we consider iPrompt (Singh et al., 2022), the existing state-of-Ue of-the--rttttttt approach in opt- mizing instructions with LLMs. iPrompt iteratively generates instructions until it cannot find one with better performance on a validation set. To evaluate
'The original authors of SuperNI found ROUGE-L posi- tively correlated to accuracy on classification tasks, so average ROUGE-L is applicd for simplicity.
'The full list of SuperNI test tasks is in Appendix G.

---

Few-shot
Zero-shot
Methods
Generation
Ranking
SuperN1
BBH
SuperN1
BBH
Empty Instruction*
None
None
57.03
51.18
35.86
45.12
Human Instruction
Human
None
60.94
50.30
46.81
45.59
Random Selectiont
LLM
Random
61.61
50.88
45.80
45,98
iPrompt*
LLM (iterative)
Examples
57.08
50.46
iPrompt+*
LLM (iterative)
Examples
61.13
50.82
"ooss-Valddttion**
LLM
Examples
62.02
51.20
LM Selection
LLM
LLM
61.69
51.96
44.19
45.05
On-the-fly Generation
LLM
None
61.03
51.38
45.85
45,47
Auto-Instruet
LLM
Trained Model
64.35
52.04
49.50
47.35
Table I: Results on SuperNI (91 tasks) and BBH (27 tasks) under the few-shot and zero-shot setting respectively. We report ROUGE-L SuperNI and accuracy on BBH. Methods with * apply the same instruction for certain task, while methods with can select different instructions for different examples. iPrompt iteratively generates and ranks candidate instructions, while other methods adopt generate-then-rant pipeline. iPrompt+ and Cross Validation not applicable under the zero-shot setting due to the need of validation examples. Detailed results on SuperNI of different task categories can be found at Appendix D.1.
note that iPrompt.
iPrompt under the true few-shot setting, con- duet its validation the 3-shot demonstrations. Besides, since the original iPrompt generates in- structions based on the examples without any task description, for a fair comparison, we implement an iPrompt+ baseline that uses a similar meta-prompt to ours with the seed instruction (See Appendix C for details). In addition, we evaluate the perfor- mance of not using any instruction (Empty In- struction), directly using the Human--ritten seed instruction (Human Instruction) or randomly se- lecting an instruction from the generated candidates (Random Selection) on each task.
surpass their human wwrtten counterparts aver- age, indicated by the random selection scores. Although humans may have prior knowledge of some examples when they write the instructions, the LLM, not given any demonstrations in the zero- shot setting, generates instructions of comparable quality to those written by humans. Nevetheless, neither random selection nor directly generating a single instruction (i.e., on-the-fly generation) signif- icantly improves over the human- human-written written bascline. This aligns with the instability of the LLM perfor- mance across different instructions as discussed in Figure 3, which indicates further instruction rank- ing is still essential.
5.3 Results
Simply prompting the LLM or using the vali- dation data are not reliable in the low-resource setting. Although offering the convenience of not training any models, both directly prompting the LLM (LM selection) and using few-shot demonstra- tions for validation (iPrompt and crossvvalidation) fail to deliver consistently improved results com- pared to random selection. This highlights that (1) the LLM itself lacks clue of the expected down- stream performance of different instructions; (2) the volume of validation data must be substantial enough to effectively estimate the performance of instructions on the test data, which brings high cost in many realistic scenarios.
The overall results of SuperNT and BBH are shown in Table 1, where scores are averaged across all tasks. Auto-Instruct shows notable consistency and generalizability in out-of-domain scenarios, sur- passing all baselines across different benchmarks and settings. Key findings outlined below.
The LLM shows competitive ability in gener- ating effective instructions, yet ranking is still necessary. In alignment with previous work (Zhou et al., 2022; Singh et al., 2022), the LLM is able to generate effective instructions for various tasks, Our style-specific meta-prompts enables the LLM produce a diverse set of instructions cater to varied scenarios where different tasks may favor different styles of instructions. the few-shot setting, the L.L-ggeneraeed instructions already
Our trained instruction ranking model is the most effective approach to select instructions so far. Although the data and instructions for out-of-

---

Methods
ChatGPT
GPT-4
Selection Acc
Win Rate
Methods
Top1
Top5
vs. Empty
vs. Human
Few-shot, instructions from text 1ex--davinci-003
Human
45.25
70.35
22.43
Human
60.39
67.31
Random
46.76
70.13
24.95
16.87
Random
60.44
67.07
Cross- Validation
47.61
68.73
26.77
20.74
Auto-Instruct
62.88
69.45
LM Selection
47.53
71.07
25.17
17.93
Few-shot, instructions from ChatGPT/GPT-4
Auto-Instruct
52.54
73.10
29.51
23.89
Human
60.39
67.31
Table 3: Evaluation of instruction ranking on silver la- bels. Left: we evaluate the percentage of cases where the selected instruction is the best (top-I 1) or is among top-5 candidates. according to the actual downstream perfor- mance. We note that there could be multiple instructions sharing the best score. Right: we check the percentage of selected instructions that outperform either the empty instruction or the human-writ -artttn ones.
Random
60.44
66.77
Auto-Instruct
62.32
68.16
sero-shot, instructions from ChaiGPT/GPT-4
Human
47.77
54.11
Random
46.22
53.06
Auto-Instruct 49.04
55.53
Table 2: SuperNI results of transferring Auto-Instruct to ChatGPT and GPT-4, using either (1) instructions generated by lext-davinci-003, or (2) instructions gener- ated by the same model as downstream inference (i.e., ChatGPT or GPT-4). The instruction ranking model is still the one trained on text- parddavinci-000 instructions.
GPT-4. Furthermore, our instruction ranking model is able rank instructions generated by ChatGPT or GPT-4 under both few-shot and zero-shot scenar- ios, despite not having seen any instruction created by these LLMs during training. Improved results can also be seen when transferring Auto-Instruee to LLaMA-2-chat (Touvron et al., 2023), a recent open-source LLM, as shown in Appendix D.2. As a conclusion, despite variations in phrasing across in- structions generated by different LLMs, the under- lying pattern determining instruction effectivenesss is transferable, although the largest improvement is still seen in the same-LLM experiments. Suffice to say, our trained instruction ranking model can be directly applied to select instructions for other LLMs without the need of re-training.
domain tasks are not seen by the ranking model, it exhibits promising generalizability in selecting effective instructions thanks to the training on hun- dreds of different tasks. For example, on the Su- perNI benchmark, it outperforms random selection by 4% and 8% on few-shot and zero-shot settings respectively. Besides, our complete pipeline deliv- ers a relative 6% improvement over the original human instructions in both few-shot and zero-shot numan-written written instruc- tions still need improvement in many contexts.
settings, indicating that the human-
5.4.2 Evaluation of Instruction Ranking
5.4 Analysis
To investigate the effectiveness of the instruction ranking model, we compare it with other instruc- tion selection baselines by assigning silver labels to candidate instructions, with results detailed in Table 3. First, we use the actual downstream per- formance of the candidate instructions as silver labels. Our ranking model is more capable of dis- tinguishing better instructions, as shown by an evi- dently higher accuracy of picking the top-1 or top- 5 instructions among all 22 candidates. Second, we evaluate how often the selected instruction im- proves the downstream performance in comparison to either the empty instruction or the human-written instruction. Once again, the instructions from our ranking model makes the most significant improve- ments, advancing the human- written counterparts in 7% more cases than random selection. The con-
In this section, we delve deeper into the perfor- mance of our approach by analyzing the use of other LLMs for instruction generation, the perfor- tasks, the size of training data, and mance Additional analysis of the comparison case studies. between Auto-Instruct and multi-an multi-answer ensemble is in Appendix D. These analyses are conducted in the shw- setting unless stated otherwise.
5.4.1 Generalization to other LLMs
To further test the generalizability of our approach, we transfer Auto-Instruct other LLMS by us- ing ChatGPT (gpt-3.5-turbo) and GPT-4 as down- stream inference models. As Table suggests, in- structions selected by Auto-Instruct on text- davinci- 003 are still effective if transferred to ChatGPT and

---

Methods
Unseen Tasks
Seen Tasks
5.4.4
Effect of More Training Tasks
Human
54.59
40.32
To analyze the effect of large-scale multi-task train- ing on out-of-domain generalizability, we manipu- late the number of training tasks of the instruction ranking model. Specifically, We exclude tasks from the training set by their category, L.., all tasks from selected categories
Random
55.57
39.74
Auto-Instruct
60.18
45.89
T (vs. Random)
(+8.3%
(+15.5%
Table Results on cerruuction-sessitiv test data both seen tasks (100 tasks seen in training) and unseen tasks (the same as Table 1) from SuperNI. We additionally report the relative improvement ratio the random selection baseline since the vanilla performance is not on the same scale.
removed. As shown in Fig- ure 4, the increment in the number of training tasks from additional categories is a key contributor the superior performance of our model compared to the random selection baseline. Since the per- formance has not plateaued when all tasks are in- cluded, it is plausible to expect further performance gains if more training tasks are available.
64.0
63.5
63.0
Avg. ROUGE
62.5
5.4.5 Analysis of the Selected Instructions
62.0
61.5
Figure illustrates how our selected instructions improve the original human instructions. As in- dicated by the average similarity scores, Auto- Instruct is able to provide instructions more simi- lar to the optimal ones among the candidates. As demonstrated by the scatter plot, in scenarios where the selected instruction outperforms the human in- struction, its embedding usually deviates signifi- cantly from that of the human instruction but stays close to the optimal one. These results suggest that the selected instruction refines the human-written seed instruction by progressing towards the ideal solution, while the embedding distance between the selected and seed instructions makes such improve- ment hard to achieve by pure manual engineering.
61.0
60.5
0%
25%
50%
75%
100%
% Training Tasks
Figure 4: Results of using different number of training tasks. 0% means directly using the pre-trained FLANN- T5 checkpoint in instruction ranking, which shows similar performance to random instruction selection.
sistent performance gain across all silver-label eval- uations further corroborates the superiority of our model over alternative ranking methods based on cross-validation or LM selection.
In addition, we offer case study in Figure 5 in the zero-shot setting where the LLM cannot re- fer to any demonstrations. Nevertheless, the LLM manages to generate additional examples using the knowledge gained from its extensive pre-training. These additional examples can act as demonstra- tions to create "2-shot inference" setting, Icading to a correct prediction that could not be achieved via the original zero-shot inference. Conversely, we also present an example where the L.M--genertted instruction includes hallucinated descriptions that distort the original meaning of the seed instruc- tion. The mismatch between this instruction and the test example results in its rejection by the rank- ing model. Readers may find further case studies in Appendix F.
5.4.3 Auto-Instruct on Seen Tasks
Besides the out-of-domain setting, we explore an in-domain setting where we select additional exam- to further
ples from tasks seen during training, examine the competency of the instruction rank- ing model. For fair comparison of the model's ranking abilities across different tasks, we experi- ment with enstucction-sensitiii examples, defined as examples where not all candidate instructions yield the same ROUGE score. We sample 100 ad- ditional examples from each of 100 tasks that are seen in training but not included in the dev set. As presented in Table 4, the model shows enhanced ranking ability on seen tasks due to prior exposure the instructions during training. This indicates that our approach is useful in both data-rich and data-scarce circumstances.
www. www.tbeeee... nete www.seert...ttt/ssspeeerranaaaie html

---

Case Study (Zero-Shot)
Human Instruction: Given tuple, determine whether the Head used for the Tail not. Only answer with "Yes" "No".
Generated Instruction (Selected by the Runking Model); In this tusk, you ure given a tuple which a set of two clements, Head and Tail. Your task is to determine whether the Head is used for the Tail or not. To do this, you need to consider the meaning of the Head and Tail and determine whether the Head can be used to achieve the purpose of the Tail. For example, if the Head is "hammer" und the Tail is "nailing nail",, then the answer is "Yes" because hammer can be used to nail nail. If the Head is "hammer" and the Tail is "eutting board", then the answer is "No" bocause hammer cannot be used cut board. Only answer with "Yes" or "No".
Generated Instruction (Discarded by the Ranking Model): To determine whether the Head is used for the Tail not, need compure the two elements of the tuple. If the Head the the Tail, then the answer is "Yos". If the Head is the the Tail, then the answer is "No".
Human Instruction
Auto-Instruct Answer: Yes
Test Input: Head: dental floss. Tail: provide dental hygiene.
x
Answer: No
Figure In this case, Anto-Instruct selects an instruction which "transforms" the zero-shot inference to a "2- shot" inference by providing additional examples (highlight in red), while discarding instruction that includes hallucination in the task description (highlight in blue). The human instruction is also included in ranking candidates.
the candidate instructions and select the most effec- tive one to solve a specific example. Experimental results demonstrate that our approach provides bet- ter instructions than both human-written ones and those produced by previous instruction generation approaches, as tested on 1 18 out-of-doman tasks.
40-
-20
Limitations
human
selected
best
To our knowledge, this work has the following limitations:
selected
other
-80
Due to the considerable cost associated with OpenAl models, and the limited capacity of their API interface, we only score the can- didate instructions
-20
Cosine Similarity
GPT-ada-002
MPNet-base
Human u.S. Best
89.22
73.22
moderate number of tasks described in $4.2.2. Given the sults in Figure we expect that the model could demonstrate improved generalizability if more training data with labeled instructions were available.
Into-Instruct v.s. Best
91.20
75.43
Figure 6: Above: Instruction embeddings of 5 SuperNI tasks where Auto-Instruct selected instruction performs better than human instruction, as visualized by T-SNE. "Best" refers to the instruction with the highest ROUGE score. Below: Average cosine similarity between in- struction embeddings on all SuperNI tasks. Two embed- ding models are rext-embeddinn-adee -002 from OpenAl and all-m all-mpnet- monne--bae--22 base-v2 from Sentence- TrannceTTTafffomrss"" Best viewed in color.
The scope of this study is limited to the gener- ation of instructions in English; tasks in non- English languages are not part of our training data. As a result, the model might not perform satisfactorily for non non-Eng non-English tasks. Further investigation into generating cross-lingual in- structions is left for future work.
6 Conclusion
In this work, we introduce Auto-Instruct, an au- tomatic approach of generating, ranking and se- lecting instructions, which offers solution to the high cost and subjectivity associated with human- engineered instructions. Our approach begins by prompting the L.LM to generate a diverse set of candidate instructions. Next, an instruction ranking model trained on hundreds of tasks is used to rank
Despite employing a wide range of meta- prompts, which significantly mitigates the de- pendence on prompt engineering, the phrasing of these meta- veta-prompts could still influence the quality of the instructions generated. We leave the exploration of automatically diversify the generated instructions as future work.

---

Acknowledgements
Yao Lu, Max Bartolo, Alastair Moore, Sebastian Riedel, and Pontus Stenetorp. 2022b. Fantastically ordered prompts and where to find them: Overcoming few- shot prompt order sensitivity. In Proceedings of the 60th Annual Meeting of the Association for Compu- tational Linguisties, ACI. 2022.
This work was supported by NSF 118-2119531, IIS-2137396, IIS-2142827, UIS-2234058, CCF- 1901059, and ONR N00014-22-1-2500 We thank Canwen Xu (University of California San Diego) for his valuable suggestions during paper writing.
Aditi Mishra, Utkarsh Soni, Anjana Arunkumar, Jinbin Huang, Bum Chul Kwon, and Chris Bryan. 2023, Promptaid: Prompt exploration. perturbation, testing and iteration using visual analytics for large language models. ArXiv preprint, 2304.01964.
References
Hyung Won Chung, Le Hou, Shayne Longpre, Barret Zoph, Yi Tay, William Fedus, Eric Li, Xuezhi Wang, Mostafa Dehghani, Siddhartha Brahma, Albert Web- son, Shixiang Shane Gu, Zhuyun Dai, Mirac Suz- gun, Xinyun Chen, Aakanksha Chowdhery, Sharan Narang, Gaurav Mishra, Adams Yu, Vincent Y. Zhao, Yanping Huang. Andrew M. Dai, Hongkun Yu, Slav Petrov, Ed H. Chi, Jeff Dean, Jacob Devlin, Adam Roberts, Denny Zhou, Quoc V. Le, and Jason Wei. 2022. Scaling instruction-finetee ArXiv preprint, 1416.
OpenAI. 2023. GPT-4 technical report. ArXiv preprint, 2303.08774.
Long Ouyang, Jeffrey Wu, Xu Jiang, Diogo Almeida, Carroli L. Wainwright, Pamela Mishkin, Chong Zhang. Sandhini Agarwal, Katarina Slama, Alex Ray, John Schulman, Jacob Hilton, Fraser Kelton, Luke Miller, Maddie Simens, Amanda Askell, Peter Welinder, Paul F. Christiano, Jan Leike, and Ryan Lowe. 2022. Training language models to follow instructions with human feedback. In Annual Con- ference on Neural Information Processing Systems 2020, NeurlPS 2022.
language models.
Mingkai Deng, Jianyu Wang, Cheng-Ping Hsich, Yihan Wang, Han Guo, Tianmin Shu, Meng Song, Erie P Xing. and Zhiting Hu. 2022. Riprompt: Optimizing discrete text prompts with reinforcement learning. ArXiv preprint, 2205. 12548.
Ethan Perez, Douwe Kiela, and Kyunghyun Cho. 2021. True few-shot learning with language models. In Ad- vances in Neural Information Processing Systems 34: Annual Conference on Neural Information Process- ing Systems 2021, NeurlPS 2021.
Qingxiu Dong, Lei Li. Damai Dai, Ce Zheng, Zhiyong Wu, Baobao Chang, Xu Sun, Jingjing Xu, Lei Li, and Zhifang Sui. 2023. A survey for in-context learning. ArXiv preprint, 2301.00234.
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- exxt-to-text trans- former. The Journal of Machine Learning Research, 21.
Ari Holtzman, Jan Buys, Li Du, Maxwell Forbes, and Yejin Choi. 2020. The curious case of neural text degeneration. 8th International Conference on Learning Representations, ICLR 2020.
Ohad Rubin, Jonathan Herzig, and Jonathan Berant. 2022. Learning to retrieve prompts for in-context learning. In Proceedings of the 2022 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies. NAACL-HLT 2022.
Or Honovich, Uri Shaham, Samuel R. Bowman, and Omer Levy. 2022. Instruction induction: From few examples natural language task descriptions. ArXiv preprint, 2205.10782
Zhenwen I Liang, Dian Yu, Xiaoman Pan, Wenlin Yao. Qingkai Zeng, Xiangliang Zhang, and Dong Yu. 2023a. Let gpt be a math tutor: Teaching math word problem solvers with customized exercise generation. In Proceedings of the 2023 Conference on Empirical Methods in Natural Language Processing, EMNLP 2023.
Victor Sanh, Albert Webson, Colin Raffel, Stephen H. Bach, Lintang Sutawika, Zaid Alyafcai, Antoine Chaffin, Arnaud Stiegler. Arun Raja, Manan Dey, M Saiful Bari, Canwen Xu, Urmish Thakker, Shanya Sharma Sharma, Eliza Szezechla, Taewoon Kim, Gunjan Chhablani. Nihal V. Nayak, Debajyoti Datta, Jonathan Chang. Mike Tian-Jian Jiang, Han Wang, Matteo Manica, Sheng Shen, Zheng Xin Yong. Harshit Pandey, Rachel Bawden, Thomas Wang, Tr- ishala Neeraj. Jos Rozen, Abheesht Sharma, An- drea Santilli, Thibault Févry, Jason Alan Fries, Ryan Techan, Teven Le Scao, Stella Biderman, Leo Gao, Thomas Wolf, and Alexander M. Rush. 2022. Multi- task prompted training enables zero-shot task gener- alization. In The Tenth International Conference on Learning Representations, ICLR 2022.
Zhenwen Liang, Dian Yu, Xiaoman Pan, Wenlin Yao, Qingkai Zeng, Xiangliang Zhang, and Dong Yu. 2023b. Mint: Boosting generalization in mathe- matical reasoning via multi-view fine-tuning, ArXiv preprint, 2307.07951.
Pan Lu, Liang Qiu, Kai- Wei Chang, Ying Nian Wu. Song-Chun Zhu, Tanmay Rajpurohit, Peter Clark, and Ashwin Kalyan. 2022a. Dynamic prompt learn- ing via policy gradient for semi-structured mathemat- ical reasoning. ArXiv preprint, 2209. 109991161 14610. 10.
Noam Shazeer and Mitchell Stem. 2018 Adafactor: Adaptive learning rates with sublinear memory cost.

---

In Proceedings of the 35th International Conference on Machine Learning. ICML 2018, Proceedings of Machine Learning Research.
models: Explaining and finding good demonstrations for in-context learning. ArXiv preprint, 2301.11916.
Xuezhi Wang, Jason Wei, Dale Schuurmans, Quoe V. Le. Ed H. Chi, Sharan Narang, Aakanksha Chowd- hery, and Denny Zhou. 2023b. Self-consisteney im- proves chain of thought reasoning in language mod- els. In The Eleventh International Conference on Learning Representations, ICLR 2023.
Weija Shi, Xiaochuang Han, Hila Gonen, Ari Holtzman, Yulia Tsvetkov, and Luke Zettlemoyer. 2022. Toward human readable prompt tuning: Kubrick's the shining is a good movie, and a good prompt too? ArXiv preprint, 2212. 10539.
Taylor Shin, Yasaman Razeghi, Robert L Logan IV, Eric Wallace, and Sameer Singh. 2020. Autoprompt: Eliciting knowledge from language models with au- tomatically generated prompts. In Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing, EMNLP 2020.
Yizhong Wang, Swaroop Mishra, Pegah Alipoormo- labashi, Yeganeh Kordi, Amirreza Mirzaei, Atharva Naik, Arjun Ashok, Arut Selvan Dhanasekaran, An- jana Arunkumar, David Stap, Eshaan Pathak, Gi- annis Karamanolakis, Haizhi Gary Lai, Ishan Puro- hit, Ishani Mondal, Jacob Anderson, Kirby Kuz- nia, Krima Doshi, Kuntal Kumar Pal, Maitreya Pa- tel, Mehrad Moradshahi, Mihir Parmar, Mirali Puro- hit, Neeraj Varshney, Phani Rohitha Kaza, Pulkit Verma, Ravsehaj Singh Puri, Rushang Karia, Savan Doshi, Shailaja Keyur Sampat, Siddhartha Mishra, Sujan Reddy A. Sumanta Patro, Tanay Dixit, and Xudong Shen. 2022. Supprrnatuualiinstruciii cralization via declarative instructions on 1600+ NLP tasks. In Proceedings of the 2022 Conference on Empirical Methods in Natural Language Processing. EMNLP 2022.
Chandan Singh, John X. Morris, Jyoti Aneja, Alexan- der M. Rush, and Jianfeng Gao. 2022. iprompt: Ex- plaining data patterns in natural language via inter- pretable autoprompting. ArXiv preprint, 2210.01 848.
Mirac Suzgun, Nathan Scales, Nathanael Schärli, Se- bastian Gehrmann, Yi Tay, Hyung Won Chung, Aakanksha Chowdhery, Quoc V. Le, Ed H. Chi, Denny Zhou, and Jason Wei. 2022. Challenging big-bench tasks and whether chain-of-thouge can solve them. ArXiv preprins, 12.0.......
Gen-
Rohan Taori, Ishaan Gulrajani, Tianyi Zhang, Yann Dubois. Xuechen Li. Carlos Guestrin, Percy Liang, and Tatsunori B. Hashimoto. 2023. Stanford alpaca: An instruction- nossruction-folloiing llaaa model. https:// gi thub. cow comm/tatsu-labb
Jason Wei, Maarten Bosma, Vincent Zhao, Kelvin Guu, Adams Wei Yu, Brian Lester, Nan Du, An- drew M Dai, and Quoe V Le. 2021. Finetuned lan- guage models are zero-shot learners. ArXiv preprint. 2109.01652.
plca.
Hugo Touvron, Louis Martin, Kevin Stone, Peter Al- bert, Amjad Almabairi, Yasmine Babaei, Nikolay Bashlykov, Soumya Batra, Prajjwal Bhargava, Shruti Bhosale, Dan Bikel, Lukas Blecher, Cristian Canton- Ferrer, Moya Chen, Guillem Cucurull, David Esiobu, Jude Fernandes, Jeremy Fu, Wenyin Fu, Brian Fuller, Cynthia Gao, Vedanuj Goswami, Naman Goyal, An- thony Hartshorn, Saghar Hosseini, Rui Hou, Hakan Inan, Marcin Kardas, Viktor Kerkez, Madian Khabsa, Isabel Kloumann. Artem Korenev, Punit Singh Koura, Marie-Anne Lachaux. Thibaut Lavril, Jenya Lee, Di- Liskovich, Yinghai Lu, Yuning Mao, Xavier Mar- tinet, Todor Mihaylov, Pushkar Mishra, Igor Moly- bog. Yixin Nie. Andrew Poulton, Jeremy Reizen- stein, Rashi Rungta, Kalyan Saladi, Alan Schelten, Ruan Silva, Eric Michael Smith, Ranjan Subrama- nian, Xiaoqing Ellen Tan, Binh Tang, Ross Tay- lor, Adina Williams, Jian Xiang Kuan, Puxin Xu, Zheng Yan, Ilyan Zarov, Yuchen Zhang, Angela Fan, Melanie Kambadur. Sharan Narang, Aurélien Ro- driguez, Robert Stojnic, Sergey Edunov, and Thomas Scialom. 2023. Llama 2: Open foundation and fine- tuned chat models. ArXiv preprint, 009.09988.
Jason Wei, Xuezhi Wang. Dale Schuurmans, Maarten Bosma, Fei Xia, Ed H Chi, Quoe V Le, Denny Zhou, et al. 2022. Chain-of-thought prompting elicits rea- soning large language models. In Advances in Neu- ral Information Processing Systems, NewrIPS 2022.
Jules White, Quchen Fu, Sam Hays, Michael Sandborn. Carlos Olea, Henry Gilbert, Ashraf Elnashar, Jesse Spencer-Smith, and Douglas C. Schmidt. 2023. A prompt pattern catalog to enhance prompt engineer- ing with chatgpt. ArXiv preprint, 2302. 11382.
Xi Ye and Greg Durrett. 2023. Explanation selection using unlabeled data for in-context learning. ArXiv preprint, 2302.04813
Mengxia Yu, Zhihan Zhang, Wenhao Yu, and Meng Jiang. 2023. Pre- Pre-training language models for com- parative reasoning. In Proceedings of the 2023 Con- ference on Empirical Methods in Natural Language Processing, EMNLP 2023.
Zhihan Zhang, Wenhao Yu, Zheng Ning, Mingxuan Ju, and Meng Jiang. 2023. Exploring contrast consis- tency of open-domain question answering systems on minimally edited questions. Transactions of the Association for Computational Linguistics, TACL. 11.
Ben Wang and Aran Komatsuzaki. 2021. GPT-J- 6B: A 6 Billion Parameter Autoregressive Lan- guage Model. https: /gi thub. cot/://go/o/oglllll///// mesh-transffrrer-jjaa
Xinyi Wang, Wanrong Zhu, and William Yang Wang. 2023a. Large language models are implicitly topic
Zhihan Zhang, Wenhao Yu, Chenguang Zhu, and Meng Jiang. 2022a. A unified encoder-decoder framework

---

with entity memory. Proceedings of the 2022 Con- ference on Empirical Methods in Natural Language Processing, EMNLP 2022.
A Training Data Pre-Processing
As detailed in $4.2, the instruction ranking model is trained to rank candidate instructions against their downstream performance on the LLM. The down- stream performance of an instruction Ie refers to how well the LLM''s predicted output ) matches the ground-truth output y when using / prompt the LLM, as quantified by the ROUGE-L score r(y. 9). To calculate this score, we pair each training exam- ple with all 22 candidate instructions of the corre- sponding task (generated with the method $4. 1), and collect the LLM's predicted output to the ex- ample prompted by each candidate instruction. Af- ter calculating the ROUGE-L scores against the ground-truth, discard examples where candi- date instructions not distinctly rankable in cases where the range of downstream performance across different instructions is less than 10 points in ROUGE-L.
Zhuosheng Zhang. Aston Zhang, Mu Li, and Alex Smola. 2022b. Automatic chain of thought prompt- ing in large language models. ArXiv preprint, 2210.03493.
Yongchao Zhou, Andrei Ioan Muresanu, Ziwen Han, Keiran Paster, Silviu Pitis, Harris Chan, and Jimmy Ba. 2022. Large language models are human-level prompt engineers. ArXiv preprint, 2211.01910.
To accelerate the training process, we sample 8 candidate instructions from the total pool of 22 for each example, and train the model to rank these 8 instructions. However, in some tasks, certain instructions may significantly outperform others. Uniformly sampling 8 candidate instructions could result such "extraordinary" instructions being disproportionately favored too many times the training of the ranking model. To address this, we inversely proportion the sampling rate of each in- struction to its popularity (i.e., the number of cases where this instruction is superior to all others). Fi- nally, sample up to 400 examples from each training task, which leads 122k training exam- ples in total.
Detailed Experimental Settings
The instruction ranking model is initialized with FLAN-T5-Large (780M parameters; Chung et al., 2022), and trained using Adafactor (Shazeer and Stern, 2018) with learning rate 5e-5, batch size 128 and dropout rate 0.1. We employ an in-domain dev set including a total of 5k unseen examples from 100 training tasks to select the best check- point within 5 epochs. The validation performance on the dev set is 67.66 in ROUGE-L, while random selection only achieves score of 54.28. When using OpenAl models, for instruction generation, set the maximum instruction length be 300 kens, and we use a temperature of 1.0 and top_p of 0.75 for token sampling; for downstream inference, we set both to O for deterministic outputs. Gen-

---

Data:
used for downstream inference. For (2), con- duct its instruction validation on the 3-shot demon- strations. Due to the cost iteratively requesting the OpenAl API, we incorporate an early stopping criterion which halts the process the validation performance' has not improved for 10 iterations. Actually, almost all tasks stopped before 30 iter- ations. Following this, We select the instruction with the best validation performance to evaluate the test examples.
Input: [input of demonstration #1]
Output: [output of demonstration #1]
Input: [input of demonstration #n] [output of demonstration #n]
Output:
Instruction:
Figure 7: The meta-prompt of instruction generation with iPrompt'.
Write an instruction on how solve the following task.
According to the original codebase, we use the meta-prompt shown in Figure 7 for instruction gen- eration with iPrompt. Since this meta-prompt does not utilize any task description, for fair compar- ison, implement an iPrompt+ baseline with similar meta-prompl to our method which utilizes the seed instruction, as shown Figure 8. Readers can refer to the original paper (Singh et al., 2022) for technical details of iPrompt.
Task:
[seed instruction]
Examples:
Input: [input of demonstration #1]
Output: [output of demonstration #1]
Input: [input of demonstration tin]
Output: [output of demonstration #n]
Instruction:
D Additional Experimental Results
Figure The meta-prompt of instruction generation with iPrompt+. similar ours in Figure 10.
In this section, we present more experimental re- sults in addition to those analyzed in Section 5. All experiments in this section conducted in the few-shot setting unless stated otherwise.
crating all candidate instructions for 91 SuperNI test tasks cost us 18 USD in total, according to OpenAl's pricing (0.02 USD per 1k tokens for text- davinci-003). In text-davinci-002 experiments, the random selection score is calculated as the aver- age score across all instructions on each example, including the humtn-written seed instruction. In ChatGPT and GPT-4 instructions, due to the lim- ited capacity of their API interfaces, we randomly sample an instruction for each example and test its performance.
D.1 SuperNI Results by Task Category
Here, we present the detailed experimental results on different categories of SuperNI test tasks (see Appedix G for the list of test tasks). As shown in Figure 9, Auto-Instruct surpasses the human- written and random instructions no matter is evaluated on classification, extraction or genera- tion tasks, with the only exception as answerability classification. Notably, Auto-Instruct outperforms the original human-written instruction by 10%, 9% and 8% on commonsense classification (classifica- tion tasks), word analogy (short generation tasks) and dialogue generation (long generation tasks), respectively.
C The iPrompt Baseline
In this section, we outline the adaptations made to the iPrompt (Singh et al., 2022) method for our setting. We mainly address two discrepancies be- tween its original implementation and setup: (1) the original iPrompt generates instructions us- ing GPT-J (Wang and Komatsuzaki, 2021), and (2) it uses validation set to score and select instruc- tions. To address (I), we use text- coxt-davnni-OO0 for its instruction generation, identical to the model
D.2 Generalization to Other LLMs
In addition Section 5.4.1, we further assess the generalizability of Auto-Instruct to open-source LLMs. As demonstrated in Table 5, instructions selected by Auto-Instruct enhance the performance of LLaMA-2-char (Touvron et al., 2023). This once again underscores the capability of Auto-Instruct
II original iPrompt implementation, the peea-prommt ends with the suffix Prompt:. However, this leads to incoher- ent instruction generation on our benchmarks. Therefore, we changed to Instruction: which addressed this issue. "ww.. gi thub. wttpcsinoa//cccco//ccooo soddelsX/tee sordelss//re/estteer imodelsxx sx/ sx/ipromptttpptp/o
"The average ROUGE-I. score hetween the L.M'ss pre- dicted output and the ground-truth on validation data.

---

Coherence Classiication
Data to Text
Answerability Classification
Information Extraction
45
72
01:35
71
70.61
71
70.44
79
42.44
42.98
70:
70.12
70.3
41.02
07.57
Human Random Selected Commonsense Classification
Human
Random Selected Word Analogy
Human
Random Selected
Human
Random
Selected
Dialogue Generation
72
38
67.17
70-
69.06
63.79
64.02
36
62.8
34.13
63.59
Human
Random
Selected
Human
Random
Selected
Human
Random
Selected
Human
Ratdom Selected
Figure 9: Few-shot performance of instructions selected by Auto-Instruce (denoted as "Selected")) all categories of SuperNI test tasks, compared to human- written and random selected instructions.
Methods
IJaMA-2-chat-77
Method
Score
Few-shot, instructions from text-davinci-003
Human
60.94
Human
53.87
Human (Ensemble)
61.08
Random
54.15 18
Auto-Instruct
64.35
Auto-Instruct
55.90
Table 5: SuperNI results of transferring Auto-Instruct to LLaMA-2-chat- using instructions generated by text-d sert-dvvnni--O00 The instruction ranking model is still the one trained on text-davinci-003 instructions.
Table 6: Results of multi answer ensemble prompted by human-written instructions SuperNI test tasks.
consistency (Wang et al., 2023b). The results, shown in Table 6, indicate that the answer ensem- ble approach only brings marginal improvement on SuperNI, which is not comparable the perfor- mance gain achieved with Auto-Instruct.
generalize across different LLMs without re- training the instruction ranking model. worth noting that we use instructions generated by text- davinci-003 in these experiments, because both the 7B and 13B versions LLaMA-2-chat exhibit weaker abilities in following our meta-pre prompts for instruction generation, contrasted with mega-size GPT models. We leave the study of instruction generation with recent open-source LLMs future work.
E Meta-Prompts for Instruction Generation
In this section, we list all meta-prompts utilized dur- ing instruction generation, outlined in $4.1. For the zero-shot setting, omit the "Examples" field in the meta-prompt to let the LLM rephrase the seed instruction. Besides, the meta-prompt with explana- tions to the demonstrations is not applicable the zero-shot setting. The meta-prompt that uses other tasks as demonstrations (Figure 10e) is integrated with three groups of demonstration tasks, each vary- ing in the average instruction length. Therefore, the LLM is prompted to generate instructions of similar granularity to the demonstration tasks. Demonstra- tion tasks are sampled from SuperN1. In SuperNI, each task paired with a concise task summary and a detailed task definition which is usually much longer. For each demonstration task, we use the
D.3 Compare to Answer Ensemble
Given that Auto-Instruct includes sampling mul- tiple candidate instructions before selecting the best one, we compare it to another sampling ap- proach, ie.. sampling and ensembling multiple an- swers. Using the original human- wrrtten instruc- tion, sample responses 10 times with nucleus sampling (Holtzman al., 2020), without pling multiple instructions. Then, ensemble all responses by marginalizing the LM prob- ability of each unique response before selecting the most probable one, similar to the idea of self-

---

Write instruction how solve the following task sentence.
Write instruction how to solve the following task paragraph.
Write step-by-step instruction how solve the following task.
Task:
(seed Instruction]
Task: (seed instruction]
Task: [seed instruction]
Examples:
Examples:
Examples:
Input: [input demonstration #1]
Input: [input demonstration #1]
Input: [input of demonstration #1]
Output: [output of demonstration #1]
Output: [output of demonstration #1]
Output: [output of demonstration #1]
Input: linput of demonstration th]]
Input: [input of demonstration #n]
Input: [input of demonstration #n]
Output: [output of demonstration #n]
Output: [output of demonstration #t]]
Output: (output of demonstration #n]
Instruction:
Instruction:
Instruction:
One-sentence instruction
(b) One-paragraph instruction
an instruction Step-by-step instruction
following
Task:
[seed instruction of task
Write step-by-step instruction how solve the following
Examples: [input-output demonstrations of task #1]
Instruction: [instruction of task #1]
Task:
[seed instruction]
....
Task: [seed instruction task #N]
Examples:
Input: [input demonstration #1]
Examples: [input-output demonstrations of task #N]
Output: [output demonstration #t]
Instruction: [instruction of task #N]
Input: [input of demonstration #n]
Task:
[seed instruction of the test task]
Output: [output of demonstration ttn]
Examples: imput-outpur demonstrations test task)
Instruction:
Instruction:
(d) Example explanation instruction
(e) Use other tasks demonstrations.
Figure Meta-prompp that we use to specify different desired styles of instructions during instruction generation. For Figure 10e, we collect 3 groups of demonstration tasks with varying average instruction length (short, medium, long), so as to guide the LLM to generate instructions of different granularities.
task summary as the seed instruction and the task definition the target instruction. We abstain from
G All Test Tasks
In Table 7, we list all 91 SuperNT test tasks used in our out-of-domain experiments. Since the size of tasks imbalanced on SuperNI, for efficient evaluation, we randomly sample 200 instances for each task, making total of 18,200 test examples.
utilizing the task definition in test tasks because (1) some task definitions are too long to fit in the T5 model together with the input (2) we practically find that the LLM tends to repeat the task definition to a large extent if it is used as the seed instruction. Although Auto-Instruct has never seen the much longer task definition of test tasks, our selected in- struction still performs better than using the task definition the instruction, which holds an erage score of 62.41 on SuperNI in the few-shot setting. We leave the exploration of integrating more complicated instructions as future work.
F Additional Case Study
In this section, provide more cases (2 sho-shot and zero-shot) where Auto-Instruct improves the original human-written instructions. These case studies are shown Figure 11, 12, and 13. Please refer to the corresponding captions for detailed case explanations.

---

Case Study (Few-Shot)
Human Instruction: Given sentence from medical study paper, select the tokens representing information about participants.
Scan the sentence and look for information related to participants, such as descriptions of age, numbers, or health conditions, and select the tokens that encapsulate this information. For example, given the sentence "Participants were 58 children (46 boys) with autism between and years of age", the output should be "58 children (46 boys) with autism between and years of age."
Auto-Instruct:
To consider the impact primary care patient outcomes of using both screener determine elevated anxiety levels among patients with previously undetected anxiety and physician intervention to inform physicians of their patients' conditions.
Test Imput:
x
Human Instruction Answer: patients
Auto-Instruct Answer: patients with
previously undetected anxicty
Figure 11: A case study in the few-shot setting, where the few-shot demonstrations are omitted for brevity. The initial human-written instruction provides general guidelines for extracting participant information from a medical study. However, it does not specify the scope of such information, leading to an answer that only includes the keyword "patients" but ignores other relevant information. In contrast, Auto-Instruct provides an instruction that delineates the types of participant information to be extracted (highlight in red), after seeing the output formats the demonstrations. Prompted by the improved instruction which suggests health conditions are examples of the requested information, the LLM generates more comprehensive answer that incorporates the patients' health conditions, Le., "with undetected anxiety".
Case Study (Few-Shot)
Human Instruction: Task description: Answer questions ubout which times certain events could have occurred.
To solve this task, you must answer questions about when certain events could have occurred. To do this, you must analyze the information given in the question and the given examples.
Auto-Instruct:
For each example, you must analyze the information given about the events that happened before and after the event you trying find the time for. The question will usually give you the time that the person woke up and the time when the event they are going closed. From this, you must determine the
frame in which the event could have occurred.
For example, in the first example, we know that Emily woke up at [mm and the museum closed after 7pm. Therefore, the time frame in which Emily could have gone to the museum is between pm and 7pm. From the other information given, we know that Emily was at the library from 2pm to 4pm, at the theater from 4pm to 5pm, at the uirport from 5pm to 6pm, and at the mall from 6pm to 7pm. Therefore, the only time frame in which Emily could have gone to the museum is between 1m and 2pm. Therefore, the correct unswer (A)... (explanations of other two demonstrations omitted)
the movies. Between what times could they have gone? We know that: Jason woke up 10am. Linda saw Jason getting coffee the cafe from 10am 3pm. Jennifer saw Jason walking lowards Statue of Liberty from 6pm 7pm. Sean saw Jason buying a phone at the clectronics store from 7pm to 10pm. The movics was closed after 10pm. Between what times could Jason have gone to the movies?
Test Input: Today, Jason
Human Instruction
x
Answer: (C)
Auto-Instruct
Answer: (A)
Options: (A) 3pm to 6pm (B) 10am to 3pm (C) 7pm to 10pm (D) 6pm to 7pm
Figure 12: A case study in the few-shot setting, where the few-shot demonstrations are omitted for brevity. The human instruction provides a general and concise description of the question's 's requirements. In contrast, generated based on the demonstrations, the instruction from Auto-Instruct offers more concrete description about the information present in the input and emphasizes which aspects should be focused on (highlight in red). Besides. Auto-Instruct provides explanations of the few-shot demonstrations as complementary information for the LLM to understand these examples.

---

Case Study (Zero-Shot)
Human Instruction: Categorize the knowledge required answer pronoun coreference resolution question. Only choose your answer from "Quantity", "Object", "Others", "Property"" , "Sputial", and "Temporal".
Inttrlnstt this task, you will given pronoun coreference resolution question you need to calegorize knowledge required to unswer the guestion. You can only choose your unswer from the provided list: "Quuntity". "Object", "Others", "Property", "Spatial", and "Temporal". "Quantity" knowledge refers to the knowledge quantities, such how many, how much, etc. "Object" knowledge refers to the knowledge of the properties of objects, such as size, color, etc. "Others" knowledge refers to the knowledge of entities other than objects, such people, places, events, etc. "Property" knowledge refers to the knowledge of the properties of entities, such as occupation, location, etc. "Spatial" knowledge refers the knowledge of the spatial relations between entities, such distance, direction, etc. "Temporal" knowledge refers the knowledge of the temporal relations between entities, such as order, sequence, etc.
Input: Sentence: painting in Mark's living room shows an oak tree. to right bookcase. The "It" refers to the painting. Question: What is the knowledge type needed to solve relation?
Human Instruction Answer: Spatial
Auto-Instruet Answerr Property
In this zero-shot classification case, the human-written instruction only provides the name of each category. result, the LLM can only attempt to determine the target category based these single-word surface names, which often lack sufficient clarity for differentiation. In contrast, the instruction provided by Auto-Instruct explains the meaning of each category, which greatly facilitates the LLM'' comprehension these categories. While Auto-Instruct tends over-interpret when explaining the "Others" category, most of the additional information (highlight in red) are useful for making more accurate predictions.
Figure 13:

---

Category
lask066 timetravel binarry www.uuiinnonsiiiiiee www.ssstenccccllsssseeee classification
task070_ abductivvli. inn.vveeeliiiiieeettttteeeeeeeee incorrett jncommtt_hassficutin classification
task1573, samsum_ classification
task065_ task065_timetrave timetrateelll........o.ooooo coosiiitnt sentenee,
sentsnce_clnssficatin clessiiication
Clasilication
task298_ sttryy9osooyyoreee.oooo correct classifccation
task 1728, web,
task1407 dart, question peneration
Data to Text
lank677 (ali677_oliie___ sentencee anwswr generation
lask14009 disddddrrsssaae generrrgnoo
nye, long texr generation
tack957 _ate olg, text, genernttiooon generate
task349, squad.00,.a..mm
answerabll, unanswerable, qusesteeable_ueeettoonnoo classification
t26k laglish_languuge language,
relevance, classification
elevance__lassiiaattin
task020 metaco, span, question
task290, tack290_ wel.mewwy.y.geeee. question answerability
Ancuerability
task1439 1nkk4499doopp_sooo dogi_sooking isanswerable
sos.miieesssssverbbleee task1442, dowiemovies_ti isanserabbe
Classification
htwp://eeeeeessteeeeeee classification task520
__sisllf_____ cocil__p__ussttia gu_qustion, yesno_eleeee classification
aquamuse wnwwwr__gieeee given in passage
task050 multire ....wwerahiltty
task1506 1akkl506_eelerrit Lichbrrty_miimallllmm dlh span
task1517 Jimit clasdfiatiion
linentio__clessiiaatinn task456, matres_ intecssiitttttnn__ classificatiin
task3888 Jerquerrreeeeeeeeee classification
task1518 limit answer generation
task1410, dort, relatiooshipppppo. extraction
ask676_ollic relationship answer generrainoo
task intervemiinneeteee
task749 glocooe. reverse
detection
task684 online privacy httpppascc_ollllyyy.epep eet__informatinn hypppop__ppppperttion
Information
task958 clc_ el__nlg._ generation parse
task1413, dort ooject identification
Extraction
lusk292 tusk292_storyeee www.yyomoooommmn.....ooo characerr generratiinn
lask578 Saaiinscui _iilllydi.s..... wwweer gasps__ser__gerratleee generation
glucose cause sontion delection
task678__oll aalie_actuall,__ relationship anewer answer_genenation
task1510, evalation relation extmation
mnk1451__duge (11451_drug__ui ____r_u___sscc_ sauug_ddee_exttaattonn extracttion
lask683 ____ooon__eeeeeeeee caciee_pive___eoee soliccypllcyyycoo _ee_______ppp_e purpow__nner_.eerrriii
tuck179_purte purticipant_extreee
subjes identifictionn
tack181_ _ooooottcmmee. extraction
task181,
tack748
glucose reverse cause, event, detection
Lood22ooosmmol_yss Batpeso___yy__oonneeeeee www.oooorrccaalaaoommomoo unswer_gennrraiion
lask647_
classifiication madcupof
classification, capableef
task1216
goommc_classiiflatieee causcs
task1202 Nakk1222__oonno
"_r__tmmie__eatte promic_clssiiiiaaiinn.o _nnced
task136 wi1/w/hw knowleeggee....... categorization htg..ooococllllc.cegrriiiioooonn
task 119666//omi_____1111
wttp__aaasiicaatoncccom oeffect
1001__ssmovva_22220 task4_ commossense, validation
0osk1208.
classssaassiiiitoonn. xreason
task1206,
Bicck_stmii__eem caamii_classiffcaaiio sisisfi
task 1997_1999eee 197_atomic ____tomie_classtii classiifiiationn oreact
Commoosennse
task1213, w.l.lommccccccmm wht.scclasssicatinnnnmm
1tt11s_ttomicccassiiccttinnn desires
task116 1ackl166_cmmm. coff_co2eeeseee_.e commensense jernsoossseeeeeeeonnnnneeee reasoning
Classifcation
classiicctasiiiiiiiinn...
owant
task 20s11__ttmmi____11 c_lassifficationn
htto:__ttmmicccassicctttttttoot hasproperty
task 10k3
____stmiee_clee
classiffiiatiinn _xeact xreact
task1214_nns tak11144sitomicc_ htt___ttmiicccsssicaaiinnn xwaat
22222000oomicccaaaeeeee _eeffest
obbjectuee
hinderdby
task 1207 aatmmiccccc.....
classsificationn atlocation
task1200 205 w___atmiee__eee classsifiiattion isafter
task1199_nms 11119_9llmiic___
www.logicall..ccoooooooo reasoning
analogical rewsoingg
lask1155_ bard Laalooiicl_reeaonnin trash_or.rrr.o tressue
lask1157 bard bard_analogical_ mmalogical_ressoming for containers task bard analogical ressoning manipulating items
Word Analogy
tack 1a54 bard annalggccall reasoning travel
bard Baokl115_taar__amsggeaaa www.aaoooooollalaoaooaaaa reasonigg causation
snalogical_ rewsonin affordance
task131_scan Jong_een bong_leet__emeeriionn action command long
task nak129_ssaat 22____aa_ooogeeeeeeaaaa_________ generttgenttionnnnmmmm action command short
Code
task110_ hetllllogieeext_eeeee sentenee, generation
1603, smealflow sentence generation
tock1714 convaii sentence generation
semeence_geneattion
Birk360_spollinn yesand response
task5744 www.diiiaaseeeee saalogue_sentence
Dialogue
lnk565 _itse_aa__ewwerrr.eoeeeea her___asweerreeeee sos__meee__geetttionnn
task576, takk576_curiostt- cirkosttt_diakgss www.er/wweeeeeeee generation dialoys
Generation
catttenceegneeationn tack1730 personachat, choose
smealflow sentence generation
tack1729, personschar, gonerate
tack361 mack361_spolin___ lil__sppooe_suuee yesand___dd__ prompt response clastification
Table 7: All SuperNI test tasks, grouped into different categories. These task categories are not seen during the training the instruction ranking model. Besides, any task that sourced from the same original dataset as any test task is excluded from training.


Reviews:
[{"review_id": "T7L8GwaygC", "reviewer": "Reviewer_n9EG", "summary": "", "questions": "- In line 326 the equation shows softmax over Qt5, but previously you say that Qt5 is the logit of the \"yes\" token. Is this correct? The softmax should be performed on top of the whole output vocabulary, right?\n-  It is not super clear to me how inference works. How many instructions do you sample at inference time? \n- Depending on the answer to the previous questions, how much is the overhead at inference time if the instructions have to be sample from the model?\n- Related to previous one too, how does the method compare to best of N sampling without instructions?", "limitations": "", "rating": 3, "confidence": 3, "soundness": 4, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "Thanks for the valuable comments and suggestions! We will add the corresponding clarifications and experiments (as follows) to the final version of the paper.\n\n**1. Regarding closed / open-source LLMs:**\n\nUsing GPT models is to follow previous approaches in instruction generation [1, 2, 3] which all used GPT models. Besides, early open-source LLMs, such as OPT and GLM, do not perform as well as InstructGPT on generating instructions [2], which is another reason that we mainly used text-davinci-003 in our experiments.\n\nGiven more instruction-tuned open-source LLMs coming out since March 2023, we additionally experimented with using instructions selected by our ranking model to prompt the Llama-2-chat-7B model. The results on few-shot SuperNI are as follows, showing that Auto-Instruct is also able to improve the performance on Llama.\n\n| Method     | Score |\n|-----------|:----------:|\n| Auto-Instruct | **55.90**    |\n| Random   | 54.18    |\n| Human    | 53.87    |\n\n**2. Regarding questions on the inference strategy:**\n\n**Q1. Question on softmax.**\n\nSorry for the confusion. Yes, $Q_{T5}(I^c,x)$ is the logit of the \"yes\" token and we used it as the ranking score of the candidate instruction $I^c$. As we mentioned in **line 323**, during training, $Q_{T5}(I^c,x)$ was normalized across candidate instructions $I^c$, which means the softmax normalization was applied on all instructions rather than the tokens in the vocabulary. This is to align the ranking scores of the list of instructions with their relative downstream performance $r(y,\\hat{y})$ which was also normalized across instructions. We will revise this part to make it clearer.\n\n**Q2. The number of sampled instructions.**\n\nAs we mentioned in **line 254**, we sampled 22 candidate instructions (3 instructions generated for each of the 7 meta-prompts, plus the original human-written seed instruction) for each task.\n\n**Q3. The overhead of instruction generation at inference time.**\n\nIt took 25 mins to generate all candidate instructions on 91 SuperNI test tasks by calling text-dainvic-003 API with sequential API requests. More time can be saved using parallel API requests. This included 767k input tokens for the model and 180k output tokens to generate. This cost 18 USD in total (0.02 USD per 1k tokens for text-davinci-003).\n\n**Q4. Comparison to best of N sampling**\n\nThanks for the constructive suggestion! We additionally tried the setting where we used the original human-written instruction and sampled the answer 10 times, without sampling multiple instructions. Then, we ensembled all 10 answers by a majority voting, similar to [4]. The results are as follows. Sampling and ensembling multiple answers brought little improvement on SuperNI, which is not comparable to Auto-Instruct.\n\n| Method     | Score |\n|-----------|:----------:|\n| Auto-Instruct | **64.35**    |\n| Human (Ensemble)   | 61.08   |\n| Human    | 60.94   |\n\n**References**\n\n[1] Honovich et al. Instruction Induction: From Few Examples to Natural Language Task Descriptions.\n\n[2] Zhou et al. Large language models are human-level prompt engineers.\n\n[3] Singh et al. iPrompt: Explaining Data Patterns in Natural Language via Interpretable Autoprompting.\n\n[4] Wang et al. Self-consistency improves chain of thought reasoning in language models.", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "- The paper is well written and their proposed ranking method improves results over random selection.", "reasons_to_reject": "- All the experiments are performed on top of closed LLMs.\n- It is not super clear which is the inference strategy.", "questions_to_authors": "- In line 326 the equation shows softmax over Qt5, but previously you say that Qt5 is the logit of the \"yes\" token. Is this correct? The softmax should be performed on top of the whole output vocabulary, right?\n-  It is not super clear to me how inference works. How many instructions do you sample at inference time? \n- Depending on the answer to the previous questions, how much is the overhead at inference time if the instructions have to be sample from the model?\n- Related to previous one too, how does the method compare to best of N sampling without instructions?", "paper_topic_and_main_contributions": "In this paper the authors propose Auto-Instruct, a pipeline approach to automatically generate instructions. First, they prompt a black-box LLM to generate a diverse set of candidate instructions for a pool of downstream tasks. Second, they train a scoring model to rank candidate instructions. Last, the top ranked instruction is used for few/zero-shot inference. \n\nFor the ranking of candidate instructions they fine-tune a T5 model to align the scores given by the ranking model with the downstream performance of the LLM when using each instruction. \n\nTheir results on SuperNI and BigBench, show that LLMs are generate instructions that are more useful than human generated ones and that ranking those boosts performance.", "excitement": 3, "reproducibility": 4, "ethical_concerns": "No", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "", "extra_scores": {}, "extra_text": {}}, {"review_id": "aLmtDRmnHu", "reviewer": "Reviewer_5KfX", "summary": "", "questions": "", "limitations": "", "rating": 3, "confidence": 4, "soundness": 3, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "Thanks for the constructive comments and suggestions! We will add the corresponding experiments (as follows) to the final version of the paper.\n\n**1. Regarding evaluation of the ranking model**\n\n**Q1. The performance of an “oracle” ranker**\n\nWe tested an “oracle” ranker which always selects the best instruction and a “worst” ranker which always selects the worst one. However, the “oracle” performance is dependent on the number of sampled instructions. More generated instructions lead to higher oracle performance, but may also bring more noise to make the ranking more challenging. Thus, the “oracle” performance cannot fully reflect whether the instruction ranking model is good enough. \n\nThe results on SuperNI are as follows. “Ranking performance” is the relative ratio that a method achieves between “worst” and “oracle”.\n\n| Method     | Few-shot Score | Ranking Performance | Zero-shot Score | Ranking Performance |\n|-----------|:----------:|:----------:|:-----------:|:----------:|\n| Oracle | 80.60    | 100% |  68.80 |  100% |\n| Auto-Instruct | 64.35  | 61.2% | 49.50 | 59.6% |\n| Random   | 61.61    | 54.7% |  45.80 | 51.8% |\n| Human    | 60.94    | 53.1% | 46.81 | 53.9% |\n| Worst    | 38.67   | 0% |  21.06 | 0% |\n\nThis shows Auto-Instruct is able to find better instructions compared to random selection or human instruction. It’s worth noting that randomly selecting a generated instruction is a *competitive* baseline since it performed comparably with human-written instructions. Nevertheless, the problem of instruction ranking still has much space for future work to explore, given the potential of the oracle scores.\n\n**Q2. Evaluation with silver labels**\n\nThanks for the suggestion! We tested with 2 sets of silver labels (macro-average on all SuperNI tasks):\n\n(1) whether the selected instruction achieved the best or top-5 downstream performance among all candidate instructions. Note that there could be multiple instructions that share the best score.\n\n| Method     | Is best? | Is in top-5? |\n|-----------|:-----------:|:----------:|\n| Auto-Instruct | **52.54%**  | **73.10%** |\n| Random   | 46.26%    |  69.61% |\n\n(2) whether the selected instruction improved the downstream performance. We consider the *improvement* over (i) empty instruction (ii) human instruction.\n\n| Method     | Better than empty? | Better than human? |\n|-----------|:-----------:|:----------:|\n| Auto-Instruct | **35.85%**  | **23.89%** |\n| Random   | 32.58%    |  16.58% |\n\nTherefore, Auto-Instruct significantly outperformed random selection, with +6.3% in selecting the best instruction and +7.3% in improving over human instruction.\n\n**2. Regarding the significance of improvement on BBH**\n\nThanks for the suggestions! First, we would like to mention that the tasks in BBH have a larger distribution shift with those SuperNI tasks used in model training. For example, many tasks in BBH are multiple-choice questions with a considerable number (5+) of options, but all tasks in SuperNI are answered in a generative fashion. Therefore, a relatively smaller improvement is expected on BBH, compared to SuperNI test tasks.\n\nRegarding statistical tests, BBH has a fixed set of 3 few-shot demonstrations for each task. Thus, we conducted paired t-tests between our model and baselines by permuting the order of these 3 demonstrations, as the order also affects LLM performance [1]. After testing all 6 permutations, the results are as follows (mean $\\pm$ standard deviation):\n\n| Method     | Score | p-value |\n|-----------|:----------:|:----------:|\n| Auto-Instruct | **52.06 $\\pm$ 0.42**  |  -  |\n| Random   | 50.52 $\\pm$ 0.29  | 0.0005 |\n| On-the-fly Generation    | 51.05 $\\pm$ 0.35  | 0.0076 |\n\nTherefore, Auto-Instruct outperformed both random selection and on-the-fly generation with significance level $\\alpha=0.01$.\n\nAlternatively, we conducted statistical tests on the zero-shot setting. Since we cannot manipulate demonstrations in zero-shot, we evenly split the data into 5 subsets and evaluated  the performance on each. The results are:\n\n| Method     | Score | p-value |\n|-----------|:----------:|:----------:|\n| Auto-Instruct | **47.35 $\\pm$ 0.92**  |  -  |\n| Random   | 45.98 $\\pm$ 0.62  | 0.0150 |\n| On-the-fly Generation    | 45.48 $\\pm$ 0.86  | 0.0363 |\n\nTherefore, Auto-Instruct outperformed both random selection and on-the-fly generation with significance level $\\alpha=0.05$. The variance is bigger in zero-shot tests because the whole dataset was divided into smaller subsets.\n\n**References**\n\n[1] Lu et al. Fantastically Ordered Prompts and Where to Find Them: Overcoming Few-Shot Prompt Order Sensitivity.", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "- Few- and zero-shot text generation with instruction has attracted much attention because of publications of large language models.\n- This paper carefully designed the training and test splits by dividing them in terms of task types to evaluate the capability of large language models in few- and zero-shot settings, which is known as the true few-shot setting.\n- Auto-Instruct improved the performance on the famous benchmarks.", "reasons_to_reject": "- The novelty of Auto-Instruct is the multiple prompts generation and their reranking because many previous studies proposed the instruction generation with large language models. However, the experiments did not investigate the correctness of the reranker:\n  - The authors can report the results of an oracle reranker, which selects the best prompt after evaluating the results. Because this is an upper bound of Auto Instruct, the authors can discuss the effectiveness of the reranker with the upper bound.\n  - The authors can give silver labels to prompts in accordance with whether a prompt was the best prompt or not, and whether a prompt improved the score in the current task. The performance of the proposed reranker model can be evaluated in the classification task of the silver labels.\n- The improvement seems marginal. Especially on BigBench, introducing a reranker increased by 0.46 points (51.38 vs 52.04) in the few-shot setting and  1.88 points (45.47 vs 47.35) in the zero-shot setting on accuracy. The authors can report the results of statistical tests because there are many tasks and they can sample few-shot demonstrations multiple times in the few-shot setting.", "questions_to_authors": "", "paper_topic_and_main_contributions": "This paper improved the prompt-based generation of large language models in few- and zero-shot settings. This paper proposed Auto-Instruct, which comprised two techniques. First, the instruction itself is generated by a large language model. Compared to previous studies, Auto-Instruct generates multiple instructions by sampling a prompt from four prompt candidates that specify a style of instruction. Second, Auto-Instruct introduces a reranker to select the best prompt from the generated prompts. The experimental results on Super Natural Instruction and BigBench showed the effectiveness of Auto-Instruct.", "excitement": 3, "reproducibility": 3, "ethical_concerns": "No", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "", "extra_scores": {}, "extra_text": {}}, {"review_id": "WQjN1Cm7j5", "reviewer": "Reviewer_MRyL", "summary": "", "questions": "", "limitations": "", "rating": 4, "confidence": 3, "soundness": 4, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "Thanks for the comments! We appreciate the acknowledgement of our contributions and the effectiveness of our method. We focus on a **true few-shot** setting where few-shot demonstrations are the only available examples besides the test set, without additional validation sets. According to results in Table 1, in the true few-shot setting, traditional ranking methods like validation with few-shot examples or using LLM itself are not reliable, while training a generalizable model is the best solution to rank and select instructions. Although a ranking model was trained, results on transferring Auto-Instruct to ChatGPT and GPT-4 (Table 2) showed that once the model was trained, it can be applied to select instructions on other models. Therefore, people can use our model when they have a tight budget.", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "The solution is simple yet effective. the comparison with baselines and existing approaches are complete. The approach demonstrates strong performance. The paper is well-written", "reasons_to_reject": "The approach requires an instruction ranker model.", "questions_to_authors": "", "paper_topic_and_main_contributions": "This author proposes a solution to one of the prevalent problems in Large Language Models - what is the best instruction for a particular task? Unlike existing approaches, the authors make the task harder and also more realistic, given a task we have few input-output demonstrations (no validation data) and a possible human-written instruction. \n\nThe solution is simple yet effective. \n1) The authors prompt the LLMs to generate diverse instructions for a given task (human seed problem description and optionally a few input/output demonstrations) by varying meta-prompts. \n2) Later, they train an instruction ranking model on a subset of SuperNI dataset. The goal of the ranker is to predict the expected performance of a given instruction on the test example provided. \n3) Given a test example, they select the instruction which would yield the best performance as predicted by the model\n\nthe results show better performance compared to the baselines.", "excitement": 4, "reproducibility": 4, "ethical_concerns": "No", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "", "extra_scores": {}, "extra_text": {}}]

Author rebuttal:

Meta-review: Addresses the issue of the need for prompt engineering LLMs and seeks to generate better instructions/prompts using LLMs for tasks automatically to improve downstream performance. Through prompting, an LLM (text-davinci-003) generates diverse instructions, followed by a FLAN-T5 reranking model to select the best ones. There were concerns about novelty, the significance of the improvement and doubts about the ranking performance. 

An unusual KL-divergence loss is used to align ROUGE-L scores of outputs with the classifier likelihood which has some similarity with BRIO (Liu et al, 2022), but this choice is not compared with the simpler approach of a vanilla classifier. Furthermore, the LLM reranker baseline may significantly improve simply by using GPT-4 instead of text-davinci-003.

Reliance entirely on automatic metrics for evaluating LLM outputs, such as ROUGE-L, while good to have, do not give a full picture that only human evaluation would complete. Including a human evaluation would significantly improve the confidence in the evaluation.
Decision: Accept-Findings