Improved Instruction Ordering in Recipe-Grounded Conversation
Year: 2023

Abstract:
In this paper, we study the task of instructional dialogue and focus on the cooking domain. Analyzing the generated output of the GPT-J model, we reveal that the primary challenge for a recipe-grounded dialog system is how to provide the instructions in the correct order. We hypothesize that this is due to the model’s lack of understanding of user intent and inability to track the instruction state (i.e., which step was last instructed). Therefore, we propose to explore two auxiliary subtasks, namely User Intent Detection and Instruction State Tracking, to support Response Generation with improved instruction grounding. Experimenting with our newly collected dataset, ChattyChef, shows that incorporating user intent and instruction state information helps the response generation model mitigate the incorrect order issue. Furthermore, to investigate whether ChatGPT has completely solved this task, we analyze its outputs and find that it also makes mistakes (10.7% of the responses), about half of which are out-of-order instructions. We will release ChattyChef to facilitate further research in this area at: https://github. com/octaviaguo/ChattyChef.

heading: 1 Introduction
text: Historically, work on conversational agents has mostly fallen into one of two categories: opendomain chatbots (Ritter et al., 2011; Li et al., 2016; Thoppilan et al., 2022; Shuster et al., 2022) or goaldirected dialogue systems within narrow domains (Williams et al., 2016; Eric et al., 2020). However, recent advances in large language models have paved the way for the exploration of dialog agents that can engage in conversations with users to accomplish open-ended objectives, such as learning about a new topic (Dinan et al., 2019; Choi et al., 2018; Reddy et al., 2019), interpreting bureaucratic policies to answer questions (Saeidi et al., 2018), or negotiating within strategy games (Lewis et al., 2017; Bakhtin et al., 2022).
GPT-J model on the test portion of our new dataset ChattyChef. The incorrect responses are classified into four error types (examples in Figure 1) with out-of-order instructions being the most common.
In this paper, we explore the task of RecipeGrounded Conversation, where the dialogue agent is expected to converse with a user to walk him/her through the cooking procedure of a recipe, while answering any questions that might arise along the way (see examples in Figure 1). Although many types of dialogue tasks have been proposed and explored, very little prior work has focused on providing instructions to a user to complete a task. In contrast to other dialogue tasks, such as documentgrounded conversation (Dinan et al., 2019), accurately tracking the conversation state is more crucial in recipe-grounded dialogue. This is because the agent needs to know which step in the recipe the user is currently working on in order to answer questions, such as: what is the next step?
To investigate what challenges may arise in recipe-grounded conversation, we have collected a dataset by crowdsourcing (see §2). As an initial baseline model, we used this data to fine-tune GPTJ following a similar protocol to Peng et al. (2022). Specifically, the conversation history, the grounded recipe, and the gold system response are concatenated as a long input sequence to the model (see §5 for details). We show that fine-tuning GPT-J on a few recipe-grounded conversations works surprisingly well, however, the model makes a significant number of mistakes based on our manual inspection
10086
over 10 conversations (131 generated responses) of the fine-tuned model (Table 1). Examples of each type of error are presented in Figure 1. Notably, the most prevalent type of errors is presenting information from the recipe to the user in the wrong order. We thus focus on tackling this most common error in our work. We hypothesize two potential causes: (1) GPT-J struggles to understand the user’s intent, and (2) GPT-J has difficulty tracking the current state throughout the conversation. Both are crucial in many scenarios, for example, when the user asks for more information about the current instruction, the system should not skip ahead to a later step of the recipe. Based on these hypotheses, we experiment with two supplemental tasks to improve instruction ordering: User Intent Detection (§3) and Instruction State Tracking (§4).
The goal of Intent Detection is to classify the user’s current intent within a fixed set of possibilities (e.g., ask for the next instruction or ask for details about ingredients). Because the set of intents varies across domains,1 we take a fewshot transfer learning approach to leverage existing dialogue intent datasets, such as MultiWOZ 2.2 (Budzianowski et al., 2018) and Schema Guided Dialogue (Rastogi et al., 2020). We show that incorporating natural language descriptions of intents (Zhao et al., 2022) can enable more effective transfer. For example, F1 score for detecting 19 different user intents in ChattyChef increases from 32.0 to 65.1 when transferring from MultiWOZ (§3.2). In addition to Intent Detection, we also explore a simple yet effective method for Instruction State Tracking. State tracking aims to identify which recipe step the user is currently working on. We show that based on unigram F1 overlap, despite
1For example, we would need a different set of intents to model instructions in Windows help documents (Branavan et al., 2010).
the approach’s simplicity, we are able to identify the most relevant recipe step at each turn of the conversation with nearly 80% accuracy.
The information from these two subtasks is then used to support Response Generation to improve instruction ordering (§5). Specifically, instead of feeding the whole recipe into the generation model, we leverage the instruction state to select only the most relevant knowledge. To incorporate user intents, we enrich the input prompt to the model with natural language descriptions of the predicted intent. Experiments show that even though intent and instruction state predictions are not perfect, including this information in the Response Generation model helps mitigate the wrong-order issue. We release ChattyChef, a new dataset of cooking dialogues, to support future work on instructiongrounded conversational agents.

