Venue: NAACL 2022

# Show, Don't Tell: Demonstrations Outperform Descriptions for

Schema-Guided Task-Oriented Dialogue

Raghav Gupta; Harrison Lee1, Jeffrey Zhao, Abhinav Rastogi, Yuan Cao, Yonghui Wu

Google Research

{raghavgupta, harrisonlee}@google.com

Equal contribution

###### Abstract

Building universal dialogue systems that operate across multiple domains/APIs and generalize to new ones with minimal overhead is a critical challenge. Recent works have leveraged natural language descriptions of schema elements to enable such systems; however, descriptions only indirectly convey schema semantics. In this work, we propose _Show, Don't Tell_, which prompts seq2seq models with a labeled example dialogue to _show_ the semantics of schema elements rather than _tell_ the model through descriptions. While requiring similar effort from service developers as generating descriptions, we show that using short examples as schema representations with large language models results in state-of-the-art performance on two popular dialogue state tracking benchmarks designed to measure zero-shot generalization - the Schema-Guided Dialogue dataset and the MultiWOZ leave-one-out benchmark.

## 1 Introduction

Task-oriented dialogue (TOD) systems need to support an ever-increasing variety of services. Since many service developers lack the resources to collect data and train models, zero and few-shot transfer to unseen services is critical to the democratization of dialogue agents.

Recent approaches to generalizable TOD systems primarily rely on combining two techniques: large language models like BERT Devlin et al. (2019) and T5 Raffel et al. (2020), and schematiuded modeling - i.e. using natural language descriptions of schema elements (intents and slots) as model inputs to enable transfer to unseen services Rastogi et al. (2020, 2020). Models combining the two currently hold state-of-the-art (SotA) results on dialogue state tracking (DST) Heck et al. (2020); Lee et al. (2021); Zhao et al. (2022).

However, description-based schema representations have some drawbacks. Writing precise natural language descriptions requires manual effort and can be difficult to write succinctly. Also, descriptions only provide indirect supervision about how to interact with a service compared to an example. Furthermore, Lee et al. (2021) showed that schema-guided DST models are not robust to variations in schema descriptions, causing significant quality drops.

We propose using a single dialogue example with state annotations as an alternative to the description-based schema representation, similar to one-shot priming Brown et al. (2020) - an approach we call _Show, Don't Tell (SDT)_. Through demonstration, we **show** models the schema semantics rather than **tell** them through natural language descriptions, as seen in Figure 1. SDT achieves SotA accuracy and generalization to new APIs across both the Schema-Guided Dataset (SGD) Rastogi et al. (2020) and MultiWOZ Leave-One-Out Budzianowski et al. (2018); Lin et al. (2021) benchmarks, while being more data-efficient and robust to schema variations.

## 2 Show, Don't Tell

Following SoTA models, we pose DST as a seq2seq task Wu et al. (2019); Zhao et al. (2021) and fine-tune T5 on DST datasets. The model input consists of a _prompt_ to convey API semantics and _context_ to represent the current dialogue instance. The _target_ contains ground truth belief states corresponding to the context. We compare against two baselines:

* i.e. values for different slots are independently decoded.


- i.e. the dialogue state is decoded sequentially in a single pass.

We modify the prompt formats above to utilize demonstrations instead of descriptions as described below and illustrated in Figure 1.

* **SDT-ind**: A _prompt_\({}^{\texttt{pind}}_{\texttt{i}}\) comprises a single example utterance and the ground truth slot-value pair formatted as \[\mathtt{P}^{\texttt{ind}}_{\texttt{i}}=[\texttt{ex}];\mathtt{u}^{\texttt{ ind}}_{\texttt{i}};[\texttt{slot}];\texttt{sv}_{\texttt{i}}\] where \(\mathtt{u}^{\texttt{ind}}_{\texttt{i}}\) is a user utterance where slot i is active/not null and sv\({}_{\texttt{i}}\) is the slot-value pair. \([\texttt{ex}],[\texttt{slot}]\) are special delimiter tokens, and ; denotes concatenation.
* **SDT-seq**: A _prompt_ p*eq comprises a single labeled dialogue formatted as: \[\mathtt{p}^{\texttt{seq}}=[\texttt{ex}];\mathtt{u}_{\texttt{i}};...;\mathtt{ u}_{\texttt{n}};[\texttt{slot}];\texttt{sv}_{\texttt{1}};...;\texttt{sv}_{ \texttt{m}}\] where \(\mathtt{uj}_{\texttt{j}}\) is an utterance, and other symbols are explained in the SDT-ind section above. In simple terms, the prompt is constructed by concatenating all utterances in an example dialogue followed by all slot-value pairs in the dialogue state.

