# Self-Explanation Prompting Improves Dialogue Understanding
in Large Language Models

###### Abstract

Task-oriented dialogue (TOD) systems facilitate users in executing various
activities via multi-turn dialogues, but Large Language Models (LLMs) often
struggle to comprehend these intricate contexts. In this study, we propose a
novel ”Self-Explanation” prompting strategy to enhance the comprehension
abilities of LLMs in multi-turn dialogues. This task-agnostic approach
requires the model to analyze each dialogue utterance before task execution,
thereby improving performance across various dialogue-centric tasks.
Experimental results from six benchmark datasets confirm that our method
consistently outperforms other zero-shot prompts and matches or exceeds the
efficacy of few-shot prompts, demonstrating its potential as a powerful tool
in enhancing LLMs’ comprehension in complex dialogue tasks.

Keywords: large language model, prompting, dialog understanding

languageresource

Self-Explanation Prompting Improves Dialogue Understanding
in Large Language Models

Haoyu Gao123†, Ting-En Lin2, Hangyu Li2, Min Yang3∗, Yuchuan Wu2, Wentao Ma2,
Yongbin Li2∗ ††thanks: ∗ Corresponding authors. ††thanks: $\dagger$ Work done
while interning at Alibaba.
---
1 University of Science and Technology of China 2 Alibaba Group
3Shenzhen Institute of Advanced Technology, Chinese Academy of Sciences
{hy.gao<EMAIL_ADDRESS>
<EMAIL_ADDRESS>

Abstract content

## 1\. Introduction

Recent advancements in large language models (LLMs) have achieved great
success in various NLP tasks. Brown et al. (2020); Touvron et al. (2023);
Chowdhery et al. (2022). However, the vast model parameters pose challenges in
downstream fine-tuning. To circumvent these challenges, diverse zero-shot
prompting strategies have been researched to enhance LLM performance Brown et
al. (2020); Liu et al. (2021); Sorensen et al. (2022). In-context learning
emerges as a viable alternative to fine-tuning, leveraging examples to augment
language processing abilities. To elicit the reasoning ability of LLMs, Chain-
of-Thought has been seamlessly integrated within the prompting framework,
showing remarkable performance in tasks requiring complex reasoning Wei et al.
(2022); Miao et al. (2021); Talmor et al. (2018). Stemming from CoT prompting,
numerous studies have delved into refining CoT via prompt design modifications
Li et al. (2022); Fu et al. (2022); Zhang et al. (2022) and optimizing
reasoning paths Wang et al. (2022a, b); Zelikman et al. (2022). In contrast,
to reduce dependency on human demonstrations, the Zero-shot CoT Kojima et al.
(2022) employs the post-append instruction, ’Let’s think step by step,’ urging
Large Language Models (LLMs) to derive the stages of reasoning sequentially
and automatically.

Figure 1: The input example for the reasoning task and the task-oriented dialogue is structured into two components: Context and Question. Table 1: Comparative analysis of reasoning and dialogue understanding tasks, highlighting the distinctive application of the proposed Self-Explanation method. Task | Dataset |  | Avg.
---
#Tokens
Context |  | Answer
---
Search Space
| Prompting
---
Method
Focus on
Reasoning |  | MultiArith
---
GSM8K
| 16.6
---
33.6
Short | Internal |  | Chain-of-Thought
---
Plan-and-Solve
| Reasoning
---
Step
| Dialog
---
Understanding
| SGD
---
MultiWOZ
| 940.9
---
1229.7
Long | External | Self-Explanation | Context

Despite the effectiveness of CoT prompting, most existing prompting methods
focus on eliciting the reasoning ability inherent in large language models.
However, these techniques might fall short when applied to tasks that require
contextual comprehension rather than reasoning steps. Specifically, dialogue-
based tasks Lin et al. (2022); Hu et al. (2022a); Li et al. (2023) serve as
typical examples that require strong comprehension ability rather than
reasoning ability. The task-oriented dialogue (TOD) He et al. (2022a, b, c) is
one of the most representative tasks that facilitates users in executing
various activities, including but not limited to hotel and restaurant
reservations, by engaging in multi-turn dialogues Gao et al. (2023); Qian et
al. (2023); Yu et al. (2023). An illustrative example of both the reasoning
task and the TOD can be seen in Figure 1. Contrary to the reasoning task,
which typically consists of concise context, the TOD mostly involves multi-
turn dialogues with long contexts. Not only do these tasks differ in terms of
context length, but they also exhibit variations across numerous other
dimensions. For instance, as delineated in Table 1, the reasoning task
predominantly emphasizes intricate problem-solving steps that entail extensive
computations and conversions. This underscores the model’s inherent ability to
reason. Consequently, the scope of searching for an answer predominantly
resides within the model.

However, when performing dialogue-based tasks, success depends on a strong
understanding of the context in continuous conversational exchanges rather
than complex reasoning. TOD tasks mainly obtain information directly from the
existing context, making the search space for answers strongly related to
external contexts. The different emphases of the two tasks resulted in the
underperformance of CoT prompts in dialogue contexts. Judging from the results
of existing evaluation studies Heck et al. (2023); Hudeček and Dušek (2023);
Bang et al. (2023), the current LLMs with unoptimized prompting perform
significantly worse than specialized small models on some dialogue-based
tasks. Hu et al. (2022b) have reformulated the dialogue state tracking task
into a few-shot text-to-SQL paradigm, utilizing the robust code capabilities
of Codex. While this represents an intriguing approach for training dialogue
exemplars, the text-to-SQL may not be universally applicable, particularly in
procedural TOD tasks such as next-action prediction. Additionally, the example
retriever needs to be retrained for each new dataset, which imposes
limitations on this approach.

To address the above issues, we explore several ways to enhance the
comprehension capabilities of LLMs by mimicking the way humans solve
conversational problems Chi et al. (1989). We introduce the ”Self-Explanation”
prompt strategy, requiring the model to explain every utterance in the
dialogue first and then complete the task based on the generated explanation.
Despite its simplicity, the proposed method enhances the performance of
contextual comprehension of LLMs in various dialogue-centric tasks. More
importantly, our prompt is task-agnostic and can be easily applied to a
variety of problems involving multi-turn dialogue. We evaluate the proposed
method across six dialogue-centric datasets. The results show that our prompt
consistently surpasses other zero-shot prompts and is on par with or surpasses
few-shot prompts. In summary, our contributions include:

  * •

We conduct a comprehensive comparison between reasoning tasks and dialogue
understanding tasks, identifying the limitations of current prompting methods.

  * •

We propose a simple yet effective prompting strategy, Self-Explanation, that
significantly enhances the dialogue comprehension capacities of large language
models.

  * •

Extensive experiments on six dialogue-based datasets have demonstrated that
the proposed method surpasses existing prompting approaches in performance.

Figure 2: Example inputs and outputs of GPT-3 with No explanation ahead
(upper) and Explain before answer (lower). Explanation greatly improves the
understanding of the dialogue.

## 2\. Method

### 2.1. Formalization

The problem can be divided into two components: the context, denoted as
$\mathcal{C}$, and the question, represented by $\mathcal{Q}$. The context,
$\mathcal{C}$, provides a descriptive framework that outlines the problem
setting and background. For reasoning tasks, this context delineates a
specific situation. An example of this can be observed in Figure 1, where
$\mathcal{C}$ contains the activities of James. Meanwhile, in the context of
TOD tasks, $\mathcal{C}$ typically captures a multi-turn dialogue between two
interlocutors.

Contrastingly, the question component, $\mathcal{Q}$, zeroes in on a specific
inquiry related to $\mathcal{C}$. In the realm of reasoning tasks,
$\mathcal{Q}$ typically solicits a value derived from multi-step computations.
This implies that the solution isn’t readily available within $\mathcal{C}$.
To illustrate, refer to Figure 1 where $\mathcal{Q}$ probes for the aggregate
distance James covers in a week. Addressing this necessitates discerning the
frequency of James’ sprints per week and the distance of each sprint.
Subsequent multiplication of these two quantities yields the desired result.

On the other hand, in a TOD task, the nature of $\mathcal{Q}$ is more
straightforward, often inquiring about the existence of specific information.
Using Figure 1 as a reference, the question might pertain to the scheduled
departure time of a reserved train or the type of cuisine a user seeks.
Responses to these types of inquiries are readily extractable from
$\mathcal{C}$, obviating the need for additional computation.

### 2.2. Self-Explanation

Humans often find it challenging to respond to questions grounded in extensive
new information. One strategy that has been empirically shown to enhance
comprehension of new material is self-explanation. The concept of self-
explanation, originating from psychological research Chi et al. (1989),
involves learners generating explanations for themselves while processing
unfamiliar content. Notably, this study demonstrated that learners engaging in
self-explanation were better able to grasp core concepts and principles than
their counterparts who did not employ this strategy.

Drawing inspiration from human cognitive processes and this psychological
paradigm, we introduce the Self-Explanation prompting method, a zero-shot
prompting technique designed to enhance multi-turn dialogue comprehension.
Within the process, models initially provide explanations for each utterance
in a multi-turn dialogue. Subsequently, these models execute the specified
task, relying on their previously generated explanations. In the process of
articulation, the large language models (LLMs) have the capacity to transform
low-level natural language inputs into more abstract, high-level constructs,
such as the intent or action of the speaker.

The framework is structured without the need for demonstration examples.
Following the problem formalization in section 2.1, we organise the inputs
using the template ”$\mathcal{C}$:[C]. $\mathcal{Q}$:[Q]. $\mathcal{A}$:[A]”,
wherein [C] and [Q] represents the input slot designated for the context and
question, respectively. As for the last part, [A] is populated by manually-
curated instructions prompting the model to elucidate. Central to our method
is the instruction: ”Provide explanations for each utterance and then respond
based on these explanations.” For the decoding strategy, we opt for the
straightforward greedy decoding method, though beam search decoding could be
employed to produce a broader range of explanations.

Table 2: Comparing the performance of zero-shot CoT and Self-Explanation methods on six dialogue datasets using gpt-3.5-turbo. | TOD | ERC | RS
---|---|---|---
Method | MutliWoz 2.1 | STARv2 | SGD | SpokenWoz | MELD | MuTual
Vanilla | 35.93 | 51.88 | 18.96 | 13.75 | 59.14 | 68.97
Vanilla + 4-shots | 41.60 | 52.93 | 17.34 | 14.13 | 55.09 | 72.51
Chain-of-Thought | 27.64 | 51.85 | 19.69 | 13.26 | 61.48 | 70.61
Plan-and-Solve | 39.19 | 56.74 | 21.11 | 14.50 | 58.38 | 69.77
Self-Explanation | 44.44 | 63.66 | 21.81 | 14.89 | 61.71 | 71.58
\+ GPT-4 | 50.97 | 70.27 | 25.75 | 25.94 | 63.51 | 91.87

## 3\. Experiments

### 3.1. Experimental Setup

#### 3.1.1. Datasets and task

We evaluate our self-explanation on six datasets from three categories of
dialogue understanding tasks: Task-oriented dialogue (TOD), Emotion
Recognition in Conversations (ERC) task and Response Selection (RS) task. For
TOD task, the datasets can be divided into two types based on the dialogue
schema: Procedural and Declarative Mannekote et al. (2023). A dialogue schema
in the context of task-oriented dialogue is a structured representation of the
conversation flow or some key entities (also known as ’slots’) that need to be
captured. The Procedural schema, derived from the STAR dataset Mosig et al.
(2020), represents a dialogue domain as a directed graph similar to a
flowchart. It consists of nodes representing user utterances, system
responses, or backend service calls. The main task of the procedural schema is
to strictly follow the task flow. For Procedural schema, we choose STARv2 Zhao
et al. (2022) dataset.

STARv2 dataset, which is an upgraded version of STAR Mosig et al. (2020) with
new ground truth belief state and new natural language action descriptions.
STAR is a schema-guided task-oriented dialogue dataset consisting of 24 tasks
across 13 domains. We evaluate the next action prediction task, which is to
predict the next system action conditioned on the dialogue history and take
the weighted F-1 score as the metric.

The Declarative format, based on the Schema-Guided Dialogue (SGD) dataset
Rastogi et al. (2020) and MultiWOZ dataset Budzianowski et al. (2018), aims to
capture the slots defined in dataset ontology. For the declarative format
schema, we select MultiWOZ 2.1, SGD, and SpokenWOZ Si et al. (2023) dataset
and evaluate the dialogue state tracking task, using Joint Goal Accuracy (JGA)
as the metric.

MultiWOZ2.1 is a fully-labeled collection of human-human written conversations
spanning multiple domains and topics. It contains 7 domains, 35 slots, and
over 10k dialogues.

SGD is another declarative format dataset containing over 16k multi-domain
conversations spanning 16 domains with more slots and possible values compared
to MultiWOZ.

SpokenWOZ is a new multi-modal spoken TOD dataset containing 8 domains, 5.7k
dialogues, and 35 slots. It introduces the unique challenges in spoken
conversation.

Besides the task-oriented dialogue, we also choose two datasets: MELD Poria et
al. (2018) and MuTual Cui et al. (2020) from the Emotion Recognition in
Conversations (ERC) task and response selection task, respectively. MELD
contains over 10k utterances from the TV series Friends, and each utterance is
annotated with emotion and sentiment labels. MuTual consists of 8k manually
annotated dialogues based on Chinese students English listening comprehension
exams.

Table 3: The effect of different trigger sentences measured on MultiWOZ with gpt3.5-turbo. Method | Prompt | MultiWOZ 2.1(JGA)
---|---|---
Vanilla | Answer the questions based on the above dialogue | 35.93
Understand |  | Before you answer, first understand the dialogue, then answer
---
the questions based on your understanding and original dialogue
36.52
Summary |  | Before you answer, first summarize the dialogue, then answer
---
the questions based on your summary and original dialogue
40.98
Explanation |  | Before you answer, first analyze the dialogue utterance
---
by utterance, give every utterance an explanation.
Then answer the questions based on your explanation
44.44

#### 3.1.2. Baselines

We compare our proposed zero-shot Explanation with two types of prompt
baselines: Zero-shot baselines and Few-shot. For zero-shot baselines, we
include zero-shot-CoT Kojima et al. (2022) and Plan-and-Solve Prompting Wang
et al. (2023). The former appends “Let’s think step by step” to the prompt.
The latter extends the zero-shot-CoT with plan ahead, and then carry out the
plan. Besides the zero-shot baselines, we also evaluate the In-Context
learning prompt performance on TOD task. Considering the sample of TOD task
consists of a multi-turn dialogue and the slot list, we only use 4 examples as
for not exceed the context window size. As for example selection, we randomly
selected 4 examples with the same domain as the test sample.

### 3.2. Main Results

Table 2 presents the performance of our method compared to baseline approaches
across six distinct datasets. In the zero-shot scenario, our technique
consistently surpasses the baselines on all evaluation datasets, irrespective
of their differences. While CoT prompting does not enhance performance on TOD
tasks, our method notably excels by an impressive 12% margin on the STARv2
dataset.

This significant improvement underscores the effectiveness of self-explanation
prompting. The task format aligns well with this prompting approach, leading
to detailed sentence-by-sentence explanations. These explanations play a
pivotal role in comprehending the dialogue flow and adhering to the given
schema. The enhanced performances on MultiWOZ, SGD, and SpokenWOZ further
affirm that the dialogue state tracking task greatly benefits from self-
explanation prompts. By providing explanations for each utterance, the
likelihood of overlooking dialogue states is diminished. In addition to the
task-oriented dialogue tasks, we assessed the impact of self-explanation
prompting on both the ERC and RS tasks. However, the gains here were
relatively modest in comparison to the TOD tasks. Given that our explanations
are rooted in semantic interpretations, they may not be as beneficial for
tasks centered on emotion recognition.

Compared to the few-shot baseline, our zero-shot prompting either outperforms
or matches performance across all six datasets. This underscores the argument
that a comprehensive understanding of dialogue is more critical than merely
having a set of examples. The efficacy of in-context learning is largely
attributed to its input-label pairing formats, its access to the label space,
and the modification of the input distribution. For tasks within the domain of
TOD, the input usually consists of multi-turn dialogues encompassing various
topics, necessitating a profound understanding of the dialogue’s entirety. The
intricate nature of TOD tasks demands a high level of comprehension, which
mere exposure to a few examples fails to deliver.

### 3.3. Analysis

#### 3.3.1. Effect of Explanation

To assess the impact of self-explanation on dialogue comprehension, we carried
out a comparative study using the MultiWOZ dataset, testing four distinct
prompting methods. The results of these tests can be found in 3.

In the Vanilla method, no additional instruction is given before the model
provides its response. In the Understand method, the model is simply prompted
with ”Understand the dialogue first” prior to answering. However, there’s no
specified format for the intermediate comprehension. With the Summary method,
the model is prompted to first summarize the dialogue. It then bases its
answer on both the summary and the original dialogue.

Our observations revealed that when comparing the self-explanation method with
Vanilla, there was a notable decline in performance. This suggests that pre-
processing or understanding the dialogue is essential for optimal performance.
Merely prompting the model to understand the dialogue without detailed
instruction also resulted in reduced performance. This demonstrates the
importance of precise comprehension guidelines. Without them, LLMs tend to
produce explanations for their answers as opposed to comprehending the
dialogue. Providing detailed comprehension instructions is less ambiguous than
allowing the model to self-navigate. The Summary method explicitly directs the
model to use the summary as a means of comprehension, subsequently answering
based on that summary. This approach enhanced performance by approximately 5%
JGA in comparison to the Vanilla method. However, summarizing is a broad-
strokes approach and might overlook finer details essential for the TOD task.

Drawing from psychological research, specifically Chi et al. (1989), it’s
evident that not all explanations confer the same benefits. Factors like
content, quality, and depth of explanations are paramount. Our refined method,
the self-explanation prompting, instructs the model to generate sequential
explanations, promoting deeper dialogue understanding.

Table 4: The dialogue content and answer predicted of three typical error type in MultiWOZ dataset where Self-Explanation get the correct answer and Vanilla get the incorrect answer. Error Type | Dialogue | Explanation | Vanilla
---|---|---|---
Time involved |  I need to get to Michaelhouse cafe by 12:45. |  | taxi-arriveby:
---
12:45
| taxi-leaveat:
---
12:45
Missing info. |  |  I am leaving Cambridge at 12:00 on Sunday,
---
can you please tell me the travel time on that ride?
| train-departure:
---
cambridge
| train-departure:
---
None
| Task unclear
---
understand
|  Please help me find the attraction downing college.
---
Yes, it’s on Regent Street in the centre of town.
Would you like the phone number?
| attraction-name:
---
downing college
| attraction-name:
---
downing college
attraction-area:
centre

#### 3.3.2. Case Study

To have a straightforward understanding of how explanation affects task
completion, We manually checked all the cases of MultiWOZ dataset that were
correctly answered by self-explanation but incorrectly answered by Vanilla and
picked several typical errors. As shown in Table 4

Generally, there are three main types of errors: time involved, missing
information, and unclear task understanding. For the first error type, the
model usually gets confused with departure time and arrival time. In the case
of time-involved errors, the user needs a taxi that arrives by 12:45. While
the model output of the vanilla prompting assigns 12:45 to the time of taxi
departure.

The second error type, missing information error, mostly happens in the
dialogue, which has a high number of turns. The large amount of dialogue
information may distract the model from correctly capturing all the
information needed to complete the task. As the case of this error shows, the
user expresses the place, time, and date of departure in one sentence. The
model output of vanilla prompting misses the place of departure, while the
output of self-explanation prompting correctly captures all the information
about the user request.

The last error type is a task-specific error. In the dialogue state track
task, the dialogue state should include the information that the user
requested and exclude the system provides. In the case of the final type of
error, the user explicitly requests an attraction called Downing College, and
the system provides some relevant information about this attraction. The model
output of self-explanation prompting correctly distinguishes the information
the user requested and the system provided. While the model output of Vanilla
prompting mistakenly includes the system information in the dialogue state.

#### 3.3.3. Connection with CoT Prompting

We have explored self-explanation prompting as a simple way to enhance the
understanding of multi-turn dialogue in large language models. In this
section, we’ll connect the dots between self-explanation prompting and CoT
prompting.

From a macro perspective, OpenAI’s documentation indicates that giving models
a moment to ”think” is beneficial. Analogous to human cognition, hastily
jumping to conclusions often leads to mistakes. CoT prompting, which requires
a systematic rationale before presenting an answer, effectively grants models
this ”thinking” time. Similarly, our self-explanation prompting offers models
a moment of reflection, but it steers them to interpret the intricate context,
$\mathcal{C}$, as opposed to breaking down the answer’s rationale.

From a micro perspective, CoT prompting guides the model toward a solution by
narrowing the scope of potential answers. In tasks requiring reasoning, the
solution isn’t straightforwardly derived from the context $\mathcal{C}$. The
response involves extensive calculations and transformations, heavily drawing
on the model’s innate reasoning faculties. This suggests the solution space is
largely tethered to the model’s capabilities. The logical progression elicited
by CoT prompting either constrains or directs this solution space.

Conversely, in the TOD task, the query $\mathcal{Q}$ typically seeks details
readily found in $\mathcal{C}$. Unlike reasoning assignments, these questions
don’t demand intricate computations. As such, the solution space primarily
lies within $\mathcal{C}$. The enhanced dialogue comprehension, courtesy of
our self-explanation prompting, offers an alternative approach to narrowing
down this solution space.

## 4\. Related work

Prompting Methods: The exploration of prompting methods for machine learning
models has been vast. One of the conventional methods is in-context learning
(ICL), as highlighted by GPT-3Brown et al. (2020). In ICL, multiple
demonstrations are provided before a test sample, and the model’s performance
significantly hinges on these demonstrations Zhao et al. (2021); Lu et al.
(2021).

Some researchers, such as those in Liu et al. (2021), endeavor to retrieve
examples semantically similar to a test query sample, utilizing metrics like
the L2 distance or cosine-similarity distance derived from sentence
embeddings. In addition to these distance metrics, the concept of mutual
information emerges as a potent example selection criterion Sorensen et al.
(2022). Here, the goal is to select a template that optimizes the mutual
information between the input and the model’s output. Taking this further,
several studies, such as (Rubin et al., 2021), have shifted towards a
supervised approach, training models to pick the most relevant demonstrations
from a pool of candidates.

Reasoning Strategies: Beyond merely selecting examples, their arrangement or
ordering can significantly influence a model’s performance. Enter the Chain-
of-Thought (CoT) strategy Wei et al. (2022), a pioneering prompting approach
designed to enhance the performance of large language models (LLMs) on
intricate reasoning tasks. Unlike ICL, which relies on prepending input-output
pairs, CoT integrates a sequence of intermediate reasoning steps into the
demonstration, thereby amplifying the reasoning capabilities of LLMs.

Recognizing the importance of diverse reasoning paths, the self-consistency
strategy Wang et al. (2022a) was introduced. It first creates multiple
reasoning paths rather than just the most likely one and subsequently selects
the most coherent answer by considering all the generated paths. Further
automation in this domain is achieved with zero-shot CoT Kojima et al. (2022).
Instead of relying on human-annotated reasoning sequences, this method induces
the model to generate reasoning steps by simply prompting it to ’think step by
step’.

## 5\. Conclusion

In this paper, we find that CoT prompting is suboptimal for multi-turn
dialogue tasks that require strong comprehension abilities. To enhance the
comprehension of LLM, we propose a new zero-shot prompting strategy called
self-explanation prompting, which guides the LLM to first understand the
multi-turn dialogue by explaining every utterance and then completing the task
based on dialogue with its explanation. Extensive experiments show that
explanation prompting can boost the LLMs contextual understanding of multi-
turn dialogue and significantly outperform or perform on par with the previous
zero-shot and few-shot baselines.

##

  * Bang et al. (2023) Yejin Bang, Samuel Cahyawijaya, Nayeon Lee, Wenliang Dai, Dan Su, Bryan Wilie, Holy Lovenia, Ziwei Ji, Tiezheng Yu, Willy Chung, et al. 2023.  A multitask, multilingual, multimodal evaluation of chatgpt on reasoning, hallucination, and interactivity.  _arXiv preprint arXiv:2302.04023_.
  * Brown et al. (2020) Tom Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared D Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, et al. 2020.  Language models are few-shot learners.  _Advances in neural information processing systems_ , 33:1877–1901.
  * Budzianowski et al. (2018) Paweł Budzianowski, Tsung-Hsien Wen, Bo-Hsiang Tseng, Inigo Casanueva, Stefan Ultes, Osman Ramadan, and Milica Gašić. 2018.  Multiwoz–a large-scale multi-domain wizard-of-oz dataset for task-oriented dialogue modelling.  _arXiv preprint arXiv:1810.00278_.
  * Chi et al. (1989) Michelene TH Chi, Miriam Bassok, Matthew W Lewis, Peter Reimann, and Robert Glaser. 1989.  Self-explanations: How students study and use examples in learning to solve problems.  _Cognitive science_ , 13(2):145–182.
  * Chowdhery et al. (2022) Aakanksha Chowdhery, Sharan Narang, Jacob Devlin, Maarten Bosma, Gaurav Mishra, Adam Roberts, Paul Barham, Hyung Won Chung, Charles Sutton, Sebastian Gehrmann, et al. 2022.  Palm: Scaling language modeling with pathways.  _arXiv preprint arXiv:2204.02311_.
  * Cui et al. (2020) Leyang Cui, Yu Wu, Shujie Liu, Yue Zhang, and Ming Zhou. 2020.  Mutual: A dataset for multi-turn dialogue reasoning.  _arXiv preprint arXiv:2004.04494_.
  * Fu et al. (2022) Yao Fu, Hao Peng, Ashish Sabharwal, Peter Clark, and Tushar Khot. 2022.  Complexity-based prompting for multi-step reasoning.  _arXiv preprint arXiv:2210.00720_.
  * Gao et al. (2023) Haoyu Gao, Rui Wang, Ting-En Lin, Yuchuan Wu, Min Yang, Fei Huang, and Yongbin Li. 2023.  Unsupervised dialogue topic segmentation with topic-aware contrastive learning.  In _Proceedings of the 46th International ACM SIGIR Conference on Research and Development in Information Retrieval_ , pages 2481–2485.
  * He et al. (2022a) Wanwei He, Yinpei Dai, Binyuan Hui, Min Yang, Zheng Cao, Jianbo Dong, Fei Huang, Luo Si, and Yongbin Li. 2022a.  Space-2: Tree-structured semi-supervised contrastive pre-training for task-oriented dialog understanding.  In _Proceedings of the 29th International Conference on Computational Linguistics_ , pages 553–569.
  * He et al. (2022b) Wanwei He, Yinpei Dai, Min Yang, Jian Sun, Fei Huang, Luo Si, and Yongbin Li. 2022b.  Unified dialog model pre-training for task-oriented dialog understanding and generation.  In _Proceedings of the 45th International ACM SIGIR Conference on Research and Development in Information Retrieval_ , pages 187–200.
  * He et al. (2022c) Wanwei He, Yinpei Dai, Yinhe Zheng, Yuchuan Wu, Zheng Cao, Dermot Liu, Peng Jiang, Min Yang, Fei Huang, Luo Si, and Yongbin Li. 2022c.  Galaxy: A generative pre-trained model for task-oriented dialog with semi-supervised learning and explicit policy injection.  In _Proceedings of the AAAI Conference on Artificial Intelligence_ , pages 10749–10757.
  * Heck et al. (2023) Michael Heck, Nurul Lubis, Benjamin Ruppik, Renato Vukovic, Shutong Feng, Christian Geishauser, Hsien-Chin Lin, Carel van Niekerk, and Milica Gašić. 2023.  Chatgpt for zero-shot dialogue state tracking: A solution or an opportunity?  _arXiv preprint arXiv:2306.01386_.
  * Hu et al. (2022a) Guimin Hu, Ting-En Lin, Yi Zhao, Guangming Lu, Yuchuan Wu, and Yongbin Li. 2022a.  Unimse: Towards unified multimodal sentiment analysis and emotion recognition.  In _Proceedings of the 2022 Conference on Empirical Methods in Natural Language Processing_ , pages 7837–7851.
  * Hu et al. (2022b) Yushi Hu, Chia-Hsuan Lee, Tianbao Xie, Tao Yu, Noah A Smith, and Mari Ostendorf. 2022b.  In-context learning for few-shot dialogue state tracking.  _arXiv preprint arXiv:2203.08568_.
  * Hudeček and Dušek (2023) Vojtěch Hudeček and Ondřej Dušek. 2023.  Are llms all you need for task-oriented dialogue?  _arXiv preprint arXiv:2304.06556_.
  * Kojima et al. (2022) Takeshi Kojima, Shixiang Shane Gu, Machel Reid, Yutaka Matsuo, and Yusuke Iwasawa. 2022.  Large language models are zero-shot reasoners.  _Advances in neural information processing systems_ , 35:22199–22213.
  * Li et al. (2022) Yifei Li, Zeqi Lin, Shizhuo Zhang, Qiang Fu, Bei Chen, Jian-Guang Lou, and Weizhu Chen. 2022.  On the advance of making language models better reasoners.  _arXiv preprint arXiv:2206.02336_.
  * Li et al. (2023) Zaijing Li, Ting-En Lin, Yuchuan Wu, Meng Liu, Fengxiao Tang, Ming Zhao, and Yongbin Li. 2023.  Unisa: Unified generative framework for sentiment analysis.  _arXiv preprint arXiv:2309.01339_.
  * Lin et al. (2022) Ting-En Lin, Yuchuan Wu, Fei Huang, Luo Si, Jian Sun, and Yongbin Li. 2022.  Duplex conversation: Towards human-like interaction in spoken dialogue systems.  In _Proceedings of the 28th ACM SIGKDD Conference on Knowledge Discovery and Data Mining_ , pages 3299–3308.
  * Liu et al. (2021) Jiachang Liu, Dinghan Shen, Yizhe Zhang, Bill Dolan, Lawrence Carin, and Weizhu Chen. 2021.  What makes good in-context examples for gpt-$3$?  _arXiv preprint arXiv:2101.06804_.
  * Lu et al. (2021) Yao Lu, Max Bartolo, Alastair Moore, Sebastian Riedel, and Pontus Stenetorp. 2021\.  Fantastically ordered prompts and where to find them: Overcoming few-shot prompt order sensitivity.  _arXiv preprint arXiv:2104.08786_.
  * Mannekote et al. (2023) Amogh Mannekote, Mehmet Celepkolu, Joseph B Wiggins, and Kristy Elizabeth Boyer. 2023.  Exploring usability issues in instruction-based and schema-based authoring of task-oriented dialogue agents.  In _Proceedings of the 5th International Conference on Conversational User Interfaces_ , pages 1–6.
  * Miao et al. (2021) Shen-Yun Miao, Chao-Chun Liang, and Keh-Yih Su. 2021.  A diverse corpus for evaluating and developing english math word problem solvers.  _arXiv preprint arXiv:2106.15772_.
  * Mosig et al. (2020) Johannes EM Mosig, Shikib Mehri, and Thomas Kober. 2020.  Star: A schema-guided dialog dataset for transfer learning.  _arXiv preprint arXiv:2010.11853_.
  * Poria et al. (2018) Soujanya Poria, Devamanyu Hazarika, Navonil Majumder, Gautam Naik, Erik Cambria, and Rada Mihalcea. 2018.  Meld: A multimodal multi-party dataset for emotion recognition in conversations.  _arXiv preprint arXiv:1810.02508_.
  * Qian et al. (2023) Yushan Qian, Bo Wang, Ting-En Lin, Yinhe Zheng, Ying Zhu, Dongming Zhao, Yuexian Hou, Yuchuan Wu, and Yongbin Li. 2023.  Empathetic response generation via emotion cause transition graph.  _arXiv:2302.11787_.
  * Rastogi et al. (2020) Abhinav Rastogi, Xiaoxue Zang, Srinivas Sunkara, Raghav Gupta, and Pranav Khaitan. 2020.  Towards scalable multi-domain conversational agents: The schema-guided dialogue dataset.  In _Proceedings of the AAAI conference on artificial intelligence_ , volume 34, pages 8689–8696.
  * Rubin et al. (2021) Ohad Rubin, Jonathan Herzig, and Jonathan Berant. 2021.  Learning to retrieve prompts for in-context learning.  _arXiv preprint arXiv:2112.08633_.
  * Si et al. (2023) Shuzheng Si, Wentao Ma, Yuchuan Wu, Yinpei Dai, Haoyu Gao, Ting-En Lin, Hangyu Li, Rui Yan, Fei Huang, and Yongbin Li. 2023.  Spokenwoz: A large-scale speech-text benchmark for spoken task-oriented dialogue in multiple domains.  _arXiv preprint arXiv:2305.13040_.
  * Sorensen et al. (2022) Taylor Sorensen, Joshua Robinson, Christopher Michael Rytting, Alexander Glenn Shaw, Kyle Jeffrey Rogers, Alexia Pauline Delorey, Mahmoud Khalil, Nancy Fulda, and David Wingate. 2022.  An information-theoretic approach to prompt engineering without ground truth labels.  _arXiv preprint arXiv:2203.11364_.
  * Talmor et al. (2018) Alon Talmor, Jonathan Herzig, Nicholas Lourie, and Jonathan Berant. 2018.  Commonsenseqa: A question answering challenge targeting commonsense knowledge.  _arXiv preprint arXiv:1811.00937_.
  * Touvron et al. (2023) Hugo Touvron, Louis Martin, Kevin Stone, Peter Albert, Amjad Almahairi, Yasmine Babaei, Nikolay Bashlykov, Soumya Batra, Prajjwal Bhargava, Shruti Bhosale, et al. 2023.  Llama 2: Open foundation and fine-tuned chat models.  _arXiv preprint arXiv:2307.09288_.
  * Wang et al. (2023) Lei Wang, Wanyu Xu, Yihuai Lan, Zhiqiang Hu, Yunshi Lan, Roy Ka-Wei Lee, and Ee-Peng Lim. 2023.  Plan-and-solve prompting: Improving zero-shot chain-of-thought reasoning by large language models.  _arXiv preprint arXiv:2305.04091_.
  * Wang et al. (2022a) Xuezhi Wang, Jason Wei, Dale Schuurmans, Quoc Le, Ed Chi, Sharan Narang, Aakanksha Chowdhery, and Denny Zhou. 2022a.  Self-consistency improves chain of thought reasoning in language models.  _arXiv preprint arXiv:2203.11171_.
  * Wang et al. (2022b) Xuezhi Wang, Jason Wei, Dale Schuurmans, Quoc Le, Ed Chi, and Denny Zhou. 2022b.  Rationale-augmented ensembles in language models.  _arXiv preprint arXiv:2207.00747_.
  * Wei et al. (2022) Jason Wei, Xuezhi Wang, Dale Schuurmans, Maarten Bosma, Fei Xia, Ed Chi, Quoc V Le, Denny Zhou, et al. 2022.  Chain-of-thought prompting elicits reasoning in large language models.  _Advances in Neural Information Processing Systems_ , 35:24824–24837.
  * Yu et al. (2023) Tianshu Yu, Haoyu Gao, Ting-En Lin, Min Yang, Yuchuan Wu, Wentao Ma, Chao Wang, Fei Huang, and Yongbin Li. 2023.  Speech-text pre-training for spoken dialog understanding with explicit cross-modal alignment.  In _Proceedings of the 61st Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers)_ , pages 7900–7913.
  * Zelikman et al. (2022) Eric Zelikman, Jesse Mu, Noah D Goodman, and Yuhuai Tony Wu. 2022.  Star: Self-taught reasoner bootstrapping reasoning with reasoning.
  * Zhang et al. (2022) Zhuosheng Zhang, Aston Zhang, Mu Li, and Alex Smola. 2022.  Automatic chain of thought prompting in large language models.  _arXiv preprint arXiv:2210.03493_.
  * Zhao et al. (2022) Jeffrey Zhao, Yuan Cao, Raghav Gupta, Harrison Lee, Abhinav Rastogi, Mingqiu Wang, Hagen Soltau, Izhak Shafran, and Yonghui Wu. 2022.  Anytod: A programmable task-oriented dialog system.  _arXiv preprint arXiv:2212.09939_.
  * Zhao et al. (2021) Zihao Zhao, Eric Wallace, Shi Feng, Dan Klein, and Sameer Singh. 2021.  Calibrate before use: Improving few-shot performance of language models.  In _International Conference on Machine Learning_ , pages 12697–12706. PMLR.

lrec-coling2024-natbib languageresource