heading: 2 Dataset Construction
text: To collect a corpus of recipe-grounded conversations for fine-tuning and evaluating models, we first obtain WikiHow2 articles under the Recipes category from the data compiled by Zhang et al. (2020). We control the qualities of the recipes by only selecting articles that have a helpful vote rating greater than 75% and have at least 5 votes. We retain the images from the recipes in our dataset, but experiments in this paper only make use of recipe texts. Moreover, in order to improve the conversation quality and avoid crowd workers quitting in the middle of a long conversation, we remove recipes with more than 8 steps.

heading: 2.1 Conversation Collection
text: After getting the recipes, we then ask crowd workers to create conversation data by role-playing.
2https://www.wikihow.com/Main-Page
There are two roles in each conversation of our dataset: an agent and a user. The agent is provided with a full recipe article and assumed to be an expert on cooking, while the user can only see the title of the recipe (i.e., the name of the dish). During the conversation, the agent needs to help the user complete a cooking task with the knowledge learned from the recipe and/or their common knowledge about cooking. Different interfaces are used by crowd workers when they play the agent and the user (see Appendix D.2).
Crowd workers are instructed that conversations should be relevant to the provided recipe, and should also be natural and interesting. In our process, at each turn of a conversation, agents need to identify and highlight the relevant text span in the article, if present, before sending a message, but they are not allowed to answer by copying and pasting. Instead, the agent must rephrase the instruction in their own words. To facilitate more natural interactions, both workers can discuss guidelines and ask their partner to resend messages whenever they have confusion or disagreements, using a separate chat interface.3 Furthermore, in our preliminary study, we found that users tend to repeatedly send messages such as “What is next?” to simply urge the agent to move on without thinking or trying to learn the task. To encourage diverse conversations, we provide different dialog act prompts for annotators to choose from: “teach a new step”, “ask a question”, “answer a question”, and “other” (see Appendix D.2). Diverse dialog acts such as asking and answering questions are encouraged with higher payments.

heading: 2.2 Dataset Statistics
text: We summarize the statistics of our final dataset – ChattyChef – and compare it with CookDial (Jiang et al., 2022) in Table 2. Compared to Cookdial, even though ChattyChef has fewer utterances per dialogue, our recipe steps are much longer, and each step includes multiple sentences or microsteps (about 6.0 sentences per step on average). This feature sets our dataset aside from the CookDial, where nearly all recipe steps have only one short sentence or one single instruction. Having recipes with long, multi-sentence steps makes the conversation more diverse, giving crowd workers more freedom in choosing their own way of in-
3During data annotation, we formed teams of two workers and allowed them to communicate with each other via Slack.
structing, as some micro-steps can be done in parallel while others can be skipped. This attribute is important as it makes our dataset closer to a reallife setting, where the user will normally not strictly follow the order of steps in the recipe. As shown in Table 3, the utterances from the agent in our dataset are much more diverse than CookDial and have instructions worded more differently from the grounded recipe.
Analysis of Instruction State Changes. In this work, we define the instruction state at a time step as the last recipe step which the agent instructed. We analyze the change of instruction state between two consecutive agent utterances of our dataset in Figure 2. Most of the time, the instruction would be either the same or the next recipe step. However, there are also cases when the agent needs to go back to previous steps (e.g., when the user requests to repeat an instruction) or go ahead (e.g., when the user wants to skip some steps) to provide instructions. In ChattyChef, the agent sometimes goes backward for as many as six steps, or forward seven steps. These observations have partially demonstrated the challenge of instructing multi-step procedures in the correct order, as there are many possibilities. Simply providing information from the recipe in a linear sequence is insufficient.

heading: 3 User Intent Detection
text: In this section, we discuss the User Intent Detection subtask. Formally, the task is to predict a set of user intent indices I (as one utterance may contain multiple intents), given the tth user utterance Uusrt and the conversation history H = {U sys1 , Uusr1 , ..., U syst−1}. We hypothesize that providing information about the user’s intents may help the response generation model better provide information to the user in the correct order. For example, if the user asks for ingredient substitutions, the system should not respond by providing information based on the current step of the recipe.