In both the T5-* and SDT-* approaches, the context is the serialized dialogue history for the current dialogue instance. The final model input is formed by concatenating the prompt and the context strings, and the target string is the same as T5-*, containing only a single slot value for *-ind models and the entire turn's belief state for *-seq models.

For both T5-* and SDT-*, we enumerate the categorical slot values in multiple-choice format in the prompt and task models with decoding the multiple choice letter corresponding to the correct categorical value.

More details on prompt design and its impact on performance are provided in Appendix A.

**Creating prompt examples:** It is imperative that SDT prompts contain enough information to infer the semantics for all slots in a schema. For SDT-ind, we create individual utterances that showcase a single slot. For SDT-seq, we create example dialogues where all slots in the schema are used.

**Multi-domain examples:** It is not feasible to construct multi-domain demonstrations for every combination of domains. Thus, we stick to single-domain SDT prompts and create separate training instances for each domain present in a multi-domain dialogue turn; for inference, we run inference once for each domain and combine the results.

## 3 Experimental Setup

**Datasets:** We conduct experiments on two DST benchmarks: Schema-guided Dialogue (SGD) Rastogi et al. (2020b) and MultiWOZ 2.1 Budzianowski et al. (2018); Eric et al. (2020). For MultiWOZ, we evaluate on the leave-one-out setup Wu et al. (2019); Lin et al. (2021a), where models are trained on all domains but one and evaluated on the holdout domain. Additionally, we apply the rec

Figure 1: Illustration of all prompt formats for a payment service for both description-based and _Show, Don’t Tell_ models with independent (top) and sequential (bottom) decoding of dialogue state.

 

ommended TRADE pre-processing script1 for fair comparison with other work. For both datasets, we created concise example dialogues modeled after dialogues observed in the datasets.

