Diversity of Demonstrations: Another important factor in the success of few-shot learning isthe diversity of the demonstrations. Naik et al. (2023) propose DiversePrompting where for thequestion of a demonstration, an LLM is used to generate different ways of solving the problem,and then those solutions are used in the prompt. Zhang et al. (2022b) propose to select a diverseset of questions as few-shot examples. Ma et al. (2023) propose a fairness metric for selectingdemonstrations which encourages selecting diverse few-shot demonstrations that produce a nearuniform predictive distribution for a semantic-free input

Order of Demonstrations: The order of demonstrations has been shown to substantially affect themodel performance. For example, Lu et al. (2022b) show that on some tasks, the model performancecan range from near-random to state-of-the-art depending on the order of the prompts, and Zhao et al.(2021) show that answers appearing toward the end of the prompt are more likely to be predicted bythe model

umber of Demonstrations: LLMs generally benefit from more demonstrations, but as the numberof demonstrations increases the rate of improvement typically decreases (Brown et al., 2020; Ye et al.,2023b; Min et al., 2022b). Generation tasks have been shown to benefit from an increased number ofdemonstrations more than classification tasks (Li et al., 2023b). Toward increasing the number ofdemonstrations, one barrier is the maximum context size of the LLM. While the size of the contexthas been increasing over time with newer LLMs, it may still be problematic for datasets with longinput texts or classification datasets with many classes

Several works try to provide theoretical justifications and insights into how LLMs learn from a fewin-context demonstrations (Xie et al., 2021; Garg et al., 2022; Von Oswald et al., 2023). However,the exact reasons behind this capability are still largely unclear making it difficult to select optimalfew-shot demonstrations

This not only improves the efficiency and scalability of the learningprocess but also has been shown to reduce biases inherent in manual exampleselection. I

However, the model’sability to perform ICL is sensitive to the choice of the few-shot demonstrations.Instead of using a fixed set of demonstrations, one recent development is to retrievedemonstrations tailored to each input query

1) The biggest challenges of multi-intent detec-tion (MID) in the deployment is the heavy coderefactoring on a running dialogue system whichalready does a good job in single-intent detection.It motivates us to design DialogUSR, which servesas a plug-in module and eases the difficulties ofincremental development.2) Prior work on MID has higher cost of dataannotation and struggles in the open-domain or do-main transfer scenarios. Only NLU experts canadequately annotate the intent/slot info for a MIDuser query, and the outputs of MID NLU modelsare naturally limited by the pre-defined intent/slotontology. In contrast, DialogUSR datasets can be1Code and data are provided in https://github.com/MrZhengXin/multi_intent_2022.!"#=>ChechowH#I:;Chec[SP]thereOPI9:TranRST12DEChec[SP]speedRV$H%PChec=>TH%P:;Chec[SP]fromH%P:;Z[Chec[SP]there^"_abSabSStep1. Initial Query Collection+,-./012345678Check the high-speed train from Xiamen toNanjing on Friday afternoonTask-orientedQuery Datasetsfghi:+,A/j12klh-./0345678Hi, I wanna check the high-speed train thatdeparts from Xiamen and arrives in Nanjing onFriday afternoonSamplingSentenceSimplificationStep2. Follow-up Query Creation'(* +,-./012345678Check the high-speed train from Xiamen to Nanjing on Friday afternoon'K* 9:;<=>How long does it take'Q* +A/BC6DEFGCheck out the special cuisine thereStep3. Query Aggregation'(* +,-./012345678Check the high-speed train from Xiamen to Nanjing on Friday afternoon'K* 9:;<=>How long does it take'Q* +A/BC6DEFGCheck out the special cuisine theremccnPcV%JS"* +,-./0123456789:;<=>?@+A/BC6DEFGCheck the high-speed train from Xiamen to Nanjing on Friday afternoon,how long does the journey take, then check out the special food there.'K* 9:;<=>How long does it take'Q* +A/BC6DEFGCheck out the specialcuisine there'KonPb* 123456789:;<=>How long does it take to travel fromXiamen to Nanjing in high-speed train'QonPb* +A/456DEFGCheck out the special cuisine in NanjingStep4. Query CompletionFigure 2: The overview for the data collection proce-dure of DialogUSR. Firstly we sample initial queriesfrom task-oriented NLU datasets (Sec. 2.1), then wehire crowdsource workers to write follow-up queries(Sec. 2.2). To aggregate the annotated queries, we pro-pose text filler templates (marked in red, Sec. 2.3) andpost-processing procedure. Finally we ask annotatorsto recover the missing information in the incompleteutterances (marked in blue, Sec. 2.4).easily annotated by non-experts, and the derivedmodels are domain-agnostic in the sense that thelearned query splitting, coreference/omission re-covery skills are generic for distinct domains3) Presumably MID is more difficult than sin-gle intent detection (SID) given the same inten-t/slot ontology. From the perspective of task(re)formulation, DialogUSR is the first to converta MID task to multiple SID tasks (the philosophyof ’divide and conquer’) with a relatively low er-ror propagation rate, providing an alternative andeffective way to handle the MID task.