heading: 3.1 Few-Shot Transfer Learning
text: Instruction-grounded chatbots could potentially be developed for many domains beyond cooking, for example, repair manuals (Wu et al., 2022), wet-lab protocols (Kulkarni et al., 2018), software documentation (Olmo et al., 2021), etc. Each new domain will require a different set of user intents, motivating the need for few-shot intent classification. To better support few-shot learning, we also investigate whether existing large-scale dialogue corpora, such as MultiWOZ, can be used to transfer knowledge to instruction-grounded chatbots.
Simply training on MultiWOZ using existing intent labels is unlikely to work well, because the MultiWOZ intents are very different from those needed for recipe-grounded dialogue. To address this challenge, we utilize natural language descriptions of the intents, following Zhao et al. (2022). A full list of intent descriptions is provided as input to T5 model (Raffel et al., 2020), which is fine-tuned to predict the index of the correct intent. Intent indices are randomized during fine-tuning, to prevent memorization of the MultiWOZ intents, which are different from those in ChattyChef, and force the model to learn to recognize intents based on their text descriptions. A complete list of intents and their associated descriptions is presented in Table 10 (in the Appendix). Example prompts used for MultiWOZ, and recipe-grounded conversation are presented in Table 12 (in the Appendix).
In addition to supporting few-shot transfer learning from existing resources such as MultiWOZ, the intent descriptions are also useful for providing intent information to the response generation model (see §5, and Table 13 in the Appendix for details.)

heading: 3.2 Experiments
text: Datasets. To evaluate the performance of the model on ChattyChef in the few-shot setting, we annotate the user intents for 10 conversations from the train set, 10 conversations from the validation set, and all 87 conversations in the test set. We consider a total of 19 different user intents for ChattyChef, which include 16 intents inherited from the CookDial dataset (Jiang et al., 2022) and 3 new intents: req_confirmation (ask for verification), req_explanation (ask to explain the reason or explain in more detail), req_description (ask for description). The full list of all 19 intents and their descriptions can be found in Appendix B.1. The numbers of intent annotations in the train, validation, and test split are 128, 125, and 1059. In addition to ChattyChef, for intent detection, we also use other datasets to conduct the cross-dataset experiments. In particular, we use one in-domain dataset CookDial and two large out-of-domain datasets, namely MultiWOZ 2.2 and Schema Guided Dialogue (SGD). Specifically, MultiWOZ 2.2 contains dialogues covering 8 domains (i.e., restaurant, hotel, attraction, taxi, train, hospital, bus, and police); while SGD has conversations spanning over 20 domains (e.g., banks, events, media, calendar, travel) but also not include cooking. For MultiWOZ and SGD, we extract all user utterances, which have active intents along with the conversation histories. For CookDial, as there is no official data split, we split the data on the conversation level with the propor-
tion of train, validation, and test set being 8:1:1. The sizes of the train/validation/test set of MultiWOZ, SGD and CookDial are 47,897/6,208/6,251, 153,940/22,832/39,623, and 3,599/466/545, respectively.
Models. We choose to experiment with the following training settings to evaluate this subtask: (1) In-context learning (In-context): As a baseline approach, we prompt the GPT-J model, which learns to do this task by only observing a few examples without any parameter updates. (2) Few-shot fine-tuning (None → ChattyChef): in this setting, we fine-tune the T5 model (following the approach discussed in §3.1) on a few training examples (16- /128-shot) from ChattyChef. (3) Cross-dataset (X → ChattyChef): the T5 model is first fine-tuned on another dataset (i.e., X may be MultiWOZ, SGD, or CookDial), and the fine-tuned model is then directly used to predict user intents in ChattyChef for 0-shot experiment or is further fine-tuned on a few examples of ChattyChef to perform the task. (4) Cross-dataset two-hop (X → CookDial → ChattyChef): this setting is similar to the Cross-dataset setting except that the model is fine-tuned on two datasets, first on an out-of-domain dataset (either MultiWOZ or SGD) then on CookDial.
For all models which utilize T5, we use the T5XL version. More details about the training process of these models are described in Appendix B.1.
Results. Following Jiang et al. (2022), we use micro-F1 as the evaluation metric for Intent Detection. Table 5 demonstrates the performance of different models. In-context learning with 16 demonstrations significantly outperforms few-shot fine-tuning on a single dataset (None → ChattyChef) with 128 examples.
Moreover, fine-tuning on another dataset first (X → ChattyChef), either from in-domain or outof-domain, does help boost the performance (over None → ChattyChef) dramatically on all settings. This result is expected for the in-domain dataset as, besides the domain similarity, CookDial and ChattyChef also share a large number of intents. More interestingly, leveraging MultiWOZ and SGD also improves the performance by more than 28% and 33% for the 16- and 128-shot, respectively, even though these two datasets cover quite different domains and intents from ChattyChef.
Finally, fine-tuning the model on MultiWOZ or SGD first further improves the performance of
CookDial → ChattyChef. In particular, both MultiWOZ/SGD → CookDial → ChattyChef outperform CookDial → ChattyChef on all settings with large margins. From this result and the above observations, we note that fine-tuning on a large dataset first, even from other domains, is extremely helpful for intent detection in the low-resource setting.
Since we want to measure the effectiveness of incorporating the intent information into the generation model, we will use the intent predictions from the best model (SGD → CookDial → ChattyChef 128-shot) in the later experiments on response generation (§5).