Footnote 1: [https://github.com/budzianowski/multiwozz@dialog-state-tracking](https://github.com/budzianowski/multiwozz@dialog-state-tracking)

**Implementation:** We train SDT models by fine-tuning pretrained T5 1.1 checkpoints. For SDT-seq, we select one example dialogue for each service to create a prompt and use that prompt across all dialogue instances of that service, across training and evaluation. We do the same for SDT-ind but create one prompt per slot instead of per service. Unless otherwise noted, all T5-based models are based on T5-XXL (11B parameters). Appendices B and C contain more details on training and baselines respectively.

## 4 Results

### SGD Results

Table 1 contains results on the SGD test set. SDT-seq achieves the highest JGA by +1.1%, outperforming the description-based T5-* models, particularly on unseen services. SDT-ind is comparable to its counterpart T5-ind and better than T5-seq.

Since SDT results vary with the choice of example dialogue provided in the prompt, we created 5 different versions of prompts for each service using different examples. We report the average JGA across the 5 versions and the 95% confidence intervals using the Student's-t distribution.

We hypothesize that the main advantage of SDT is that the schema semantics are conveyed via demonstration, which is more similar in form to the end task of state tracking and more informative than descriptions. On the other hand, natural language descriptions can be viewed as an intermediary that models must interpret in order to achieve the end goal of slot value prediction.

We see that SDT-seq outperforms SDT-ind and posit that this is because the full dialogue prompts in SDT-seq demonstrate more complex linguistic patterns (e.g. coreference resolution, long term dependencies) than the single utterance prompts of SDT-ind. On the other hand, we believe T5-seq does not outperform T5-ind because no additional information is conveyed to the model through concatenating independent descriptions. All-else-equal, decoding all slots in one pass is more challenging than decoding each slot independently.

We also experimented with using up to 5 example dialogues in each prompt of SDT-seq, but accuracy did not increase.

### MultiWOZ Results

Table 2 summarizes results for the MultiWOZ 2.1 leave-one-out setup. SDT-seq outperforms T5-seq by +1.5% overall and in 3 of the 5 domains, achieving state-of-the-art performance.

### Impact of Model Size

T5's XXL size (11B parameters) may be unsuitable in resource-constrained settings. To understand how the the impact of model size, we measure SDT's performance on SGD across multiple T5 sizes in Table 3. For base and large sizes, both SDT variations offer higher JGA than their description-based counterparts, possibly due to smaller T5 models being less capable of inferring unseen slots with just a description, whereas SDT models provide more direct supervision in contrast. Additionally, SDT-ind outperforms SDT-seq for both the smaller sizes, potentially due to SDT-seq's prediction task being more complex than that of SDT-ind.

### Data Efficiency

To examine the data efficiency of SDT models, we also experiment with training SDT-seq with 0.16% (10-shot), 1%, and 10% of the SGD training data

\begin{table}
\begin{tabular}{l c c c} \hline \hline
**Model** & All & Seen & Unseen \\ \hline MRC+WD-DST* & 86.5 & 92.4 & 84.6 \\ T5-seq & 86.4 & **95.8** & 83.3 \\ T5-ind & 87.7 & 95.3 & 85.2 \\ \hline SDT-ind & 87.5\(\pm\)0.9 & 95.2\(\pm\)0.7 & 85.0\(\pm\)1.4 \\ SDT-seq & **88.8\(\pm\)0.5** & **95.8\(\pm\)0.2** & **86.4\(\pm\)0.7** \\ \hline \hline \end{tabular}
\end{table}
Table 1: SDT achieves state-of-the-art JGA as evaluated on the SGD test set, performing especially well on unseen services. *Data augmentation/special rules applied.

\begin{table}
\begin{tabular}{l|c c c c|c} \hline \hline
**Model** & Attraction Hotel Restaurant & Taxi Train & Avg \\ \hline TRADE & 20.1 & 14.2 & 12.6 & 59.2 & 22.4 & 25.7 \\ SUMBT & 22.6 & 19.8 & 16.5 & 59.5 & 22.5 & 28.2 \\ TransferQA & 31.3 & 22.7 & 26.3 & 61.9 & 36.7 & 35.8 \\ T5-seq & **76.1** & 28.6 & 69.8 & **87.0** & 60.4 & 64.4 \\ \hline SDT-seq & 74.4 & **33.9** & **72.0** & 86.4 & **62.9** & **65.9** \\ \hline \hline \end{tabular}
\end{table}
Table 2: SDT-seq outperforms T5-seq on the MultiWOZ 2.1 cross-domain (leave-one-out) benchmark. Results for TRADE, SUMBT, and TransferQA from Kumar et al. (2020), Campagna et al. (2020), and Lin et al. (2021), respectively.

 

and evaluating on the entire test set. For 10-shot, we randomly sample 10 training dialogues from every service; for 1% and 10%, we sample uniformly across the entire dataset. SDT-seq demonstrates far higher data efficiency than T5-seq (Table 4), indicating that SDT is more suitable for bootstrapping dialogue systems with a limited budget for collecting training data.

### Robustness

Large LMs are often sensitive to the choice of prompt Zhao et al. (2021); Reynolds and McDonell (2021). To this end, we evaluate SDT-seq on the SGD-X Lee et al. (2021) benchmark, comprising 5 variants with paraphrased slot names and descriptions for every schema (Appendix Figure 4). Note that SDT-seq only makes use of slot names, so variations in description have no effect on it.

Table 5 shows SDT-seq achieves the highest average JGA \((JGA_{v_{1-5}})\) and lowest schema sensitivity (\(SS_{JGA}\), lower value indicates higher robustness), making it the most robust of the compared models. While the JGA decline indicates that SDT-seq is somewhat sensitive to how slot names are written, when compared to a variant of T5-seq Zhao et al. (2022) that only uses slot names, it is still more robust based on the schema sensitivity, and the relative drop in JGA is nearly equal.

## 5 Discussion

### Writing descriptions vs. demonstrations

The information provided to SDT is not identical to what is provided to typical schema-guided models, as SDT exchanges natural language descriptions for a demonstration of identifying slots in a dialogue. However, we argue that from the developer standpoint, creating a single example is similar in effort to writing descriptions, so we consider the methods comparable. Creating the SDT-seq prompts for all 45 services in SGD took an experienced annotator \(\sim\)2 hours, compared to \(\sim\)1.5 hours for generating all slot descriptions. SDT-ind prompts are even simpler to write because they relax the requirement for creating a coherent dialogue involving all slots.

Descriptions can sometimes be easier to generate than a succinct dialogue that covers all slots. However, given the performance gain, examplesed prompts may be a better choice for many settings, especially for smaller model sizes and low resource settings where the gain over description-based prompts is more pronounced.

### Descriptions plus demonstrations

We tried combining both descriptions and a demonstration in a single prompt to try to further improve performance. However, results showed that this did not improve upon using demonstrations alone (see Appendix Table A1 for details).

We hypothesize that demonstrations, along with slot names, already convey slot semantics sufficiently, rendering descriptions extraneous. However, given that using slot names alone underperforms using descriptions Zhao et al. (2022), the improvement SDT exhibits over using descriptions does not result purely from the use of slot names.

### Prompting vs. traditional finetuning

To understand the impact of using a single demonstration as a prompt vs. traditional finetuning, we finetune T5-seq an additional time on the same set of dialogues used in SDT-seq prompts; therefore it has access to both slot descriptions as well as a single demonstration for each service. In this case, T5-seq is provided strictly more information than

\begin{table}
\begin{tabular}{l r r r} \hline
**Model** & 10-shot & 1\% & 10\% \\ \hline T5-seq & 51.0 & 79.4 & 83.0 \\ SDT-seq & **70.7** & **84.5** & **87.4** \\ \hline \end{tabular}
\end{table}
Table 4: Data efficiency experiments on the SGD test set. SDT-seq’s example-based prompt approach is more suited to low resource settings than T5-seq’s description-based prompts.

\begin{table}
\begin{tabular}{l c c c} \hline
**Model** & Base (250M) & Large (800M) & XXL (11B) \\ \hline T5-seq & 72.9 & 80.0 & 86.4 \\ T5-ind & 72.6 & 82.2 & 87.7 \\ \hline SDT-ind & **78.2\(\pm\)0.6** & **83.7\(\pm\)0.8** & 87.5\(\pm\)0.9 \\ SDT-seq & 76.3\(\pm\)1.6 & 83.2\(\pm\)0.6 & **88.8\(\pm\)0.5** \\ \hline \end{tabular}
\end{table}
Table 3: SGD test set JGA across T5’s Base, Large, and XXL sizes. SDT’s advantage is especially prominent on smaller model sizes.

\begin{table}
\begin{tabular}{l c c c c} \hline
**Model** & \(JGA_{Orig}\) & \(JGA_{v_{1-5}}\) & \(Diff_{rel}\) & \(SS_{JGA}\) \\ \hline SGP-DST* & 60.5 & 49.9 & -17.5 & 51.9 \\ T5-ind\({}_{base}\)* & 72.6 & 64.0 & -11.9 & 40.4 \\ T5-seq (name)\(\bigstar\) & 79.7 & 73.0 & **-8.4** & 35.0 \\ T5-seq & 86.4 & 77.8 & -10.0 & 27.0 \\ \hline SDT-seq & **88.8** & **81.2** & -8.6 & **24.1** \\ \hline \end{tabular}
\end{table}
Table 5: Robustness evaluation on the SGD-X test sets. *Results from Lee et al. (2021). \(\bigstar\)Result of using T5-seq with only slot names and no descriptions, from Zhao et al. (2022).

 

SDT-seq. T5-seq with finetuning obtains a JGA of 87.7% on SGD, on par with T5-ind but still lower than SDT-seq, suggesting that, when scarce, dialogue examples are better used as prompts Le Scao and Rush (2021).

Interestingly, finetuning on up to 5 dialogue examples per service did not improve performance after the first example (Appendix Figure 3).

### Error analysis

Figure 2 compares some common error patterns made by T5-seq vs. SDT-seq. The patterns suggest that SDT's demonstrations are helpful when multiple slots in the same domain are similar to each other (#1 in Figure 2) and when slots dissimilar from those seen in training are introduced (#2). However, SDT can sometimes be limited by its prompt. For instance, in #3 it has only seen the "music" value for the _event_type_ slot in the prompt, potentially resulting in under-predicting the categorical values not featured in the example dialogue (e.g. "theater").

## 6 Related Work

Prior approaches focused on framing DST as question answering Ruan et al. (2020); Ma et al. (2019); Zhang et al. (2021). Many MultiWOZ crossdomain models leverage slot names/descriptions Wu et al. (2019); Lee et al. (2019); Lin et al. (2021).

Pretrained generative LLMs Raffel et al. (2020); Brown et al. (2020) have enabled framing NLP tasks as seq2seq problems. Some DST papers Zhao et al. (2021); Feng et al. (2021) look at settings with no train-test discrepancy. Many studies explore the efficacy of task-specific prompts Jiang et al. (2020); Liu et al. (2021). Madotto et al. (2020) and prime LMs with examples for dialogue tasks, but without finetuning. Wei et al. (2021) finetunes language models to teach them to use prompts to generalize across NLP tasks.

## 7 Conclusion

We study the use of demonstrations as LM prompts to convey the semantics of APIs in lieu of natural language descriptions for TOD. While taking similar effort to construct, demonstrations outperform description-based prompts in our experiments across DST datasets (SGD and MultiWOZ), model sizes, and training data sizes, while being more robust to changes in schemata. This work provides developers of TOD systems with more options for API representations to enable transfer to unseen services. In future work, we would like to explore this representation for other TOD tasks (e.g. dialogue management and response generation).

## 8 Ethical Considerations

We proposed a more efficient way of building TOD systems by leveraging demonstrations in place of descriptions, leading to increased accuracy with minimal/no data preparation overhead. We conduct our experiments on publicly-available TOD datasets in English, covering domains which are popular for building conversational agents. We hope our work leads to building more accurate TOD systems with similar or less overhead and encourages further research in the area.

## References

* Brown et al. (2021) Tom Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared D Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry,

Figure 2: Comparing common error patterns made by T5-seq vs. SDT-seq. Correct and incorrect predictions colored in red and blue, respectively.

 

Amanda Askell, Sandhini Agarwal, Ariel Herbert-Voss, Gretchen Krueger, Tom Henighan, Rewon Child, Aditya Ramesh, Daniel Ziegler, Jeffrey Wu, Clemens Winter, Chris Hesse, Mark Chen, Eric Sigler, Mateusz Litwin, Scott Gray, Benjamin Chess, Jack Clark, Christopher Berner, Sam McCandlish, Alec Radford, Ilya Sutskever, and Dario Amodei. 2020. Language models are few-shot learners. In _Advances in Neural Information Processing Systems_, volume 33, pages 1877-1901. Curran Associates, Inc.
* a large-scale multi-domain Wizard-of-OZ dataset for task-oriented dialogue modelling. In _Proceedings of the 2018 Conference on Empirical Methods in Natural Language Processing_, pages 5016-5026, Brussels, Belgium. Association for Computational Linguistics.
* Campagna et al. (2020) Giovanni Campagna, Agata Forcyciarz, Mehrad Moradshahi, and Monica Lam. 2020. Zero-shot transfer learning with synthesized data for multi-domain dialogue state tracking. In _Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics_, pages 122-132, Online. Association for Computational Linguistics.
* Devlin et al. (2019) Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. 2019. BERT: Pre-training of deep bidirectional transformers for language understanding. In _Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long and Short Papers)_, pages 4171-4186, Minneapolis, Minnesota. Association for Computational Linguistics.
* Eric et al. (2020) Mihail Eric, Rahul Goel, Shachi Paul, Abhishek Sethi, Sanchit Agarwal, Shuyang Gao, Adarsh Kumar, Anuj Goyal, Peter Ku, and Dilek Hakkani-Tur. 2020. MultiWOZ 2.1: A consolidated multi-domain dialogue dataset with state corrections and state tracking baselines. In _Proceedings of the 12th Language Resources and Evaluation Conference_, pages 422-428, Marseille, France. European Language Resources Association.
* Feng et al. (2021) Yue Feng, Yang Wang, and Hang Li. 2021. A sequence-to-sequence approach to dialogue state tracking. In _Proceedings of the 59th Annual Meeting of the Association for Computational Linguistics and the 11th International Joint Conference on Natural Language Processing (Volume 1: Long Papers)_, pages 1714-1725, Online. Association for Computational Linguistics.
* Heck et al. (2020) Michael Heck, Carel van Niekerk, Nurul Lubis, Christian Geishauser, Hsien-Chin Lin, Marco Moresi, and Milica Gasic. 2020. TripPy: A triple copy strategy for value independent neural dialog state tracking. In _Proceedings of the 21th Annual Meeting of the Special Interest Group on Discourse and Dialogue_, pages 35-44, 1st virtual meeting. Association for Computational Linguistics.
* Jiang et al. (2020) Zhengbao Jiang, Frank F. Xu, Jun Araki, and Graham Neubig. 2020. How can we know what language models know?
* Jouppi et al. (2017) Norman P. Jouppi, Cliff Young, Nishant Patil, David Patterson, Gaurav Agrawal, Raminder Bajwa, Sarah Bates, Suresh Bhatia, Nan Boden, Al Borchers, Rick Boyle, and Pierre-luc et al. Cantin. 2017. Indatacenter performance analysis of a tensor processing unit. _SIGARCH Comput. Archit. News_, 45(2):1-12.
* Kumar et al. (2020)Adarsh Kumar, Peter Ku, Anuj Goyal, Angeliki Metallinou, and Dike Hakkani-Tur. 2020. Ma-dst: Multi-attention-based scalable dialog state tracking. _Proceedings of the AAAI Conference on Artificial Intelligence_, 34(05):8107-8114.
* Le Scao and Rush (2021) Teven Le Scao and Alexander Rush. 2021. How many data points is a prompt worth? In _Proceedings of the 2021 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies_, pages 2627-2636, Online. Association for Computational Linguistics.
* Lee et al. (2021a) Chia-Hsuan Lee, Hao Cheng, and Mari Ostendorf. 2021a. Dialogue state tracking with a language model using schema-driven prompting. In _Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing_, pages 4937-4949, Online and Punta Cana, Dominican Republic. Association for Computational Linguistics.
* Lee et al. (2021b) Harrison Lee, Raghu Gupta, Abhinav Rastogi, Yuan Cao, Bin Zhang, and Yonghui Wu. 2021b. Sgd-x: A benchmark for robust generalization in schema-guided dialogue systems.
* Lee et al. (2019)Hwaran Lee, Jinsik Lee, and Tae-Yoon Kim. 2019. SUMBT: Slot-utterance matching for universal and scalable belief tracking. In _Proceedings of the 57th Annual Meeting of the Association for Computational Linguistics_, pages 5478-5483, Florence, Italy. Association for Computational Linguistics.
* Lin et al. (2021a) Zhaojiang Lin, Bing Liu, Andrea Madotto, Seungwhan Moon, Paul Crook, Zhenpeng Zhou, Zhiguang Wang, Zhou Yu, Emjoon Cho, Rajen Subba, and Pascale Fung. 2021a. Zero-shot dialogue state tracking via cross-task transfer.
* Lin et al. (2021b) Zhaojiang Lin, Bing Liu, Seungwhan Moon, Paul Crook, Zhenpeng Zhou, Zhiguang Wang, Zhou Yu, Andrea Madotto, EnuJoon Cho, and Rajen Subba. 2021b. Leveraging slot descriptions for zero-shot cross-domain dialogue State Tracking. In _Proceedings of the 2021 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies_, pages 5640-5648, Online. Association for Computational Linguistics 