he anno-tators are instructed to write up to 3 subsequentqueries on what they need or what they would liketo know about according to the designated initialquery

we ask human an-notators to put themselves in the same position ofa real end user and imagine they are eliciting mul-tiple intents in a single complex user query whileinteracting with conversational agents

sample an initial query from twoChinese user query understanding datasets fortask-oriented conversational agents, namely SMP-ECDT2(Zhang et al., 2017) and RiSAWOZ3 (Quanet al., 2020). Then we ask human annotators to sim-plify the initial queries that have excessive length(longer than 15 characters), or are too verbose orrepetitive in terms of semantics

we propose com-plex dialogue utterance splitting and reformulation(DialogUSR) task with corresponding benchmarkdataset that firstly splits the multi-intent query intoseveral single-intent sub-queries and then recoverthe coreferred and omitted information in the sub-queries,

Tointegrate the multi-intent detection model into aproduct dialogue system, the developers wouldmake extra efforts in continuous deployment, i.e.technical support for both single-intent and multi-intent detection models, and system modifications,i.e. changes in the APIs and implementations ofNLU and other related modules

o handle multi-intent user queries, a straight-forward solution is to train a dedicated natural lan-guage understanding (NLU) system for multi-intentdetection

n the context of the TOD system, two crucialcomponents for measuring the success of a dia-logue are belief state and system response

he main contributions of our work can be sum-marized as follows:1. We design a prompt construction methodbased on domain and slot information.2. We proposed an adaptive prompt generationframework for the comprehensive black-box LLM-based TOD system.3. Experimental results demonstrate the effec-tiveness of our approach in enhancing the capabili-ties of LLMs.

e de facto way of utilizing black-box largelanguage models (LLMs) to perform variousdownstream tasks is prompting. However,obtaining suitable prompts for specific tasksis still a challenging problem. While exist-ing LLM-based methods demonstrate promis-ing performance in the task-oriented dialogue(TOD) task, they often require manual adjust-ment in prompt selection or focus solely on dia-logue understanding or generation. To addressthese issues, we propose an adaptive promptgeneration framework to fully unleash the po-tential of LLMs for the comprehensive TODsystem. Firstly, we design a trainable slot gen-erator (TSG) that can generate domain and slotinformation in the belief state, which serves asprior knowledge for subsequent prompt genera-tion. Next, we propose an adaptive prompt gen-erator (APG) that utilizes the prior knowledgeto generate prompts for the LLM, deriving thebelief state and system response of the dialoguefor evaluation. Finally, we evaluate our frame-work on the MultiWOZ 2.0 dataset. Extensiveexperiments demonstrate th

With the Meta NLG tasks defined above, we formulate themeta-learning objective of Meta-NLG as below:θM eta = M etaLearn(T1, ..., TK )= arg maxθ EiEDTi ,D′TiLD′Ti(fθ′i) (4)θ′i = Adapt(DTi , θ) = θ − α∇θ LDTi (fθ ) (5)

Low-resource Adaptation. To simulate the process ofadapting to a low-resource NLG task, the sizes of both sub-sets DTi and D′Ti , especially DTi , are set small. Therefore,when the model is updated on DTi as a part of the later meta-learning steps, it only sees a small amount of samples in thattask. This setup embeds the goal of low-resource adaptation.

Task Generalization. To generalize to new NLG tasks,Meta NLG tasks follow the same modality as the target task.For example, if our target task is to adapt to DA-utterancepairs in a new domain, then DA-utterance pairs in each Tiare sampled from the same source domain. We also consideradapting to new DA types in later experiments. In this case,DA-utterance pairs in each Ti have the same DA type. Thissetting merges the goal of task generalization.