heading: 4 Instruction State Tracking
text: We study the second subtask to support the instruction ordering of the generation module – Instruction State Tracking. The goal of this task is to predict the current state of the instruction, or in other words, the last instructed recipe step. Formally, given the tth system response U syst , the previous instruction state Tt−1 (i.e., an index of a recipe step), and the recipe with a list of nr steps R = {R1, R2, . . . , Rnr}, the expected output of this subtask is Tt.

heading: 4.1 Aligning Conversations to Recipe Steps
text: For this subtask, we adopt a simple unsupervised approach to track the instruction state. The key idea of our approach is to align the most recent system utterance with its most similar step in the
recipe, and this aligned step will be the current instruction state. If the utterance can not be aligned with any recipe steps, the current instruction state will be the same as the previous one. For the scoring function that measures similarity between the conversation history and the text of recipe steps, we use two simple approaches: (1) WordMatch (Word Matching): the scoring function computes the unigram F1 overlap between two input texts. (2) SentEmb (Sentence embedding): the scoring function computes the cosine similarity between sentence embeddings of the two input texts. More details about the alignment algorithm and SentEmb approach are described in Appendix B.2.

heading: 4.2 Experiments
text: Setup. For this subtask, we evaluate two approaches: WordMatch and SentEmb, which were discussed above. We manually annotate the instruction states for all the system responses in ChattyChef and evaluate the accuracy of the two approaches on the validation and test sets.
Results. The performance of Instruction State Tracking is reported in Table 6. Despite of its simplicity, the WordMatch approach has comparable performance to SentEmb. In particular, WordMatch outperforms SentEmb on the validation set by 1.2%, but is slightly worse on the test set by 0.4%. One plausible explanation is that there are many entities (e.g., ingredients, cooking utensils) in the recipe that are hardly be paraphrased in the cooking dialogue. In the next section, we will use the predicted instruction state from the WordMatch approach for integration with the generation model.

heading: 5 Response Generation
text: Given the conversation history and the grounded recipe, the Response Generation task aims to generate the instruction response to the user. Formally, given the history H = {U sys1 , Uusr1 , ..., U syst−1, Uusrt−1}, the recipe R, the dialog system is expected to generate the next utterance U syst .

heading: 5.1 Generating Dialog Responses
text: Base Model. In this work, we chose GPT-J (Wang and Komatsuzaki, 2021) as the base model. To fine-tune the model, we follow the approach of Peng et al. (2022) that concatenates the dialog history, the cooking recipe, and the system response as “H 
 R =>[system]U syst ”
and feed it to the model. Both [system] and 
 are regular text strings. Let S be the source text, which corresponds to part of this concatenated string of the dialog history and the cooking recipe (i.e., “H 
 R =>[system]”). In the fine-tuning phase, the model tries to learn the conditional probability of P (U syst |S), which can be written as the product of a series of conditional probabilities:
P (U syst |S) = nt∏
i=1
p(U syst,i |U sys t,<i, S)
where nt is the length of the response at the tth turn of conversation, U syst,<i indicates all tokens before the ith token generated by the system.
Intent-aware Model. Since the intent labels may not convey the full meaning of the user’s intents (§3), we propose to leverage the natural language description of the intents when integrating this information type into the model. In particular, we enhance the input prompt to the GPT-J model as “H 
 R [user] wants to:D. => [system] U syst ”, where D is the description of user intent. An example prompt is shown in Table 13 (in the Appendix).
State-aware Model. When provided with a full recipe, the response generation model might have difficulty choosing the correct recipe part to condition on when generating a response, which can lead to giving wrong order instructions. As the instruction state (§4) indicates the last instructed step, this information is essential for selecting the proper knowledge from the recipe for the model. Therefore, we explore two heuristic approaches for knowledge selection: (1) Cutoff: only select recipe steps starting from the current instruction state. Formally, the input prompt to the GPT-J model is “H 
 R′=>[system]U syst ”, where R′ = {RTt−1 , . . . , Rnr}, and Tt−1 is the output from the Instruction State Tracking module. (2) Center: Only select recipe steps in the ±1 window around the current state. Formally, the input prompt to GPT-J will be similar to Cutoff except for R′ = {RTt−1−1, RTt−1 , RTt−1+1}.

heading: 5.2 Experimental Setup
text: For this task, we evaluate the following models: (1) GPT-J: the base GPT-J model. (2) GPT-J+cut: a state-aware model, using the Cutoff approach to
select the grounded knowledge. (3) GPT-J+ctr: same as the above method, but the grounded knowledge is selected by using the Center approach. (4) GPT-J+int: the GPT-J model which is incorporated with User Intent information. (5) GPTJ+ctr+int: a state-aware model using the Center approach and is additionally incorporated with user intent. (6) ChatGPT:4 We also interact with ChatGPT, a chatbot launched by OpenAI. We provide the recipes and the corresponding conversation histories from our test set and ask ChatGPT to provide the next system response. At the time of writing, because OpenAI had not yet published an API to process a large number of requests, we manually interacted with ChatGPT and collected 131 responses for 10 test conversations. The details about the training process of GPT-J base model and its variants are provided in Appendix B.3.