Xiao Liu, Yanan Zheng, Zhengxiao Du, Ming Ding, Yujie Qian, Zhilin Yang, and Jie Tang. 2021. Gpt understands, too.
* Ma et al. (2019) Yue Ma, Zengfeng Zeng, Dawei Zhu, Xuan Li, Yiying Yang, Xiaoyuan Yao, Kaijie Zhou, and Jianping Shen. 2019. An end-to-end dialogue state tracking system with machine reading comprehension and wide & deep classification.
* Madotto et al. (2020) Andrea Madotto, Zihan Liu, Zhaojiang Lin, and Pascale Fung. 2020. Language models as few-shot learner for task-oriented dialogue systems. _CoRR_, abs/2008.06239.
* Raffel et al. (2020) Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li, and Peter J. Liu. 2020. Exploring the limits of transfer learning with a unified text-to-text transformer.
* Ratogi et al. (2020a) Abhinav Rastogi, Xiaoxue Zang, Srinivas Sunkara, Raghav Gupta, and Pranav Khaitan. 2020a. Schema-guided dialogue state tracking task at dstc8.
* Rastogi et al. (2020b) Abhinav Rastogi, Xiaoxue Zang, Srinivas Sunkara, Raghav Gupta, and Pranav Khaitan. 2020b. Towards scalable multi-domain conversational agents: The schema-guided dialogue dataset. _Proceedings of the AAAI Conference on Artificial Intelligence_, 34(05):8689-8696.
* Reynolds and McDonell (2021) Laria Reynolds and Kyle McDonell. 2021. Prompt programming for large language models: Beyond the few-shot paradigm.
* Ruan et al. (2020) Yu-Ping Ruan, Zhen-Hua Ling, Jia-Chen Gu, and Quan Liu. 2020. Fine-tuning bert for schema-guided zero-shot dialogue state tracking.
* Wei et al. (2021) Jason Wei, Maarten Bosma, Vincent Y. Zhao, Kelvin Guu, Adams Wei Yu, Brian Lester, Nan Du, Andrew M. Dai, and Quoc V. Le. 2021. Finetuned language models are zero-shot learners.
* Wu et al. (2019) Chien-Sheng Wu, Andrea Madotto, Ehsan Hosseini-Asl, Caiming Xiong, Richard Socher, and Pascale Fung. 2019. Transferable multi-domain state generator for task-oriented dialogue systems.
* Zhang et al. (2021) Yang Zhang, Vahid Noroozi, Evelina Bakhturina, and Boris Ginsburg. 2021. Sgd-qa: Fast schema-guided dialogue state tracking for unseen services.
* Zhao et al. (2022) Jeffrey Zhao, Raghav Gupta, Yuan Cao, Dian Yu, Mingqiu Wang, Harrison Lee, Abhinav Rastogi, Izhak Shafran, and Yonghui Wu. 2022. Description-driven task-oriented dialog modeling.
* Zhao et al. (2021a) Jeffrey Zhao, Mahdis Mahdieh, Ye Zhang, Yuan Cao, and Yonghui Wu. 2021a. Effective sequence-to-sequence dialogue state tracking. In _Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing_, pages 7486-7493, Online and Punta Cana, Dominican Republic. Association for Computational Linguistics.
* Zhao et al. (2021b) Tony Z. Zhao, Eric Wallace, Shi Feng, Dan Klein, and Sameer Singh. 2021b. Calibrate before use: Improving few-shot performance of language models.