Therefore, the first step is to construct a set of auxiliaryMeta NLG tasks (T1, ..., TK ) to simulate the low-resourcefine-tuning process. We construct a Meta NLG task Ti by:Ti = (DTi , D′Ti ) (3)DTi and D′Ti of each Ti are two independent subsets of DA-utterance pairs from high-resource source data Ds. DTi andD′Ti correspond to meta-train (support) and meta-test (query)sets of a typical meta-learning or few-shot learning setup, andTi is often referred to as a training episode. This meta setupwith both DTi and D′Ti in one Meta NLG task allows ourMeta-NLG algorithm to directly learn from different MetaNLG tasks. The usage of them will be elaborated later. MetaNLG tasks are constructed with two additional principles:

the idea of our Meta-NLG algorithm isto repeatedly simulate auxiliary Meta NLG tasks from Ds tomimic the fine-tuning process in Eq.(2).

uppose fθ is the base NLG model parameterized by θ, andwe have an initial θs pre-trained with DA-utterance pairsDs = {(dj , Yj )}j∈s from a set s of high-resource sourcetasks. When we adapt fθ to some low-resource task t withDA-utterance pairs Dt = (dt, Yt), the fine-tuning processon Dt can be formulated as follows:θ∗ = Adapt(Dt, θ = θs) = arg maxθ LDt (fθ )= arg maxθ∑(dt ,Yt )∈DtlogP (Yt|dt; θ) (2)The parameter θs will be used for initialization, and themodel is further updated by new observations Dt. The sizeof Dt in low-resource NLG tasks is very small due to thehigh annotation cost, therefore, a good initialization parame-ter θs learned from high-resource source tasks is crucial forthe adaptation performance on new low-resource NLG tasks.Proceedings of the Twenty-Eighth International Joint Conference on Artificial Intelligence (IJCAI-19)3152

hieved state-of-the-art perfor-mance by directly optimizing the gradient towards a goodparameter initialization for easy fine-tuning on low-resourcescenarios. It introduces no additional architectures nor pa-rameters.

The optimization algorithm itself canbe designed in a way that favors fast adaption

The idea is to use an additional meta-learnerto learn to update the original learner with a few trainingexamples. [Andrychowicz et al., 2016] developed a meta-learner based on LSTMs. Hypernetwork [Ha et al., 2016],MetaNet [Munkhdalai and Yu, 2017], and TCML [Mishraet al., 2017] also learn a separate set of representations forfast model adaptation. [Ravi and Larochelle, 2017] proposedan LSTM-based meta-learner to learn the optimization algo-rithm (gradients) used to train the original network

The idea is to learn a metric space and thenuse it to compare low-resource testing samples to rich train-ing samples

A fundamental problem is “fastadaptation to new and limited observation data”

We formulate the problem froma meta-learning perspective, and propose a gen-eralized optimization-based approach (Meta-NLG)based on the well-recognized model-agnostic meta-learning (MAML) algorithm.

Inthis paper, we study NLG in a low-resource settingto generate sentences in new scenarios with handfultraining examples

As Meta-NLG is model-agnostic as long asthe model can be optimized by gradient descent, we could ap-ply it to any existing NLG models to optimize them in a waythat adapt better and faster to new low-resource tasks

Then, we proposed a generalizedNLG algorithm called Meta-NLG based on MAML by view-ing languages in different domains or dialog act types as sep-arate Meta NLG tasks.

nstead of casting the problem as model-based approaches, we propose a generalized optimization-based meta-learning approach to directly enhance the opti-mization procedure for the low-resource NLG task

Although promis-ing results were reported, we found that datasets used bythese methods are simple which tend to enumerate many slotsand values in an utterance without much linguistic variations.

Meta-NLG defines aset of meta tasks, and directly incorporates the ob-jective of adapting to new low-resource NLG tasksinto the meta-learning optimization process.

De-spite the recent success of neural approaches forNLG, they are typically developed for particulardomains with rich annotated training examples

Git - Học nghiêm túc một lần

fine-tune SC-GPT on limited amounts of domain-specific labels for adaptation

Finally, thesequentialized dialog act A′ is concatenated withits augmented response x′, and then fed into GPT-2.

We firstly pre-process dialog act A into a se-quence of control codes using the following format:A′ = [ I ( s1 = v1 , · · · sP = vP ) ] (4)Meanwhile, the output sequence x′ is pre-processed via appending x with a special start to-ken [BOS] and an end token [EOS].