heading: 5.3 Results
text: We report the following automatic evaluation metrics: BLEU (Papineni et al., 2002),5 BLEURT (Sellam et al., 2020), the average length of the outputs and the diversity scores (Li et al., 2016) based on the proportion of unique n-grams over the total number of n-grams. Because there is a lack of consensus on how best to automatically evaluate open-domain dialogue models (Liu et al., 2016; Sedoc et al., 2019; Csáky et al., 2019), we also conduct two human evaluations in which model outputs are rated in terms of correctness while the errors are categorized.
4https://chat.openai.com/chat 5All BLEU scores reported in this paper are based on
corpus-level BLEU-4.
Automatic Evaluation. Table 7 shows the performance of different models on the test set of ChattyChef. All GPT-J variants (+int, +cut, +ctr, and +int+ctr) have comparable or better performance than the base model, except for GPT-J+int, which has a lower BLEU score, and GPT-J+ctr, which has lower diversity scores. In terms of the comparison of the two knowledge selection methods, GPT-J+ctr has higher BLEU and BLEURT scores, while GPT+J+cut has better diversity scores. One possible reason is that the Center approach considers a small context window of at most three recipe steps. It helps the model to focus on the most relevant information; but at the same time, it reduces the total amount of knowledge the model can rely on to instruct, making the responses less diverse than other models. Finally, incorporating the intent information does not show improvement in terms of BLEU and BLEURT, however, this approach does help increase the diversity of the generated responses. We also conduct additional experiments on the CookDial dataset in Appendix A.
Human Evaluation. In order to further understand the behaviors of the models, we ask three annotators to analyze the system outputs and manually categorize their errors. We also ask the annotators to rate the correctness of each system response, using a 5-point Likert scale (i.e., 5-completely correct; 4-mostly correct, has minor and acceptable errors; 3-borderline, has both correct and incorrect information, nothing outweighs the other; 2- mostly incorrect, but still has correct information; 1-completely incorrect). The inter-annotator agreements measured by the nominal and ordinal Krippendorff’s alpha (Krippendorff, 2004) for the error categorization and correctness rating are 0.43 and
0.62, respectively. More details about how to aggregate three annotations are in Appendix C). As shown in Table 7 and Figure 4, all GPT-J variants that incorporate the intent and/or state information have fewer errors and more responses rated with 4 and 5 for correctness than the base model. Even though automatic metrics do not show a clear difference, human evaluation reveals that GPT-J+int has fewer (22.9%→18.3%) wrong-order errors compared to the base model and is also the model with the least number of this type of error. On the contrary, using Center approach (i.e., GPT-J+ctr and GPT-J+ctr+int) in grounded recipe selection does not have much impact on reducing the number of wrong-order responses, despite the fact that it helps improve BLEU and BLEURT scores. In addition, all +int/+ctr variants of GPT-J have fewer responses
with severe wrong-order errors (correctness of 1) than the base model.
Finally, we also analyze the errors in the outputs of ChatGPT. Overall, ChatGPT performs extremely well in this task with only 10.7% of the outputs being erroneous. The outputs of ChatGPT are notably longer than other systems since ChatGPT tends to instruct multiple recipe steps in one utterance or utilize knowledge outside the given recipe. As shown in Table 7, wrong-order instruction is still the most common error for ChatGPT. One scenario where ChatGPT makes mistakes in terms of the ordering is when the recipe step contains multiple microsteps (see an example in Figure 3). It indicates that there are still many challenges that remain unsolved in the cooking instruction dialogue task.