## Appendix A Prompt Design

We experimented with various formats for the SDT prompt before arriving at the final format. Below, we list alternative designs that we tried and their impact on JGA, as evaluated on the SGD test set.

### Categorical value strings vs. multiple choice answers

We found that JGA dropped -2% when we tasked the model with decoding categorical values instead of multiple choice answers - e.g. payment_method=debit card instead of payment_method=b (where b is linked to the value debit card in the prompt as described in Section 2). When taking the model to decode categorical values, it would often decode related yet invalid values, which we counted as false in our evaluation. For example, instead of debit card, the model might decode bank balance.

### Slot IDs vs. slot names

When we delexicalized slot names with slot IDs, JGA dropped -5%. One downside of this approach is that the model lost access to valuable semantic information conveyed by the slot name. Another downside is that the model could not distinguish two slots that had the same value in the prompt. For example, if the prompt was "I would like a petfriendly hotel room with wifi" and the corresponding slots were l=True (has_wifi) and 2=True (pets_allowed), it is ambiguous which ID refers to which slot.

The potential upside of using slot IDs was to remove dependence on the choice of slot name, but this did not succeed for the reasons above.

### Decoding active slots vs. all slots

We experimented with training the model to only decode active slots rather than all slots with none values when they were inactive. JGA dropped -0.4%, which we hypothesized might be a result of greater dissimilarity between the slot-value string in the prompt (which contained all slots by construction) and the target, which only contained a subset of slots 