To enablethe guidance of dialog act in response generation,we propose to continuously pre-train the GPT-2model on large amounts of annotated (dialog act,response) pairs. The pre-training dataset3 includesannotated training pairs from Schema-Guided Dia-log corpus, MultiWOZ corpus, Frame corpus, andFacebook Multilingual Dialog Corpus. The totalsize of the pre-training corpus is around 400k ex-amples

Existing methods for NLG can be broadly sum-marized into two major categories. (i) Template-1Semantically-Conditioned Generative Pre-Trainingbased methods require domain experts to handcrafttemplates for each domain, and the system fills inslot-values afterward (Cheyer and Guzzoni, 2014;Langkilde and Knight, 1998). Thus, the producedresponses are often adequate to contain the requiredsemantic information, but not always fluent and na-ture, hurting users’ experiences. (ii) Statistical lan-guage models such as neural networks (Gao et al.,2019) learn to generate fluent responses via train-ing from labelled corpus. One canonical model issemantically conditioned LSTM (SC-LSTM) (Wenet al., 2015b), which encodes dialog acts with one-hot representations and uses it as an extra feature toinform the sentence generation process.

ayer Transformer neural language model, trainedin three steps: (i) Pre-trained on plain text, similarto GPT-2 (Radford et al.); (ii) Continuously pre-trained on large amounts of dialog-act labeled utter-ances corpora to acquire the ability of controllablegeneration; (iii) Fine-tuned for a target domain us-ing very limited amounts of domain labels.

o simulatesuch a few-shot learning setting, we have devel-oped a new benchmark dataset, called FEWSHOT-WOZ, based on the MultiWOZ (Budzianowskiet al., 2018) and Cambridge NLG datasets (Wenet al., 2016a). F

In a typical task-oriented dialogsystem, the Natural Language Generation (NLG)module plays a crucial role: it converts a systemaction (e.g., often specified in a semantic form se-lected by a dialog policy) into a final response innatural language. Hence, the response should beadequate to represent semantic dialog actions, andfluent to engage users’ attention

Regression Objective Function. The cosine-similarity between the two sentence embeddingsu and v is computed (Figure 2). We use mean-squared-error loss as the objective function

Classification Objective Function. We con-catenate the sentence embeddings u and v withthe element-wise difference |u − v| and multiply itwith the trainable weight Wt ∈ R3n×k:o = softmax(Wt(u, v, |u − v|))where n is the dimension of the sentence em-beddings and k the number of labels. We optimizecross-entropy loss.

SBERT adds a pooling operation to the outputof BERT / RoBERTa to derive a fixed sized sen-tence embedding. We experiment with three pool-ing strategies: Using the output of the CLS-token,computing the mean of all output vectors (MEAN-strategy), and computing a max-over-time of theoutput vectors (MAX-strategy). The default config-uration is MEAN.

The field of text generation systems shifted from traditional approaches to statistical approacheswhere the focus was on exploiting patterns in text data and building models to make a predictionbased on the text it has see

Notably, we iden-tify three important areas of further research towards building more effective dialogue systems:1) incorporating larger context, including conversation context and world knowledge; 2) addingpersonae or personality in the NLG system; and 3) overcoming dull and generic responses thataffect the quality of system-produced responses. We provide pointers on how to tackle these openproblems through the use of cognitive architectures that mimic human language understanding andgeneration capabilities

Some of the early success in the field of language generation was building systems like Eliza(Weizenbaum, 1966) and PARRY

Featurization Firstly, the policy featurizes theuser input, system actions and slots.

Similar to the REDP, we do not use aclassifier to select a system action. Instead, we jointlytrain embeddings for the dialogue state and each of thesystem actions by maximizing a similarity function be-tween them

Vlasov etal. [2] introduced the Recurrent Embedding Dialogue Pol-icy (REDP) architecture. The ablation study in this workhighlighted that the improved performance of REDP isdue to an attention mechanism over the dialogue historyand a copy mechanism to recover from unexpected userinput. This modification to the standard RNN structureenables the dialogue policy to ‘skip’ specific turns in thedialogue history and produce an encoder state which isidentical before and after the unexpected input.

Topic disentanglement in task-oriented dialogueRecent work has attempted to produce neural architec-tures for dialogue policies which can handle interleaveddiscourse segments in a single conversation