heading: 6 Related Work
text: The task of recipe-grounded conversation is close to the Conversational Question Answering (CQA) task. In CQA, given a reference text, the system needs to engage in a multi-turn conversation to answer questions from users. Compared to singleturn question answering, CQA raises new challenges (e.g., co-reference resolution, contextual reasoning) due to the dependency between Question Answering turns. There exist multiple datasets in this area, such as CoQA (Reddy et al., 2019), QuAC (Choi et al., 2018), DoQA (Campos et al., 2020), and ShARC (Saeidi et al., 2018). There are several differeces between Instructional Dialogue and Conversational Question Answering. Firstly, in the dialogue setting, the message from the system can also be a question, such as verification. Secondly, while the goal of CQA is seeking information, Instructional Dialogue focuses on supporting users to complete a procedure; therefore, there is additional order-related relationship between the system’s responses and the instructions that needs to be managed by the dialog agent.
Recent work has investigated issues that arise in chatbots based on large language models. For instance, they are known to sometimes generate toxic language (Baheti et al., 2021; Deng et al., 2022), make factual errors in their statements (Honovich et al., 2021; Dziri et al., 2022; Rashkin et al., 2021), and be overly confident (Mielke et al., 2022). In this work, we focus on addressing a specific problem related to instruction-grounded dialogue, which is presenting information in the wrong order to a user.
A small amount of prior work (Jiang et al., 2022; Strathearn and Gkatzia, 2022) has started to explore the problem of recipe-grounded conversation, which makes these papers the two closest to ours. Both of these papers focused primarily on dataset creation. Jiang et al. (2022) included experiments on response generation, but as their focus was on building a new dataset, they did not conduct extensive experiments or perform a human evaluation of their system’s outputs. They did propose baselines and evaluate the tasks of User Question Understanding and Agent Action Frame Prediction, which are similar to our User Intent Detection and Instruction State Tracking. Although these tasks have similar goals, our work is different in the sense that we focus on tackling the problems in the lowresource setting, by transferring knowledge from
existing dialogue corpora such as MultiWOZ. Finally, besides providing additional recipe-grounded conversations as in these two prior works, our main focuses are on analyzing challenges of current large langauge models (i.e., GPT-J and ChatGPT) on this task and addressing the specific challenge of instruction ordering.

heading: 7 Conclusion
text: In this paper, we have proposed to explore two additional subtasks, namely User Intent Detection and Instructional State Tracking, to mitigate the problem of incorrect instruction order in Instructional Dialogue. We analyze these two auxiliary subtasks with different methods in low-resource settings. Even though the performance of the modules for the two subtasks is still low, experiment results show that incorporating the user intent or state information does help to mitigate the wrongorder instructions issue, with the intent information having a greater impact. However, combining the two pieces of information does not lead to improvement over using each individual one of them alone. Therefore, we believe that further research for the two subtasks is still needed, and also more effective ways of incorporating the information into the Response Generation module need to be investigated. Finally, we release ChattyChef, a new cooking instructional dataset, to promote future research in this direction.
Limitations
In this work, we have only analyzed the common errors of two models (i.e., GPT-J and ChatGPT) in the Instructional Dialogue task. One open question is whether other GPT-based models or models with other architectures (e.g., encoder-decoder models) also have the same issue in this task. Our work and dataset are also limited to the English language.
Ethical Considerations
To collect recipe-grounded conversations we hired crowd workers using the Prolific platform.6 The study was conducted with the approval of our local IRB. The compensation was derived based on Prolific’s payment principles. We estimate the hourly pay for crowd workers was $15.49 (details in Appendix D). Crowd workers were strictly asked not to write any offensive content or personal information.
6https://www.prolific.co/

heading: Acknowledgments
text: We thank Yao Dou, Fan Bai as well as four anonymous reviewers for their helpful feedback on this work. We also thank Govind Ramesh, Grace Kim, Yimeng Jiang for their help with human evaluation. This research is supported in part by the NSF awards IIS-2112633 and IIS-2052498. The views and conclusions contained herein are those of the authors and should not be interpreted as necessarily representing the official policies, either expressed or implied, of NSF or the U.S. Government. The U.S. Government is authorized to reproduce and distribute reprints for governmental purposes notwithstanding any copyright annotation therein.