### In-line annotations vs. dialogue+slots concatenated

We hypothesized that bringing the slot annotation in the prompt closer to where it was mentioned in the dialogue might help the model better understand the slot's semantic meaning. We changed the format as follows:

* Original: [ex] [user] I would like a pet-friendly hotel room with wifi [system] If found ... **[slot] has_wifi=True**
* In-line: [ex] [user] I would like a pet-friendly hotelroom with wifi **[has_wifi=True]** [system] I found ... However, this decreased JGA by more than -20%. We hypothesized that this was likely due to a mismatch between the prompt's annotations and the target string format, which we did not change.

## Appendix B SDT Model Details

We used the publicly available T5 checkpoints2. For all experiments, we used a sequence length of 2048, 10% dropout and a batch size of 16. We used a constant learning rate of \(1e-3\) or \(1e-4\). All models were trained for 50k steps or until convergence, and each experiment was conducted on either 64 or 128 TPU v3 chips Jouppi et al. (2017).

Footnote 2: [https://github.com/google-research/text-to-text-transfer-transformer/blob/main/released_checkpoints.md](https://github.com/google-research/text-to-text-transfer-transformer/blob/main/released_checkpoints.md)

## Appendix C Baseline Models

For SGD, we compare against SGP-DST Ruan et al. (2020), MRC+WD-DST Ma et al. (2019), T5-seq Zhao et al. (2022) and T5-ind Lee et al. (2021a).

For MultiWOZ, we compare against TRADE Wu et al. (2019), SUMBT Lee et al. (2019), TransferQA Lin et al. (2021a), and T5-seq. Transfer QA is based on T5-large.



* [14] M. C. Bader, A. D. Krizhevsky, and R. G. Hinton. Learning to predict the presence of a large number of samples. In _Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR)_, pages 235-238, 2016.
* [15] J. L. Friedman, S. W. Teh, and I. Goodfellow. Imagenet classification with deep neural networks. In _Advances in Neural Information Processing Systems (NIPS'97)_, pages 1397-1398, 2007.
* [16] P. F. Donahue, Y. Bengio, and V. Vanhoucke. Generative adversarial nets for image recognition. In _International conference on machine learning systems_, volume 1, pages 103-113, 2016.
* [17] T. Darrell, N. Ramanan, and E. Rabinovich. Deep residual learning for image recognition. In _IEEE International Conference on Acoustics and Speech (ICASSP)_, pages 139-140, 2016.
* [18] H. Chen, X. Li, and Z. Zhang. Deep residual learning for image recognition. In _ECCV_, pages 139-140, 2016.

[MISSING_PAGE_POST]

un. Deep residual learning for image recognition