n the example above, theuser might follow up with a further question like so thatused up my credit, right?. If the topic of refund creditshas been popped from the stack, this can no longer helpclarify what the user wants to know

The authors of RavenClaw argue forexplicitly tracking topics to enable the contextual inter-pretation of the user intents

While a stack naturally allows for sub-dialogues to behandled and concluded, the strict structure of a stackis also limiting

The assistant’s question Shall Iplace the order? prompts the return to the task at hand:completing a purchase. One model is to think of thesesub-dialogues as existing on a stack, where new topicsare pushed on to the stack when they are introduced andpopped off the stack once concluded

discourse segments, where a discourse seg-ment (or topic) is a set of utterances that directly re-spond to each other.

The proposed TED architecture should bethought of as a candidate building block for use in de-veloping state-of-the-art architectures in various dialoguetasks.

Interpretingsimple instructions like please turn on the lights is rela-tively straightforward, but to handle more complex tasks,these systems must be able to engage in multi-turn con-versations.

ith higherrequirements on product experience, actual di-alog scenarios become more complex, and DMneeds to be further improved. Traditional DMis usually built in a clear dialog script sys-tem (searching for matching answers, query-ing the user intent, and then ending the dia-log) with pre-defined system action space, userintent space, and dialog body. However, dueto unpredictable user behaviors, traditional di-alog systems are less responsive and have agreater difficulty dealing with undefined sit-uations. In addition, many actual scenariosrequire cold start without sufficient tagged di-alog data, resulting in high data cleansing andtagging costs. DM based on deep reinforce-ment learning requires a large amount of datafor model training. According to the experi-ments in many academic papers, hundreds ofcomplete sessions are required to train a dialogmodel, which hinders the rapid developmentand iteration of dialog systems.To solve the limitations of traditional DM,researchers in academic and industry circleshave begun to focus on how to strengthen theusability of DM. Specifically, they are workingto address the following shortcomings in DM:• Poor scalability• Insufficient tagged data• Low training efficiency

sign and removing the isolation between mod-ules. However, the end-to-end model placeshigh requirements on the quantity and qualityof data and does not provide clear modelingfor processes such as slot filling and API call-ing. This model is still being explored and is asyet rarely applied in the industry.

This modular system structure is highly in-terpretable, easy to implement, and applied inmost practical task-oriented dialog systems inthe industry. However, this structure is notflexible enough. The modules are independentof each other and difficult to optimize together.This makes it difficult to adapt to changing ap-plication scenarios. Additionally, due to theaccumulation of errors between modules, theupgrade of a single module may require theadjustment of the whole system

ask-oriented dialog systems are divided byarchitecture into two categories. One type isa pipeline system that has a modular struc-ture(Wen et al., 2016), as shown in Figure 1.It consists of four key modules:

Common dialog systems are divided into thefollowing three types: chatting systems, task-oriented dialog systems, and QA systems. In achatting systems, the system generates inter-esting and informative natural responses to al-low human-machine dialog to proceed(Serbanet al., 2017)

The di-alog state is obtained by directly calculat-ing the maximum conditional probability in-stead of the Bayesian a posteriori probabil-ity.

n recent years, with breakthroughs in deeplearning in the image, voice, and text fields,third-generation dialog systems built arounddeep learning have emerged.

The first-generation dialog systems weremainly rule-based. For example, the ELIZAsystem(Weizenbaum, 1966) developed by MITin 1966 was a psychological medical chatbotthat matched methods using templates.

At that time, re-inforcement learning was widely studied andapplied in dialog systems. A representative ex-ample is the statistical dialog system based onthe Partially Observable Markov Decision Pro-cess (POMDP) proposed by Professor SteveYoung of Cambridge University in 2005(Younget al., 2013)

Turing test. Topass this test, the machine had to commu-nicate with a real person so that this per-son believed they were talking to another per-son

Inthis paper, we survey recent advances andchallenges within three critical topics forDM: (1) improving model scalability to fa-cilitate dialog system modeling in new sce-narios, (2) dealing with the data scarcityproblem for dialog policy learning, and (3)enhancing the training efficiency to achievebetter task-completion performance

Given the dialog history, DM pre-dicts the dialog state and decides thenext action that the dialog agent shouldtake.

n most cases, there are two kinds of errors in the Vietnamese language:mistyped errors and misspelled errors [11]. Mistyped errors are errors that occurduring the typing process. The majority of these mistakes are caused by the