heading: A Experiments on CookDial dataset
text: A.1 Incorporation of Instruction State and User Intent information
In this section, we explore the performance of models using Instruction State and Intent Information on the CookDial dataset. We fine-tuned the models adopting the same approaches as in §5 and using the same set of automatic metrics to evaluate. Instead of extracting silver labels, We use the gold Instruction State (i.e., "tracker_completed_step" in CookDial) and User Intent information from the CookDial dataset. The performance of all models is demonstrated in Table 8.
From the table, we can see that the model performance on CookDial is much higher than in our dataset, this is due to the more straightforward instruction scenarios and higher lexical similarity between the grounded recipe and system utterances in CookDial (as discussed in §2.2). In addition, similar behaviors of the models fine-tuned on CookDial and ChattyChef can also be observed here - incorporating the Instruction State information helps to improve BLEU and BLEURT scores, while incorporating the intent information helps the models generate more diverse responses.
A.2 Transfer learning from CookDial to ChattyChef
To explore whether the information learned from CookDial is helpful for our dataset, we keep finetuning the model from Table 8 with the corresponding settings on our dataset. As shown in Table 9, transfer learning does not show a clear improvement in terms of BLEU and BLEURT, it even hurts the performance of the model in many cases. The big difference between the two datasets (as discussed in §2.2) may be the reason why transfer learning is ineffective here. However, transfer learning also has the merit of making the system outputs more diverse, especially for GPT-J+cut and GPT-J+ctr.
B Implementation Details
For all experiments, we train models across 4 A40 GPUs (48GB each). The total GPU hours for training a GPT-J model in the Response Generation task is about 5.3 hours, and the total GPU hours for training the T5 models in the User Intent Detection task is about 4 hours.
B.1 User Intent Detection The details about user intents and their description are reported in Table 10. Examples of input and out prompts to the T5 model are demonstrated in Table 12.
For all experiments which use T5 model, we set the maximum sequence length to 1028 and the number of training epochs to 30, we stop the training process if the perplexity of the model on the validation set does not improve after 5 epochs. We use AdamW to optimize and consider the initial learning rate ∈ {1e-5, 5e-5, 1e-4}. For the in-context setting, the maximum length of the input sequence is set to 1984.
For all the models, we employ beam search with a beam size of 5 for decoding. We select the model checkpoint that produces the lowest perplexity on the validation set and then apply the selected one to the test set.
B.2 Instruction State Tracking The Instruction State Tracking Algorithm is described in Algorithm 1). In order to produce the system utterance - recipe alignment, similarity scores between the most recent system response to all the recipe steps are computed (Line 3 - 7 in Algorithm 1). After that, by comparing the similarity
Algorithm 1: Instruction State Tracking Input: RecipeR = {R1, R2, . . . , Rnr}
Most recent system utterance: Usyst Previous instruction state: Tt−1 Threshold parameters 0 < α1 ≤ α2 < 1 Scoring function f
Output: Instruction State Tt 1 Initialize score[i] = 0 ∀i = 1, 2, . . . , nr 2 Initialize current_state = Tt−1 /* compute similarity scores
between the most recent system utterance and all recipe steps */
3 for i = 1, 2, . . . , nr do 4 micro_steps← sentence_tokenize(Ri) 5 score[i] = maxr∈micro_steps f(U sys t , r) 6 best_state← argmax(score) 7 max_score← score[best_state] 8 if (best_state == current_state+ 1 and
max_score > α1) or (max_score > α2) then 9 current_state← best_state
10 Tt ← current_state
score to thresholds (i.e., α1 and α2), the algorithm decides whether the current system utterance is aligned to a new state (i.e., a new recipe step – line 9 in Algorithm 1) or is aligned with the previous state.
For the Sentence Embedding approach, we use sentence-transformers/paraphraseMiniLM-L6-v2 (Reimers and Gurevych, 2019) to compute the sentence embeddings of system responses and recipe steps. We use NLTK(Bird et al., 2009) to perform the word and sentence tokenization. About the threshold, we set α1, α2
equal to 0.2 and 0.3, respectively, for the Word Matching approach. For the sentence embedding approach, we set α1 equal to 0.5 and α2 equal to 0.6. The thresholds are chosen based on the accuracy of the validation set.
B.3 Response Generation
An example of the input to the GPT-J model is illustrated in Table 13.
To fine-tune all the GPT-J models, We set the maximum sequence length to 1280 and the number of training epochs to 3. We use AdamW to optimize and set the initial learning equal to 1e-5, except for transfer learning experiments with CookDial, in which we use the learning rate of 5e-6. We employ beam search with a beam size of 5 for decoding. We select the model checkpoint that produces the lowest perplexity on the validation set and then apply the selected one to the test set.

heading: C Human Evaluation
text: In this section, we discuss the way to aggregate annotations from annotators. For the error categorization experiment, the final decision of an example is reached if all three annotators have the same annotation. When only two annotators have the same annotation, a fourth one will join and decide whether to agree with the majority. In all other situations, a discussion between annotators is held, and the final decision is based on majority voting. For the correctness rating experiment, the rating of each example is the average score of the three annotators. In cases when only two annotators rate an example as completely correct or a rating of 5, but the third one detects an error and marks the example as incorrect (i.e., belongs to one of the four error types), if the final decision from the error categorization is also incorrect, the correctness of this example is the rating of the third annotator. The same rule applies to the opposite situation, i.e., only two annotators rate an example as completely incorrect, and the third one thinks it is correct.

heading: D Dataset construction
text: D.1 Collection Strategies
Even though employing two workers using different interfaces has advantages, we see that pairing workers on a task is inefficient. In particular, for each conversation, one worker would need to wait for a long time until the partner joined the task. Moreover, in some cases, some workers are uncooperative. For example, during the chat, one worker may spend too much time sending his messages or even quit the task, which will have a bad impact on his partner (Choi et al., 2018; Reddy et al., 2019). As a result, we study three different collection strategies as follows. Paired conversations (Paired): Two workers are required for each conversation; one acts as the
agent, and the other act as the user. After two workers got paired, they would be assigned to the same cooking task; however, only the agent has access to the recipe, and all the user knows about this task is the title (i.e., what to cook). Self-chat (Self): In this mode, only one worker is needed for each conversation. The worker will play both roles (i.e., Agent and User). Model-User (M-User): One worker is assigned for each conversation in this mode. However, unlike Self-chat, when the worker plays the User role, he would be provided with candidate responses from a model, and he could either pick one and edit it or enter his own words.
All conversations were collected through the ParlAI API (Miller et al., 2017). The participants for this paper were recruited using Prolific
(www.prolific.co). We restricted the task to workers whose first language is English and with more than 100 submissions with at least a 99% approval rate. Crowd workers were not informed of the specific details of the dataset. However, they consented to have their responses used for this purpose through the Prolific Participation Agreement. The statistic about each collection method is reported in Table 11.
D.2 Collection Interfaces See Figure 7 for the screenshot of our crowdsourcing interface.
ACL 2023 Responsible NLP Checklist

heading: A For every submission:

heading: 3 A1. Did you describe the limitations of your work?
text: Section Limitations
A2. Did you discuss any potential risks of your work? Not applicable. Left blank.

heading: 3 A3. Do the abstract and introduction summarize the paper’s main claims?
text: Section 1
7 A4. Have you used AI writing assistants when working on this paper? Left blank.
B 3 Did you use or create scientific artifacts? Section 2, 3, 4, 5

heading: 3 B1. Did you cite the creators of artifacts you used?
text: Section 2, 3, 5, Appendix B
B2. Did you discuss the license or terms for use and / or distribution of any artifacts? Not applicable. Left blank.
B3. Did you discuss if your use of existing artifact(s) was consistent with their intended use, provided that it was specified? For the artifacts you create, do you specify intended use and whether that is compatible with the original access conditions (in particular, derivatives of data accessed for research purposes should not be used outside of research contexts)? Not applicable. Left blank.
7 B4. Did you discuss the steps taken to check whether the data that was collected / used contains any information that names or uniquely identifies individual people or offensive content, and the steps taken to protect / anonymize it? Section Ethical Considerations

heading: 3 B5. Did you provide documentation of the artifacts, e.g., coverage of domains, languages, and
text: linguistic phenomena, demographic groups represented, etc.? Section 2, Appendix C
3 B6. Did you report relevant statistics like the number of examples, details of train / test / dev splits, etc. for the data that you used / created? Even for commonly-used benchmark datasets, include the number of examples in train / validation / test splits, as these provide necessary context for a reader to understand experimental results. For example, small differences in accuracy on large test sets may be significant, while on small test sets they may not be. Section 2, 3, 4
C 3 Did you run computational experiments? Section 3, 4, 5, Appendix B

heading: 3 C1. Did you report the number of parameters in the models used, the total computational budget
text: (e.g., GPU hours), and computing infrastructure used? Appendix B
The Responsible NLP Checklist used at ACL 2023 is adopted from NAACL 2022, with the addition of a question on AI writing assistance.

heading: 3 C2. Did you discuss the experimental setup, including hyperparameter search and best-found
text: hyperparameter values? Appendix B

heading: 3 C3. Did you report descriptive statistics about your results (e.g., error bars around results, summary
text: statistics from sets of experiments), and is it transparent whether you are reporting the max, mean, etc. or just a single run? Section 3, 4, 5

heading: 3 C4. If you used existing packages (e.g., for preprocessing, for normalization, or for evaluation), did
text: you report the implementation, model, and parameter settings used (e.g., NLTK, Spacy, ROUGE, etc.)? Appendix B
D 3 Did you use human annotators (e.g., crowdworkers) or research with human participants? Section 2, Appendix C

heading: 3 D1. Did you report the full text of instructions given to participants, including e.g., screenshots,
text: disclaimers of any risks to participants or annotators, etc.? Section 2, Appendix C

heading: 3 D2. Did you report information about how you recruited (e.g., crowdsourcing platform, students)
text: and paid participants, and discuss if such payment is adequate given the participants’ demographic (e.g., country of residence)? Appendix C

heading: 3 D3. Did you discuss whether and how consent was obtained from people whose data you’re using/curating? For example, if you collected data via crowdsourcing, did your instructions to
text: crowdworkers explain how the data would be used? Section 2, Appendix C

heading: 3 D4. Was the data collection protocol approved (or determined exempt) by an ethics review board?
text: Section Ethical Considerations

heading: 3 D5. Did you report the basic demographic and geographic characteristics of the annotator population that is the source of the data?
text: Appendix C

heading: Future Work
text: Finally, we release ChattyChef, a new cooking instructional dataset, to promote future research in this direction. Limitations
In this work, we have only analyzed the common errors of two models (i. e. , GPT-J and ChatGPT) in the Instructional Dialogue task. One open question is whether other GPT-based models or models with other architectures (e. g. , encoder-decoder models) also have the same issue in this task. Our work and dataset are also limited to the English language. Ethical Considerations
To collect recipe-grounded conversations we hired crowd workers using the Prolific platform. 6 The study was conducted with the approval of our local IRB. The compensation was derived based on Prolific’s payment principles. We estimate the hourly pay for crowd workers was $15. 49 (details in Appendix D). Crowd workers were strictly asked not to write any offensive content or personal information. 6https://www. prolific. co/