Learning to Clarify: Multi-turn Conversations with Action-Based Contrastive Self-Training

## Abstract

Abstract Large language models (LLMs) aligned through reinforcement learning from human feedback (RLHF) have quickly become one of the dominant paradigms for building intelligent conversational assistant agents. However, despite their strong performance across many benchmarks, LLM-based agents still lack conversational skills such as disambiguation: when generalized assistants are faced with ambiguity, they often overhedge or implicitly guess users’ ground-truth intents rather than asking clarification questions, and under task-specific settings, high-quality conversation samples are often limited, affecting models’ ability to learn optimal dialogue action policies. We propose Action-Based Contrastive Self-Training (henceforth ACT ), a quasi-online preference optimization algorithm based on Direct Preference Optimization (DPO) which allows for sample-efficient dialogue policy learning in multi-turn conversation. We demonstrate ACT ’s efficacy under sample-efficient conditions in three difficult conversational tasks: tabular-grounded question-answering, machine reading comprehension, and AmbigSQL, a novel task for disambiguating information-seeking requests for text-to-SQL generation. Additionally, we propose evaluating LLMs’ ability to function as conversational agents by examining whether they can implicitly recognize and reason about ambiguity in conversation. ACT demonstrates substantial conversation modeling improvements over standard approaches to supervised fine-tuning and DPO.

## 1 Introduction

Conversations offer a natural and effective way for humans and intelligent systems to collaborate [, ].
The impressive capabilities of large language models (LLMs) have powered the rapid development of many generalist conversational assistants such as ChatGPT(^1^11https://openai.com/blog/chatgpt) and Gemini [], which present an opportunity for users to verbalize their need for assistance on complex tasks. However, the promises of a conversational interfaces also come with the complexities of language. Human conversation is riddled with ambiguity, whether it be due to humans’ tendency to prefer underspecification [] or even due to syntactic errors []. Moreover, disambiguation becomes even more important in complex domains where it can be a difficult multi-turn process to achieve common ground []. As it stands, existing LLM-powered conversational agents continue to struggle with modeling ambiguity [], and tend to exhibit unwanted behavior such as overhedging [] or generating responses which represent a “guess” of the user’s intent [] (see Figure 1).

One of the primary reasons that LLMs may exhibit unwanted conversational behaviors is that their language modeling objective during pre-training or supervised fine-tuning (SFT) is not directly aligned with this goal  []. While approaches like [] propose LLM “alignment” using reinforcement learning from human feedback [], existing models still struggle with conversational tasks spanning multiple turns []. This is partly due to the fact that existing RLHF approaches do not directly optimize for pragmatic skills (e.g. []). Moreover, there is often high variance in the target distribution of a particular use case, so it is imperative that downstream adaptation approaches are able to teach an LLM generalizable policies. Given sufficient in-distribution training data, this may be feasible with standard tuning approaches. But, policy learning can be particularly challenging given limited data [, ], and high-quality conversation collection can be difficult for reasons
such as privacy concerns [].

This motivates the design of a conversational adaptation approach for LLMs which is more closely aligned with the goal of modeling actions in multi-turn conversation. We focus on improving LLMs’ abilities to implicitly select conversational strategies in ambiguous contexts, and propose an approach called Action-Based Contrastive Self-Training (ACT). ACT is a sample-efficient, quasi-online Direct Preference Optimization algorithm  [] which focuses on learning by highlighting the differences between an agent’s possible pragmatic conversational actions. We demonstrate ACT’s sample-efficient performance on a diverse range of mixed-initiative conversational tasks: (i) tabular-grounded question answering, (ii) machine reading comprehension, and (iii) text-to-SQL generation. Our work demonstrates the necessity of considering action-based preferences for conversational tasks, and we propose a workflow for evaluating LLMs’ ability to recognize and reason about ambiguity in conversation.

Figure: Figure 1: Simplified example of ambiguity present at tabular-grounded conversational question answering based on []. A conversational agent should recognize when there is ambiguity and ask a clarifying question towards a more accurate final answer.
Refer to caption: x1.png

## 2 Related Work

### 2.1 Mixed-Initiative Conversational Agents

Neural approaches to building mixed-initiative conversational agents typically consist of two core components: an understanding and planning module (e.g., a binary prediction task to determine whether to ask a clarifying question or provide an answer), and a generation module which can be controlled at a pragmatic level using the output of the planning module [, , , ] (e.g., forming an utterance which follows the action prescribed by the aforementioned prediction task).
Generation: Many existing works focus on novel training methodologies to improve conditional generation as a complement to planning, with approaches such as multi-objective SFT [, ] or introducing specialized embeddings for control codes [].
In recent years, LLMs have vastly improved performance in pragmatically-controlled generation [], but all of these approaches still depend on conversational planning. Planning remains a difficult task – natural interaction is not deterministic and often requires long-horizon planning.
Planning:
The planning task can be viewed as a stochastic Markov Decision Process [, , ] in which some dialogue state is drawn from a potentially unknown distribution, given the previous dialogue state and an imposed action. However, the action itself is not literally presented to the interacting parties; rather, an action is a low-dimensional representation of the pragmatic intent behind a given dialogue utterance (i.e., a dialogue act [, , , ]). As such, training planning modules often requires complex long-horizon reasoning and simulation to estimate the responses and intents of each interacting party. Many such efforts have examined combining neural models with search algorithms [, , ] and simulation [, , ]. However, not only do such modular approaches often incur high computational overhead [], but they result in error propagation while not directly optimizing for response quality itself. In hopes of mitigating these concerns, we propose directly optimizing dialogue action planning as an implicit subtask of response generation in mixed-initiative conversation contexts, as we discuss in Section 3.2.

### 2.2 Reinforcement Learning for LLM Alignment

The current paradigm of LLM training for downstream use cases consists of three phases: pre-training, supervised fine-tuning (SFT) for instruction-following, and RL tuning for alignment with human preferences [, , , ]. In our work, we primarily focus on the RL tuning phase. These approaches typically start with an initial policy model obtained by conducting SFT on a target task ($\pi_{SFT}$), before performing RL tuning using contrastive preference examples (most commonly collected through human feedback [] or a similar proxy like LLM-generated feedback []).
Online versus Offline RL Algorithms:
In the case of online algorithms like PPO, a reward model is first fit over the preference examples so that it could be used for RL optimization [].
Such algorithms have certain advantages which may benefit the Markov Decision Process-like nature of conversations — namely, a diverse search space as opposed to a fixed dataset, flexible reward functions, and broader policy exploration.
However, PPO is notoriously difficult to tune, and offline algorithms such as DPO [], SLiC [], and IPO [] have become widely adopted as an LLM adaptation approach because they bypasses explicit reward modeling and thus only require one set of hyperparameters to optimize [, , , ] while still achieving similar empirical results [] given a fixed preference dataset.
Despite these findings, many of our contemporaries also question the promises of fully offline preference learning and have examined “online” variants of these offline algorithms [, , , ].

## 3 Methods

### 3.1 Problem Setup

We consider the formulation of tuning an LLM to function as a mixed-initiative conversational agent — through a series of dialogue interactions with a user, the LLM is expected to assist the user by correctly providing an output to the given query. Unlike the common agent interaction setting in which users completely control the flow of interaction with the expectation that agents may autonomously complete tasks such as using tools or online shopping [], mixed-initiative conversational agents should understand how to redirect the flow of the interaction [] through the execution of various actions or conversational strategies [, , ], such as clarifying questions.

##### Notation

Consider a conversational environment in which an LLM is RL-tuned for response optimization. Let $\pi_{\theta_{i}}$ be an LLM’s policy parameterized by $\theta$ at timestep $i\geq 0$, with $\pi_{ref}$ being the reference policy model (i.e., $\pi_{ref}\leftarrow\pi_{\theta_{0}}$). Let $D$ be a dataset consisting of conversations. Let each conversation $c$ in $D$ contain $n$ dialogue turns, through which a user is requesting one or more pieces of information from an agent. The state of a conversation (the observed utterances and actions given by each interacting party) at timestep $i$ can be represented by $t_{i}$. Implicitly, each $t_{i}$ is part of a trajectory which ends when the user’s question expressed at an earlier timestep $j\leq i$ is answered(^2^22The case where $t_{i}$ contains the answer to a question while $j=i$ represents single-turn trajectories (those where a question is answered immediately, without any clarification turns).). Each state $t_{i}$ is represented by the following tuple: $(p_{i},r_{i},g_{i},a_{i})$. $p_{i}$ is the prompt at $i$, consisting of any task-specific information (e.g. a SQL database schema, tabular data or retrieved passages) combined with any existing dialogue context. $r_{i}$ is the ground truth system-side response at $i$. $g_{i}$ is the response at the end of $t_{i}$’s ground truth trajectory, i.e., the answer to the user’s original question after any possible clarification turns. In the single-turn trajectory case, $g_{i}\leftarrow r_{i}$. $a_{i}$ is the action implicitly expressed by $r_{i}$, where $a_{i}$ exists in the Action Space $S$ of a particular task(^3^33In the context of a fixed dataset, $a_{i}$ may be a fixed annotation. However, in online contexts like training or inference, the implicit action must be inferred by other means such as classification.). For the conversational datasets considered in our experiments, we set $S=[\text{CLARIFY},\text{ANSWER}]$ (but we note that the method can be extended to a broader action space). We also assume access to a capable controllable generation model ($M$), Action Classifier ($A$) and model which can be controlled to function as a coherent User Simulator ($U$). As discussed in Section 3.2, $M$ is used for preference data creation whereas $A$ and $U$ are both used during tuning and evaluation. We illustrate this notation in Figure A3.

### 3.2 ACT : Action-Based Contrastive Self-training

Figure: Figure 2: Overview of the tuning phase of ACT. For each initial contrastive pairing from $D_{pref}$ (constructed as in Section 3.2.1), we sample an on-policy response from the model being tuned. After evaluating the sampled response’s trajectory, we update the contrastive pairing by either replacing the existing winning or losing response. The model policy is updated using the objective in Eqn 1.
Refer to caption: x2.png

One of the north stars in developing intelligent conversational models is the ability to automatically produce responses which take actions which lead to the highest probability of conversational success [, ]. We propose ACT, an approach that adapts generic LLMs for dialogue generation which considers dialogue planning as an implicit subtask. ACT is a quasi-online extension of the DPO algorithm which maintains its ease of use while incorporating more of the flexible exploration found during online learning. ACT relies on a few core intuitions.
1) Contrastive preferences are an intuitive medium for demonstrating the pragmatic differences between the implicit actions of “winning” and “losing” dialogue responses.
2) Conversational improvements require multi-turn optimization, which are difficult to express using only single-turn contrast pairings.
3) The gradient of the objective of algorithms such as DPO (see Eq. 2) is weighted based on the log probabilities assigned to the winning and losing responses.
4) By construction, on-policy response sampling represents a high-probability token sequence for an iteration of a policy model.
5) Knowledge of whether a policy model will assign high token probabilities to a given sequence can be used to form high-quality contrast pairings which effectively reward or penalize a model’s own responses due to DPO’s contrastive learning objective.
The overall ACT framework is summarized in Fig. 2. ACT consists of two phases: action-based contrast dataset construction (Algorithm 1) and contrastive self-training (Algorithm 2).

Figure: Algorithm 1 Action-Based Contrast Dataset Construction

#### 3.2.1 Construction of Preference Data

The preference dataset primarily consists of contrastive winning-losing action pairs. That is, for each conversation turn $t_{i}$ in a dataset $D$, we can construct $D_{pref}$ consisting of augmented $t_{i}^{\prime}$ tuples. We add rejected action $a_{i}^{\prime}$ which is sampled from $S\setminus a_{i}$ (note that in settings with a binary action space, such as ambiguous question answering, this is deterministic), winning response $y_{w_{i}}$ which is equal to $r_{i}$, and $y_{l_{i}}$ which is a losing response sampled using $M$(^4^44The losing response is sampled as $y_{li}\sim P_{M}(\cdot|p_{i},a_{i}^{\prime})$ after converting actions into instructions as in [].). See Algorithm 1.
LLM-generated responses can be more likely to be faithful to some prescribed dialogue act than the supposed ground-truth dialogue act annotations of utterances in many crowd-sourced dialogue datasets []. As such, given that each $a_{i}^{\prime}$ is pre-defined when constructing $D_{pref}$, we use a high capacity LLM rather than tuning a smaller one or asking crowdworkers for losing response construction (more details in Appendix E).

#### 3.2.2 Self-Training Using On-policy Conversation Trajectory Simulation

As in DPO training, we continuously sample batches from $D_{pref}$. Although each conversation turn $t_{j}$ in each batch $i$ has a default winning ($y_{wi}$) and losing ($y_{li}$) response, we also sample an on-policy response $y_{j}$ from $\pi_{\theta_{i}}$. We use $A$ to determine whether the implicit action of $y_{j}$
(^5^55Classifying $y_{j}$’s action optimizes the following: $\operatorname*{argmax}_{a_{k}\in S}P_{A}(a_{k}|p_{j},y_{j})$)
matches the ground truth action $a_{j}$. If it does match $a_{j}$, then we simulate the outcome $g_{j}^{\prime}$ of the trajectory resulting from $y_{j}$ using $U$
(^6^66The next user turn (denoted $u_{j+1}$) is sampled according to $u_{j+1}\sim P_{U}(\cdot|p_{j},y_{j}$))
and $\pi_{\theta_{i}}$. If either the implicit action of $y_{j}$ is incorrect, or the trajectory outcome $g_{j}^{\prime}$ fails to meet task-specific heuristics (e.g., low semantic similarity or an incorrect arithmetic expression), we set $y_{lj}=y_{j}$. We provide details on the usage of $A$ and $U$ in Appendices F and G, respectively.

#### 3.2.3 Contrastive RL Tuning for Alignment

After constructing the up-to-date winning $y_{wi}$ and losing $y_{li}$ pairing at turn $i$ through simulation (Section 3.2.2), we update the policy model ($\pi_{\theta}$) using the DPO training objective[], which is as follows (we ignore the $i$ iterator for simplicity):

$$ $\mathcal{L}_{\text{DPO}}(\pi_{\theta};\pi_{ref})=-\mathbb{E}_{(p,y_{w},y_{l}) \sim\mathcal{D}}\left[\log\sigma\left(\beta\log\frac{\pi_{\theta}(y_{w}\mid p) }{\pi_{ref}(y_{w}\mid p)}-\beta\log\frac{\pi_{\theta}(y_{l}\mid p)}{\pi_{ref}( y_{l}\mid p)}\right)\right],$ (1) $$

where $p$ is a prompt consisting of a concatenation between task info and conversation history = {$x_{1},y_{1},...,x_{i-1},y_{i-1},x_{i}$} with each $x_{i}$ and $y_{i}$ representing observed user-side and system-side utterances at turn $i$; $y_{w}$ and $y_{l}$ are the designated “winning” and “losing” responses or trajectories as set in Section 3.2.2; $\pi_{ref}$ is the initial reference policy model; and $\beta$ is a hyperparameter that regularizes the ratio between $\pi_{\theta}$ and $\pi_{ref}$. The gradient of this objective is given in [] as follows:

$$ $\nabla_{\theta}\mathcal{L}_{\text{DPO}}(\pi_{\theta};\pi_{ref})=\\ -\beta\mathbb{E}_{(p,y_{w},y_{l})\sim\mathcal{D}}\bigg{[}\sigma(\hat{R}_{ \theta}(p,y_{l})-\hat{R}_{\theta}(p,y_{w}))\bigg{[}\nabla_{\theta}\log\pi(y_{w }\mid p)-\nabla_{\theta}\log\pi(y_{l}\mid p)\bigg{]}\bigg{]},$ (2) $$

where $R(p,y)=\beta\log\frac{\pi(y|p)}{\pi_{ref}(y|p)}$ for a given policy model $\pi$ and reference model $\pi_{ref}$, as proven under the assumptions in []. The intuition behind the objective is that the gradient of the loss function would increase the likelihood of winning responses $y_{w}\in Y_{w}$ and would decrease the likelihood of losing responses $y_{l}\in Y_{l}$, with each example being weighed by the magnitude of how incorrectly the implicitly defined reward model ranks the paired responses.

Figure: Algorithm 2 ACT: Action-Based Contrastive Self-Training

## 4 Experimental Setup

Table: Table 1: Experimental results on PACIFIC’s public validation set. ACT achieves the strongest performance compared to all tuning approaches across every condition in every metric. ACT with zero-shot inference also matches or outperforms 10-shot Gemini in most conditions.

ACT is a sample-efficient approach to adapt an LLM to a conversational action policy.
We are primarily concerned with learning improved timing for agent-side clarification question asking, and we thus evaluate ACT as a tuning approach for three complex conversational information-seeking tasks. As a base model for our tuning experiments, we use Zephyr $\beta$, a version of Mistral 7B [] which has been instruction tuned on UltraChat and aligned to human preferences on UltraFeedback [, , ].

### 4.1 Datasets

We investigate three mixed-initiative conversation tasks in which a user interacts with an assistant to retrieve some information. In our setup of each task, a user asks a query which may or may not be underspecified. The assistant is tasked with providing a response which may either be a clarifying question or an attempt to directly answer the user’s query. For each task, we synthesize the initial rejected responses by prompting Gemini Ultra 1.0(^7^77Gemini is accessed through the Vertex AI API: [https://cloud.google.com/vertex-ai/docs/](https://cloud.google.com/vertex-ai/docs/)) as the conditional generation model, $M$.

##### PACIFIC

is a task for proactive conversational question answering grounded on a mixture of tabular and textual financial data [].
This may involve generating the correct words from a given span, from multiple spans, or providing a correct arithmetic expression.
The official evaluation for PACIFIC uses a numeracy-focused token overlap metric called DROP F1.

##### Abg-CoQA

is a conversational question answering dataset for disambiguation in machine reading comprehension [].
As there are no arithmetic expressions, we use embedding-based semantic distance with SentenceBERT [] as an evaluation metric, which has been proposed as a more flexible and realistic measure of question-answering performance [].

##### AmbigSQL

is our new task for SQL-grounded conversational disambiguation.
We systematically perturbed unambiguous queries from Spider, a popular text-to-SQL benchmark [],
resulting in paired training examples which can be easily incorporated into contrastive RL tuning. Each trajectory is evaluated by whether the final proposed SQL query matches the ground truth query’s execution result.
We provide a detailed description of AmbigSQL and its construction in Appendix B.
Our motivation in constructing AmbigSQL stems from the idea that disambiguation can lead to improved task performance. We found that constructing a SQL query for an underspecified request with and without clarification turns can result in a gap in execution match of up to 45.8% (see Table A10).

### 4.2 Evaluation

We conduct evaluations of ACT’s ability to improve reasoning about ambiguity in conversation along two dimensions: 1) Implicit Ambiguity Recognition, an action-level evaluation of whether an agent correctly chooses to ask a clarifying question or provide an answer, and 2) Agent Task Performance, a content-level of the downstream task in terms of metrics such as execution match.

##### Implicit Ambiguity Recognition

follows the notion of “dialogue act accuracy” used to evaluate generation controllability in []. We evaluate whether each model can implicitly select the correct conversational action. Given a contextually-ambiguous user request, a model should generate a clarifying question, otherwise, it should attempt to provide the requested information.
Since PACIFIC and Abg-CoQA have highly imbalanced classes, we perform evaluation in terms of Accuracy, Weighted F1, and Macro F1. AmbigSQL is balanced, so we only evaluate Accuracy.

Agent Task Performance
We also evaluate on downstream task performance to verify that 1) ACT does not unlearn task knowledge when optimizing for implicit actions, and 2) ACT improves multi-turn task capabilities.

Table: Table 2: Abg-CoQA test set evaluation results. ACT outperforms SFT across all evaluations in all three data settings. However, Gemini Ultra achieves the strongest downstream task performance when prompted with in-distribution in-context conversation examples.

PACIFIC and Abg-CoQA are both initially proposed only with static task performance evaluations. The official PACIFIC evaluation only consists of system-side DROP F1 score (i.e., the system does not have to provide the eventual correct answer after asking a clarifying question), and Abg-CoQA only requires the system to provide answers (i.e., the system is never asked to produce a clarifying question). To mirror the static evaluation settings originally designed for these two tasks, we first conduct turn-level evaluation by comparing the model’s response to the ground truth utterance given in response to the user’s query, using the task-specific heuristics given in Section 4.1.

However, because we are specifically concerned with improving LLMs’ multi-turn capabilities, we additionally propose a multi-turn evaluation scheme for all three tasks considered. We consider each user query to be a different information-seeking goal. For a given goal, the initial user-side query can be considered the beginning of a ground truth trajectory, and any possible clarification turns that are in response to a query can be considered to be a part of the same ground-truth trajectory of that query’s goal. We sample a response for each user-side query and simulate the trajectory outcome each time the sampled response is a clarifying question. We use $A$ and $U$ for simulation as described in Section 3.2.2 for ACT, and use the heuristics defined in Section 4.1. We also compute task performance on the simulated responses in which the model has previously asked any clarifying questions, in order to get a more fine-grained measure of the model’s ability to reason about its own clarification questions.
Details of each evaluation metric for each task are provided in Appendix C.

### 4.3 Baselines

##### Prompting Baselines

We also compare downstream task performance against end-to-end prompt-based approaches paired with frontier LLMs: Gemini Ultra 1.0 and Gemini Pro 1.5. We use 10 conversations as in-context examples, with three different prompting frameworks: i.) “Standard” which uses the same instruction formatting used for tuning; ii.) chain-of-thought reasoning []; and iii.) the mixed-initiative prompting style as used in [] combined with Proactive Prompting [], which is the strongest prompting baseline in [] (henceforth Proactive MIPrompt, following the convention in []). We provide a detailed description of each style with examples in Appendix D.

##### Tuning Baselines

We compare ACT with supervised fine-tuning (SFT) as well as a common approach to DPO-based alignment. For SFT, we use the ground truth responses for each dataset’s training split.
As for DPO-based alignment, in the absence of human annotators, a widely accepted approaches has been naively sampling responses from two high capacity models, with $Y_{w}$ coming from whichever model is of higher capacity (e.g., GPT-4 versus GPT-3.5) [, , ], effectively performing distillation from the larger model. We thus construct a preference dataset by sampling responses from Gemini Ultra 1.0 and its smaller counterpart, Gemini Pro 1.0. We use “Standard” in-context learning with ten examples for domain adaptation.

## 5 Experimental Results

To emulate real-world scenarios with limited data, we evaluate ACT as a tuning approach in a few different conditions with limited conversation samples across a set of diverse tasks.

### 5.1 Conversational QA with Tabular Grounding

In Table 1, we see that across all three data settings considered, ACT achieves the strongest performance across all metrics compared to the other tuning approaches. Additionally, tuning with ACT in these limited data settings grants the model the ability to match our outperform frontier language models despite having zero in-context examples during inference.
Overall, ACT appears to be helping to improve the recognition of ambiguity, as well as the ability to reason about clarifying questions. Additionally, the task-specific heuristics do appear to improve performance at the turn-level.

### 5.2 Conversational QA for Machine Reading Comprehension

Our results for Abg-CoQA are presented in Table 2. In all three data settings, we observe that ACT achieved the strongest performance in terms of task-specific metrics (notably, in terms of trajectory-level embedding similarity). However, in the 50 and 250 conversation condition, Naive DPO outperforms ACT in terms of Action Accuracy, and in the 100 conversation condition, SFT outperforms ACT in terms of Macro F1. Additionally, Gemini Ultra with Standard prompting outperforms all baselines in terms of Macro F1, Turn Similarity, and Trajectory-level similarity, although ACT with 250 conversations achieves comparable performance in terms of Trajectory-level similarity. This is likely because existing frontier LLMs can already achieve strong QA performance.

### 5.3 Conversational Text-to-SQL Generation

We find that although the prompting baselines do not achieve very high Action Accuracy, it is possible to achieve rather high Accuracy with SFT in each data condition. However, it appears that SFT alone is not sufficient for maximizing conversational reasoning performance. In each of the limited data scenarios, we observe considerable improvements in terms of Execution Match and Post-Clarification Execution Match with ACT compared to both SFT and Naive DPO.
We note that prompting Gemini achieves the highest downstream task performance. This is likely due to the stronger capabilities of these LLMs in complex tasks such as text-to-SQL generation.

Table: Table 3: AmbigSQL test set evaluation. Zephyr tuned with ACT is able to achieve the strongest task performance within each data setting. There are especially large performance improvements in post-clarification SQL execution match when data resources are more scarce.

### 5.4 Qualitative Examples

In Table 4 we compare two trajectories produced by Zephyr 7B tuned on 50 conversations from PACIFIC using SFT and ACT, respectively, given the same conversation context and tabular information. The SFT model provided an incorrect answer to the user request, matching the “Incorrect Assumption” case in Figure 1. In contrast, the model tuned using ACT asked a clarifying question before eventually producing the correct answer. We provide additional qualitative examples in Appendix H.

Table: Table 4: Comparison of trajectories using different tuning approaches. Left: snippet of tabular data from the PACIFIC test set. Middle: trajectory resulting from the SFT model in response to the user query. Right: trajectory resulting from the ACT model. Red text: sampled from $U$.

### 5.5 Ablation Studies

**Table 5: Ablation study of various conditions using PACIFIC’s 50 conversation setting.**
|  | Macro F1 $\uparrow$ | Turn F1 $\uparrow$ | Traj. F1 $\uparrow$ | Post-Clarify F1 $\uparrow$ |
| --- | --- | --- | --- | --- |
| Action Importance |  |  |  |  |
| ACT |  |  |  |  |
| w/ Random Actions | 63.2 | 55.3 | 58.7 | 32.8 |
| Ablation of ACT subcomponents |  |  |  |  |
| ACT |  |  |  |  |
| w/o on-policy sampling | 74.8 | 61.5 | 59.1 | 40.5 |
| ACT |  |  |  |  |
| w/ sampling but w/o simulation | 81.4 | 60.8 | 60.2 | 50.1 |
| ACT (full) | 82.2 | 62.8 | 61.9 | 57.2 |
| ACT with unaligned foundation models |  |  |  |  |
| Gemma 2B SFT | 57.7 | 38.0 | 40.5 | 17.0 |
| Gemma 2B ACT | 62.7 | 42.6 | 44.0 | 24.8 |
| Mistral 7B SFT | 57.7 | 53.8 | 51.4 | 27.7 |
| Mistral 7B ACT | 75.7 | 58.1 | 57.6 | 31.9 |

##### Are action-based preferences necessary?

One of the key factors of ACT is that all of the contrastive pairs highlight differences between pragmatic actions (e.g. asking a question versus providing an answer). As indicated in the main results (Tables 1,2,3), we see that Naive DPO (i.e., when we sample preference pairings from LLMs without action specification) underperforms ACT. In Table 5, we additionally examine the importance of action selection by randomly sampling both the winning and losing action when constructing the preference pair, and observe this underperforms normal ACT.

##### Do we need on-policy sampling?

In Table 5, we also consider whether it is sufficient to remove sampling altogether, i.e. using the normal DPO algorithm on the action-based preference dataset as constructed in Section 3.2.1. While we do observe some improvements over SFT (e.g., from 69.0 to 74.8 in terms of Macro F1 and from 57.8 to 61.5 in terms of turn-level DROP F1), the overall improvements are much larger when using on-policy sampling as with full ACT. This may be due to the fact that the LLM-sampled negative responses are not guaranteed to lie within the language manifold of the tuned policy model, making the training example too “easy.” Similarly, distribution shift is the key motivating factor the proposed online variant of DPO in [].

##### Is trajectory simulation necessary?

We propose ACT as an approach which is better-aligned with multi-turn conversations due to its trajectory-level simulation from the policy model. In Table 5, we find that removing trajectory-level simulation (while including on-policy response sampling for the purpose of determining pragmatic-level actions) results in degraded performance in terms of post-clarification DROP F1. This indicates that the model is better able to reason about its own clarification questions when tuned with trajectory-level simulation. We do note that this condition does outperform both SFT and ACT without any sampling (particularly in terms of Macro F1).

##### How much does pre-aligning the initial policy model help?

In all of our experiments with ACT, we used Zephyr 7B-$\beta$, a version of Mistral 7B which has already been aligned with DPO. In Table 5 we also examine the impact of directly tuning two base foundation models, Mistral 7B and Gemma 2B. Directly comparing the baseline SFT performance with Mistral 7B against Zephyr 7B (see Table 1), we can see there is already a noticeable gap in all metrics. After applying ACT, while Mistral 7B’s performance does improve, it does not achieve the same performance as Zephyr.

### 5.6 Limitations

The biggest limitation of our work is that we assume: i) the labeled clarification need of each dataset is objective; ii) the clarification questions are appropriate; and iii) the eventual answers are the ground truth. However, depending on the dataset, this can be a faulty assumption. Crowdsourced conversation datasets are often noisy [], and relying on noisy annotations or token sequences can result in suboptimal learned policies (from the perspective of asking unnecessary clarifying questions, as well as generating disfluent language). We discuss further limitations in Appendix A.1.

## 6 Conclusion

In this work, we proposed ACT, a quasi-online contrastive RL-tuning approach for sample-efficient conversational task adaptation, along with a workflow for evaluation of conversational agents.
How ACT will generalize to large-scale data and multi-task environments warrants further study, but in this work we see encouraging evidence that it is highly effective for task adaptation in the limited data regime. Future work may also consider combining ACT with existing sophisticated tuning approaches and task heuristics such as execution feedback for complex tasks like text-to-SQL generation.

## Appendix A Additional Limitations, Ethical Considerations, and Broader Impacts

### A.1 Additional Discussion of Limitations

ACT also makes use of task-specific heuristics. While this was intentional since success criteria can vary greatly across domains, it can be considered a limitation from the perspective that ACT’s implementation details may vary, requiring more customization and engineering expertise/effort. Additionally, our overall approach to tuning and evaluation makes heavy use of existing LLMs. We prompt Gemini for purposes such as Action Classification or User Simulation, but such approaches are not perfect and will occasionally result in unwanted behavior. These prompting approaches similarly require substantial customization efforts. We also realize that not all researchers may have access to commercial LLMs due to researchers for financial or privacy reasons.

Our study also focuses specifically on the limited data regime. We believe that such contexts (e.g., when the target user population is unknown; when conversational data cannot be collected due to privacy concerns; when a conversational system is in its early stages and collecting abundant data for development iteration is not feasible; etc.) would benefit the most from focused adaptation designed to fundamentally teach conversational skills approaches such as ACT. As such, in our paper, this was the focus of all of our experiments. It is not clear how much our findings would generalize in settings in which there is an abundance of training data whose distribution closely matches the target distribution. Intuitively, if much more in-distribution data is made available, even the performance of unaligned objectives like SFT would start to catch up to the performance of focused approaches.

##### Is ACT online learning?

[] defines offline reinforcement learning as using a fixed dataset of experiences, whereas online reinforcement learning relies on interacting with an environment in real-time. Additionally, [] defines on-policy sampling in contrastive RL tuning as settings where both the winning and losing responses are sampled from the policy model.
In our case, during tuning, we sample a single response from the policy model.

As such, we define ACT as a quasi-online contrastive RL tuning approach. ACT does rely on action-based preference dataset, as is common in fully-offline reinforcement learning. However, ACT continuously samples responses form the policy model in order to update the contrast pairing with good or bad trajectories. Overall, it has both dynamic and static components, so we refer to it as quasi-online. ACT also specifically is different from fully online DPO where both the winning and losing responses are sampled (i.e. in []) because our focus is on conversational actions. There is no guarantee that sampling a response from the policy model twice will result in differing actions, unless you change the prompt. However, in that case, you would no longer be computing the DPO objective.

By nature of the domains considered, the extent to which ACT allows for online exploration is also limited. As previously mentioned, our experiments are constrained by the fact that there is an objective right/wrong target answer. For instance, if the target answer is an arithmetic expression as is common in PACIFIC, there are a fairly limited number of unique trajectories (when inspected in terms of the number of tokens) that will arrive at that particular expression. In such cases, the trajectory sampled from the policy model during ACT tuning may not be any different from the offline trajectory found in the training data.

### A.2 Ethical Considerations

##### Usage and Safety

We do not condone the use of our work for any unethical, unlawful, and/or harmful applications. In our work, we do not release any new model artifacts or web-scraped data, but we do not specifically introduce any model guardrails as a part of ACT. However, our implementation of ACT relies on other LLMs such as Gemini to produce an initial preference dataset, and to perform user simulation. Gemini is released with safety guardrails in place, but these inference-time guardrails may not be available when using open-source LLMs instead. We advise that any deployments of models tuned with ACT should consider adding safety guardrails at inference-time.

##### Hallucinations

One commonly documented concern with using LLMs is their tendency to hallucinate answers in Assistant QA contexts. A solution is to provide an LLM with information from a retriever (i.e., retrieval-augmented generation). Two of the datasets we use, PACIFIC and Abg-CoQA, mirror this setting by performing grounded QA using a mixture of long-context textual passages and tabular data. It follows that ACT could be further studied in combination with approaches for improved retrieval-augmented generation.

Our evaluation criteria in this paper are also rather restrictive towards hallucinations. In PACIFIC, we use a token-level metric (DROP F1); in Abg-CoQA, we evaluate a candidate response’s semantic similarity with a ground truth answer; in AmbigSQL we use execution match, which is a fully objective metric. As such, it is difficult to perform well on PACIFIC and Abg-CoQA if a model consistently hallucinates answers, and in AmbigSQL, a “hallucinated” response would not consist of the appropriate SQL code.

### A.3 Broader Impacts

There is an abundance of modern conversational assistants. ACT seeks to improve multi-turn conversational experiences, and thus, it can be used to improve many applications used by potentially millions of users around the world. However, the popularity of conversational assistants also creates an increased risk of misuse. Some people may develop conversational for unethical applications such as misinformation generation, or gray areas such as optimizing dialogue generation for content which is not suitable for the workplace. As discussed above, we do not condone the use of ACT for any unethical, harmful, or unlawful applications, and we suggest the usage of safety guardrails for any deployments.

## Appendix B AmbigSQL : Modeling Ambig uity in Conversational Text-to- SQL

**Table A6: Overview of AmbigSQL, an ambiguous Text-to-SQL dataset synthesized from Spider.**
|  | Train | Dev | Test |
| --- | --- | --- | --- |
| Num. Unambiguous Requests | 7,000 | 1,034 | 1,034 |
| Num. Ambiguous Requests | 7,000 | 1,034 | 1,034 |
| Num. Unique Schemas | 1,056 | 145 | 145 |
| Types of Ambiguity | 3 | 3 | 3 |

There is growing interest in using LLM-based agents for coding tasks []. Particularly, due to the complexity of such tasks, multi-turn interactions in which an agent is able to clarify assumptions and user intents should intuitively help with goal completion []. Despite this, there are few existing resources for multi-turn code generation tasks. One example is CoSQL, a conversational text-to-SQL task which also includes linguistic ambiguities [], but the proposed task does not include agent-style interaction in which a model must learn to ask clarifying questions. Upon our inspection of the dataset, there are also various inconsistencies related to the “system-side” clarification questions given in the dataset’s conversational contexts, which we highlight in Table A7. As a result, we propose AmbigSQL, our own synthetically constructed resource for ambiguous conversational text-to-SQL.

**Table A7: Conversations in CoSQL with noisy “clarification questions” (highlighted in red). Example 1) is a remnant of crowdsourcing in which the system-side party makes mention of the task guideline. Example 2) demonstrates a system-side clarification question being asked prior to the user making any information requests. Example 3) The system-side clarification question makes reference to some prior database search result, but the execution feedback is not made accessible to the system during inference.**
| No. | Interacting Party | Utterance |
| --- | --- | --- |
|  | User | Can you list all the singer ids that aren’t present in the song table? |
|  | Assistant | SELECT Name FROM singer WHERE Singer_ID NOT IN ... |
|  | User | Thanks! |
| 1 | Assistant | You should ask at least 3 questions |
| 2 | Assistant | Did you want the full name of makers and the number? |
| 3 | Assistant | Do you mean the address of the customer with first name Luis? |

### B.1 AmbigSQL Construction

**Table A8: In-context example given as part of a prompt for creating information requests in which the target population is ambiguous. The format of the black text represents how a ground-truth request would be used to form the prompt for a target example. The blue text represents the content that would be synthesized from an LLM. We omit the database schema from the paper.**
| $[$Database Schema Omitted$]$ |
| --- |
| The target SQL query is the following:<br>SELECT professional_id , last_name , cell_number FROM Professionals<br>WHERE state = ’Indiana’ UNION SELECT T1.professional_id , T1.last_name ,<br>T1.cell_number FROM Professionals AS T1 JOIN Treatments AS T2 ON<br>T1.professional_id = T2.professional_id<br>GROUP BY T1.professional_id HAVING count(*) > 2<br>Here is a clear request that would correspond to this SQL query: |
| “Which professionals live in the state of Indiana or have done treatment on more than 2 treatments? List his or her id, last name and cell phone.” |
| Here is the same request converted into an ambiguous format by underspecifying the target columns: |
| “Which ones live in the state of Indiana or have done treatment on more than 2 treatments?” |
| Here is an appropriate clarifying question to recover the clear request from the ambiguous request: |
| “Are you asking about the Professionals?” |

We start from Spider, a popular single-turn text-to-SQL dataset and benchmark. An overview of AmbigSQL is given in Table A6. Due to the nature of the single-turn requests in Spider, each instance can be viewed as a conversation consisting of a single state $t_{1}$ (see notation defined in Section 3). In $t_{1}$, $p_{1}$ contains any instructions, the database schema, and the user’s request. $r_{1}$ is the correct SQL query which yields the information requested by the user. $g_{1}=r_{1}$ because the trajectory ends on the same turn due to the system yielding the correct query. $a_{1}=ANSWER$ because the only action possible is to provide a SQL query.

Our desired result in constructing AmbigSQL is to have a corpus which can be used to demonstrate to an LLM the linguistic differences between ambiguous and clear user requests. That is, given a fixed database schema and a target SQL query, we want a pair of requests such that one requires asking a clarification question and one does not. This would also result in a balanced dataset in which half of the requests require asking clarification questions, and half do not.

We focus on three fundamental types of ambiguous information requests. Those in which the requested information is ambiguous (e.g., “Show details about singers ordered by age from the oldest to the youngest”), those in which the requested population is ambiguous (e.g., “Which ones who live in the state of Indiana?”; see Table A8), and finally, those in which the requested presentation of results is ambiguous (e.g. “Show name, country, age for all singers ordered by age”; see Table A9).

We iterate through each of the examples in Spider, and use an LLM (Gemini Ultra 1.0) to synthesize a perturbed version of each unambiguous query, along with an appropriate clarifying question. For queries which require some manipulation of results presentation, we prompt an LLM to perturb the query such that the requested presentation style becomes ambiguous. Otherwise, we randomly select a perturbation strategy: either masking the requested information (Table A9) or masking the requested population (Table A8). For each of these three strategies, we use five in-context examples demonstrating the appropriate masking process. The exact in-context examples are given in the attached code. Each of these ambiguous queries are thus associated with conversations containing “ground truth” states at two timesteps, $t_{1}$ and $t_{2}$. $p_{1}$ contains an ambiguous user request, $r_{1}$ is the synthesized clarification question, and accordingly, $a_{1}=CLARIFY$. $p_{2}$ contains the disambiguated user request, $r_{2}$ is the correct ground truth SQL query, and accordingly, $a_{2}=ANSWER$.

The code to create AmbigSQL will be released publicly. Each instance includes the database metadata included in Spider, but for all experiments used in this paper, the database schema is linearized into the format used for prompting in  [, ].

**Table A9: In-context example given as part of a prompt for creating information requests in which the target columns are ambiguous. The format of the black text represents how a ground-truth request would be used to form the prompt for a target example. The blue text represents the content that would be synthesized from an LLM. We omit the database schema from the paper.**
| $[$Database Schema Omitted$]$ |
| --- |
| The target SQL query is the following:<br>SELECT professional_id , last_name , cell_number FROM Professionals<br>WHERE state = ’Indiana’ UNION SELECT T1.professional_id , T1.last_name ,<br>T1.cell_number FROM Professionals AS T1 JOIN Treatments AS T2 ON<br>T1.professional_id = T2.professional_id<br>GROUP BY T1.professional_id HAVING count(*) > 2<br>Here is a clear request that would correspond to this SQL query: |
| “Which professionals live in the state of Indiana or have done treatment on more than 2 treatments? List his or her id, last name and cell phone.” |
| Here is the same request converted into an ambiguous format by underspecifying the target columns: |
| “Which professionals live in the state of Indiana or have done treatment on more than 2 treatments?” |
| Here is an appropriate clarifying question to recover the clear request from the ambiguous request: |
| ‘’Which information of the professionals do you want to know?” |

Table: Table A10: Examination of ambiguity in AmbigSQL. Competitive high capacity LLMs struggle with producing “correct” SQL queries given only ambiguous user requests. Including disambiguation turns in the prompts greatly improves execution match.

### B.2 Examining Clarification Need in AmbigSQL

We primarily are concerned with examining the extent to which clarification questions are necessary in providing the requested SQL queries. Inspired by the notion of “recovery” presented in [], we examine the performance in constructing each of the unique SQL queries with and without the gold clarification turns. Concretely, we first evaluated the Execution Match performance achieved by prompting LLMs with only the ambiguous versions of each user request, with each instruction including the instruction that the LLM must construct a SQL query. Then, we prompted LLMs to construct the same SQL queries, but given the disambiguation turns as conversation history (i.e., with context consisting of the original ambiguous request, the clarification question, and then non-ambiguous request).

We conducted this analysis on the test set using two competitive LLMs, Gemini Pro 1.0 and Gemini Ultra 1.0, with the Execution Match tool from Spider and CoSQL [, ]. Our results are shown in Table A10. Given only an ambiguous request, both Gemini Pro and Gemini Ultra struggle to consistently construct the correct SQL query. However, given disambiguation turns, Execution Match improves dramatically, approximating the performance on the validation set given in [, ].

### B.3 Examples

Table A11 and Table A12 each contain a pair of examples from AmbigSQL’s test set. Each example contains the prompt which is provided to an LLM, the immediate ground truth response to the user request provided as part of the prompt, and the resulting ground truth trajectory (for examples which include clarifying questions). The examples in each table are paired — the top example is directly taken from Spider and converted into a conversational format, and the bottom example is the result of introducing ambiguity into the first example.

**Table A11: Examples from the AmbigSQL test set using the “concert_singer” database. Black text: context provided to an LLM as a prompt. Blue text: ground-truth single-turn response. Purple text: target trajectory which should be achieved through simulation.**
| $[$Instruction$]$ |
| --- |
| You are an Assistant having a conversation with a User who would like to retrieve some information from a SQL database with the schema provided below. If you are confident in the User’s intent, you should provide the appropriate SQL query. Otherwise, you should ask the User a clarifying question. |
| $[$Database Schema Omitted$]$ |
| $[$Conversation$]$ |
| User: How many singers do we have? |
| Assistant: SELECT count(*) FROM singer |
| $[$Instruction$]$ |
| You are an Assistant having a conversation with a User who would like to retrieve some information from a SQL database with the schema provided below. If you are confident in the User’s intent, you should provide the appropriate SQL query. Otherwise, you should ask the User a clarifying question. |
| $[$Database Schema Omitted$]$ |
| $[$Conversation$]$ |
| User: Tell me about the singers. |
| Assistant: What specifically would you like to know about the singers? For example, would you like to know how many there are, or see a list of their names? |
| User: How many singers do we have? |
| Assistant: SELECT count(*) FROM singer |

**Table A12: Examples from the AmbigSQL test set using the “flight_2” database. Black text: context provided to an LLM as a prompt. Blue text: ground-truth single-turn response. Purple text: target trajectory which should be achieved through simulation.**
| $[$Instruction$]$ |
| --- |
| You are an Assistant having a conversation with a User who would like to retrieve some information from a SQL database with the schema provided below. If you are confident in the User’s intent, you should provide the appropriate SQL query. Otherwise, you should ask the User a clarifying question. |
| $[$Database Schema Omitted$]$ |
| $[$Conversation$]$ |
| User: Return the number of airports. |
| Assistant: SELECT count(*) FROM AIRPORTS |
| $[$Instruction$]$ |
| You are an Assistant having a conversation with a User who would like to retrieve some information from a SQL database with the schema provided below. If you are confident in the User’s intent, you should provide the appropriate SQL query. Otherwise, you should ask the User a clarifying question. |
| $[$Database Schema Omitted$]$ |
| $[$Conversation$]$ |
| User: How many are there? |
| Assistant: Could you please specify which table you are referring to when you ask ’How many are there?’ |
| User: Return the number of airports. |
| Assistant: SELECT count(*) FROM AIRPORTS |

## Appendix C Additional Details on Evaluation

We define the following action-level evaluation metrics:

- •
Accuracy: Percentage of correct implicit actions
- •
Weighted F1: Average of F1 for each action, weighted by its support
- •
Macro F1: Unweighted Average of F1 for each action

We define the following content-level evaluation metrics:

- •
Turn-level DROP F1: Average immediate response DROP F1 [, ]
- •
Trajectory-level DROP F1: Average trajectory-outcome DROP F1 [, ]
- •
Post-Clarification DROP F1: Average DROP F1 [, ] of responses which follow agent clarification turns
- •
Turn-level Similarity: Immediate response embedding similarity
- •
Trajectory-level Similarity: Trajectory outcome embedding similarity
- •
Trajectory-level Execution Match: Percentage of trajectory outcomes with correct execution results
- •
Post-Clarification Execution Match: Percentage of trajectory outcomes with correct execution results out of those that which contain clarification turns

##### PACIFIC

As described in Section 4, PACIFIC is a conversational question-answering dataset in which the final answers may involve generating the correct words from a given span, from multiple spans, or providing a correct arithmetic expression. As such, the authors propose using DROP F1 as the official evaluation metric. The way DROP F1 is used in the original paper [] is analogous to our aforementioned “Turn-level DROP F1.” However, as this does not fully represent a model’s conversational reasoning abilities, we additionally evaluate LLMs in the PACIFIC environment using Accuracy, Weighted F1, Macro F1, Trajectory-level DROP F1, and Post-Clarification DROP F1. Concretely, the evaluation for some LLM $\pi$ is as follows. Assume we have some example with prompt $p$, winning action $a$, ground truth response $r$, and trajectory-level information goal $g$. We sample a candidate response from the LLM: $y\sim P_{\theta}(\cdot|p)$. We then simulate the trajectory resulting from each response $y$ according to Lines 6-12 in Algorithm 2 and obtain trajectory outcome $g^{\prime}$. The aforementioned action-level metrics are computed using the implicit actions of each $y$ with each ground truth implicit action $a$. Turn-level DROP F1 is computed between all sampled responses $y$ and all ground truth responses $r$, and Trajectory-level DROP F1 is computed over all simulated trajectory outcomes $g^{\prime}$ and all ground truth information goals $g$. Post-Clarification F1 is defined as Trajectory-level F1 for only the subset of trajectories which include clarification turns.

##### Abg-CoQA

As previously mentioned in Section 4, Abg-CoQA is a conversational question-answering dataset for machine reading comprehension. Thus, we use embedding similarity [] as it allows for producing more coherent and diverse responses which may be scored lowly by criteria such as token-level F1 score. In the original paper, language models are only evaluated in terms of QA performance [], rather than their ability to disambiguate requests. Thus, for our evaluation, we remove all clarification turns from the prompt and require the LLM to produce clarifying questions on its own. However, unlike the other tasks considered in this paper, each ambiguous request is paired with all of the possible trajectories (i.e., the reasons why the request is considered ambiguous). We thus perform an evaluation for every ground truth trajectory, so that it is impossible for an LLM to achieve a high cumulative trajectory-level score simply by getting lucky at guessing the user’s intent.

Concretely, the evaluation for some LLM $\pi$ is as follows. Assume we have some example with prompt $p$, winning action $a$, ground truth response $r$, and the set of trajectory-level information goals $G$. For every individual trajectory-level goal $g\in G$, we sample a candidate response from the LLM: $y\sim P_{\theta}(\cdot|p)$ then simulate the trajectory resulting from each response $y$ according to Lines 6-12 in Algorithm 2 and obtain trajectory outcome $g^{\prime}$. As with PACIFIC, we compute Accuracy, Weighted F1, and Macro F1 using the implicit actions of each $y$ with each ground truth implicit action $a$. We compute Turn-level similarity for each unique $p$ between sampled responses $y$ and ground truth responses $r$. We compute Trajectory-level similarity over all simulated trajectory outcomes $g^{\prime}$ and all ground truth information goals $g$.

##### AmbigSQL

is a ambiguous text-to-SQL generation task. By design, the labels are balanced, so we only use Accuracy for action-level metrics. The primary objective is to produce SQL queries which result in correct executions, so we evaluate LLMs in terms of Trajectory-level and Post-Clarification Execution Match. For each instance in the test set, we sample a response from an LLM and compute the trajectory as specified in Lines 6-12 in Algorithm 2. Trajectory-level Execution Match includes SQL queries which are constructed with or without clarification turns, whereas Post-Clarification Execution Match only looks at SQL queries which are constructed following clarification turns.

**Table A13: “Standard” in-context example given as part of a prompt to an LLM for response generation in PACIFIC. The purple text is the overall system instruction. The blue text is what an LLM would have to produce at inference time.**
| You are an Assistant answering questions from a User. You should either attempt to answer the question or ask a clarifying question if there is any ambiguity. |
| --- |
| $[$Table and Passage Omitted$]$ |
| User: How much does the company expect to make contributions to the defined plans during the next fiscal year? |
| Assistant: [’What kind of defined plans are you asking about?’] |
| User: The defined benefit plans and the defined contribution plan respectively. |
| Assistant: [’$5.1 million’, ’$0.6 million’] |
| User: What is the value of the expected defined contribution plan as a percentage of the defined benefit plan during the next fiscal year? |
| Assistant: 0.6/5.1 = 11.76 |
| User: How much would change if there is a 1% increase and a 1% decrease respectively in the discount rate? |
| Assistant: [’What kind of change are you asking about?’] |
| User: The pension. |
| Assistant: [’$(39,145)’, ’$49,361’] |
| User: What is the difference in that amount if the discount rate had a 1% increase and a 1% decrease? |
| Assistant: 49,361 - (39,145) = 88506 |
| User: How much would the pension change if there is a 1% increase and a 1% decrease respectively? |
| Assistant: [’Which rate of increase and decrease are you talking about?’] |
| User: The future salary growth. |
| Assistant: [’$7,572’, ’$(6,919)’] |
| User: What is the difference between them? |
| Assistant: 7,572 - (6,919) = 14491 |

## Appendix D Description of In-Context Learning Baselines

We use several in-context learning baselines with frontier LLMs in Section 4. For each condition, we randomly sample 10 conversation examples from each task’s 250-instance data pool, and apply one of the following prompting frameworks.

##### Standard Prompting

We simply provide in-context examples that are structurally identical to the inputs used for model tuning. Our format is similar to the formats used in [, ] and we provide an example in Table A13.

**Table A14: “Chain-of-Thought” in-context example given as part of a prompt to an LLM for response generation in PACIFIC. The purple text is the overall system instruction. The blue text is what an LLM would have to produce at inference time.**
| You are an Assistant answering questions from a User. You should either attempt to answer the question or ask a clarifying question if there is any ambiguity. |
| --- |
| $[$Table and Passage Omitted$]$ |
| User: What is the value of the expected defined contribution plan as a percentage of the defined benefit plan during the next fiscal year? |
| Instruction: If the user’s question is ambiguous, ask an appropriate clarifying question. Otherwise, directly answer the user’s question using the information from the passage context and the table. Let’s think step by step. |
| Reasoning: The user’s question is not ambiguous. Assistant: 0.6/5.1 = 11.76 |
| User: How much would change if there is a 1% increase and a 1% decrease respectively in the discount rate? |
| Instruction: If the user’s question is ambiguous, ask an appropriate clarifying question. Otherwise, directly answer the user’s question using the information from the passage context and the table. Let’s think step by step. |
| Reasoning: The user’s question was ambiguous. Assistant: [’What kind of change are you asking about?’] |
| User: The pension. |
| Instruction: If the user’s question is ambiguous, ask an appropriate clarifying question. Otherwise, directly answer the user’s question using the information from the passage context and the table. Let’s think step by step. |
| Reasoning: The user’s question is not ambiguous. Assistant: [’$(39,145)’, ’$49,361’] |
| User: What is the difference in that amount if the discount rate had a 1% increase and a 1% decrease? |
| Instruction: If the user’s question is ambiguous, ask an appropriate clarifying question. Otherwise, directly answer the user’s question using the information from the passage context and the table. Let’s think step by step. |
| Reasoning: The user’s question is not ambiguous. Assistant: 49,361 - (39,145) = 88506<br>User: How much would the pension change if there is a 1% increase and a 1% decrease respectively? |
| Instruction: If the user’s question is ambiguous, ask an appropriate clarifying question. Otherwise, directly answer the user’s question using the information from the passage context and the table. Let’s think step by step. |
| Reasoning: The user’s question was ambiguous. |
| Assistant: [’Which rate of increase and decrease are you talking about?’] |

##### Chain-of-Thought Prompting

We integrate the popular reasoning framework, chain-of-thought prompting [] into our aforementioned “Standard” conversational prompt format. Effectively, we ask an LLM to do end-to-end dialogue generation by having it first produce a reasoning chain which states whether the current context is ambiguous or not. We provide an example in Table A14.

**Table A15: “Proactive Mixed-Initiative” in-context example given as part of a prompt to an LLM for response generation in PACIFIC. The purple text is the overall system instruction. The blue text is what an LLM would have to produce at inference time.**
| You are an Assistant answering questions from a User. You should either attempt to answer the question or ask a clarifying question if there is any ambiguity. |
| --- |
| $[$Table and Passage Omitted$]$ |
| User: How much does the company expect to make contributions to the defined plans during the next fiscal year? |
| The user’s last question was ambiguous. The Assistant asks a clarifying question. |
| Assistant: [’What kind of defined plans are you asking about?’] |
| User: The defined benefit plans and the defined contribution plan respectively. |
| The user’s last question was unambiguous. The Assistant directly answers the question. |
| Assistant: [’$5.1million^{\prime},^{\prime}$0.6 million’] |
| User: What is the value of the expected defined contribution plan as a percentage of the defined benefit plan during the next fiscal year? |
| The user’s last question was unambiguous. The Assistant directly answers the question. |
| Assistant: 0.6/5.1 = 11.76 |
| User: How much would change if there is a 1% increase and a 1% decrease respectively in the discount rate? |
| The user’s last question was ambiguous. The Assistant asks a clarifying question. |
| Assistant: [’What kind of change are you asking about?’] |
| User: The pension. |
| The user’s last question was unambiguous. The Assistant directly answers the question. |
| Assistant: [’$(39,145)^{\prime},^{\prime}$49,361’] |
| User: What is the difference in that amount if the discount rate had a 1% increase and a 1% decrease? |
| The user’s last question was unambiguous. The Assistant directly answers the question. |
| Assistant: 49,361 - (39,145) = 88506 |
| User: How much would the pension change if there is a 1% increase and a 1% decrease respectively? |
| Actions: [“Directly Answer”, “Ask a Clarification Question”] |
| Prompt: Given the task background and the conversation history, please use appropriate actions to generate the response. |
| Response: The user’s last question was ambiguous. The Assistant asks a clarifying question. |
| Assistant: [’Which rate of increase and decrease are you talking about?’] |

##### Proactive Mixed-Initiative Prompting

Following the baselines given in [], we apply the Proactive Prompting framework [] mixed with the Mixed-Initiative Prompting style []. Ultimately, the LLM conditions on the possible set of actions, along with interweaved natural language instructions that describe which actions correspond to existing dialogue turns. We provide an example in Table A15. We use this framework for each of the long-context dialogue corpora (PACIFIC and Abg-CoQA).

## Appendix E Conditional Generation Model Details

As mentioned Section 3.1, we make use of a high capacity LLM as a conditional generation model, $M$. For all experiments considered, we use Gemini Ultra 1.0 to construct the initial action-based contrastive preference dataset. We follow the format of “mixed-initiative prompting” described in [], rather than performing zero-shot inference, we use ten in-context examples to adapt the LLM to the prompting structure. Concretely, for a given input/output pair to be used as an in-context example, we interweave each System-side utterance with a narrative instruction that states that the next utterance is either a clarifying question or a direct answer. This yields “control” over the pragmatic action of the generated utterance.

## Appendix F Action Classifier Details

Compared to recognizing whether a request is ambiguous or not, action classification (i.e., recognizing whether an existing utterance is a question or answer attempt) is considerably simpler. We directly prompt Gemini Ultra 1.0 with 10 in-context examples to serve as $A$ (as per the notation given in Section 3.1).

**Table A16: In-context example given as part of a prompt to an LLM for action classification with PACIFIC. The blue text represents the action for this example.**
| $[$Table and Passage Omitted$]$ |
| --- |
| User: What was the total number of acquisitions in FY19? |
| Assistant: 35 acquisitions |
| User: What are the benefits of active growth strategy? |
| Assistant: strengthens and scales the National Storage operating platform which drives efficiencies across the business. |
| User: What was the total NLA? |
| Assistant: Which region are you asking about? |
| The last Assistant utterance is a clarifying question. |

Table A16 is an example of an in-context example used to demonstrate a system-side response with the “Clarify” action in PACIFIC (“Assistant: Which region are you asking about?”). All of the conversation history is made available in addition to the relevant table and passage in the prompt. We include all contextual information available as part of the input to the Action Classifier, along with the last Assistant response which is an example of the classification target.

**Table A17: In-context example given as part of a prompt to an LLM for action classification with Abg-CoQA. The blue text represents the action for this example.**
| $[$Passage Omitted$]$ |
| --- |
| User: And who in the group was anxious? |
| Assistant: Peppe |
| User: Was she well-rested? |
| Assistant: no |
| The last Assistant utterance is a direct answer. |

Table A17 is an example of an in-context example used to demonstrate a system-side response with the “Answer” action in Abg-CoQA (“Assistant: no”). As is common in this corpus, a subset of the conversation is made available in addition to the relevant passage in the prompt. We include all contextual information available as part of the input to the Action Classifier, along with the last Assistant response which is an example of the classification target.

**Table A18: In-context example given as part of a prompt to an LLM for action classification with AmbigSQL. The blue text represents the action for this example.**
| $[$Database Schema Omitted$]$ |
| --- |
| User: “Which professionals live in the state of Indiana or have done treatment on more than 2 treatments? List his or her id, last name and cell phone.” |
| Here is the same request converted into an ambiguous format by underspecifying the target columns: |
| Assistant:<br>SELECT professional_id , last_name , cell_number FROM Professionals<br>WHERE state = ’Indiana’ UNION SELECT T1.professional_id , T1.last_name ,<br>T1.cell_number FROM Professionals AS T1 JOIN Treatments AS T2 ON<br>T1.professional_id = T2.professional_id<br>GROUP BY T1.professional_id HAVING count(*) > 2<br>The last Assistant utterance is a direct answer. |

Table A18 is an example of an in-context example used to demonstrate a system-side response with the “Answer” action in AmbigSQL. In AmbigSQL, the information provided as input is the database schema, and the user’s initial information request. This information is provided as part of the input to the Action Classifier, along with the last Assistant response which is an example of the classification target.

## Appendix G User Simulator Details

In order to iterate on system-side dialogue models, many works investigate the use of a user simulator, $U$ (as per the notation given in Section 3.1) (e.g. [, , ]). At its core, it requires a response generation model which can robustly represent user-side intents. Traditionally, this involved training a model specifically on user-side responses but due to the aforementioned control capabilities of modern LLMs [], we directly perform few-shot prompting for user simulation, following [, ]. For a given conversation during training, we again prompt a high-capacity LLM with in-context examples to identify the information-seeking user intents. Then, conditioned on the generated information-seeking intents, we prompt the same LLM with the responses from the policy model to simulate the sub-goal trajectory. This allows $U$ to ground on the real intents of the user while retaining enough flexibility to respond coherently to some system-side response. In our work, we use Gemini Ultra 1.0 with three hand-crafted in-context examples for both intent summarization and user response generation.

**Table A19: In-context example given as part of a prompt to an LLM for intent summarization with PACIFIC. The purple text represents the system prompt used for this task. The blue text represents the summarized information-seeking intents.**
| The following is a conversation between a User and an Assistant. The User is asking some questions. Summarize what information the User is looking for. |
| --- |
| $[$Table and Passage Omitted$]$ |
| User: What does Walletron deliver? |
| Assistant: patented mobile wallet technology. |
| User: How much did it cost the company to acquire certain technology assets of RevChip, LLC ("RevChip") and TranSend Integrated Technologies Inc. ("TranSend")? |
| Assistant: $7.0 million |
| User: What was the pro forma revenue in 2019? |
| Assistant: $1,382,957 |
| User: What was the change in its amount between 2018 and 2019? |
| Assistant: 21228 |
| User: How about that in pro forma net income? |
| Assistant: -6425 |
| [Information] The user wants to know: 1. What technology Walletron delivers, 2. How much it cost Walletron to acquire certain technology assets of RevChip, LLC and TranSend Integrated Technologies Inc., 3. What the pro forma revenue was in 2019, 4. What the change in pro forma revenue was between 2018 and 2019, and 5. What the change in pro forma net income was between 2018 and 2019. |

##### PACIFIC

We provide one of our three handcrafted in-context examples of summarizing information-seeking intent in Table A19. While the information summary is handcrafted, the conversation and grounding data are taken directly from the PACIFIC. After intent summarization, $U$ is given the existing conversation history along with an instruction that includes the information seeking intents and asked to provide the next user response. This format is structurally the same as the three simulation-specific in-context examples — an example is provided in Table A20.

**Table A20: In-context example given as part of a prompt to an LLM for user simulation with PACIFIC. The purple text represents the system prompt used for this task, which contains the information-seeking intents summarized from Table A19. The entire conversation is used for this example to demonstrate grounding between a conversation and intents.**
| The following is a conversation between a User and an Assistant. The User is asking some questions. The user wants to know: 1. What technology Walletron delivers, 2. How much it cost Walletron to acquire certain technology assets of RevChip, LLC and TranSend Integrated Technologies Inc., 3. What the pro forma revenue was in 2019, 4. What the change in pro forma revenue was between 2018 and 2019, and 5. What the change in pro forma net income was between 2018 and 2019. |
| --- |
| $[$Table and Passage Omitted$]$ |
| Assistant: $7.0 million |
| User: What was the pro forma revenue in 2019? |
| Assistant: $1,382,957 |
| User: What was the change in its amount between 2018 and 2019? |
| Assistant: 21228 |
| User: How about that in pro forma net income? |
| Assistant: -6425 |

##### Abg-CoQA

We conduct user simulation for Abg-CoQA similarly to PACIFIC. Table A21 is one of three hand-crafted examples of intent summarization, and Table A22 is one of three hand-crafted examples used for simulating the final user response.

**Table A21: In-context example given as part of a prompt to an LLM for intent summarization with Abg-CoQA. The purple text represents the system prompt used for this task. The blue text represents the summarized information-seeking intents.**
| $[$Passage Omitted$]$ |
| --- |
| User: What was his ranking? |
| Assistant: General |
| User: Did someone else have horse fighters? |
| Assistant: yes |
| User: Who? |
| Assistant: Do you want to know who had 2,500 horse fighters initially? |
| User: No, I want to know who had a considerable force of horse fighters west of him. |
| Assistant: General (Bishop) Polk. |
| Instruction: Summarize what information the user is looking for. |
| Summary: The user wants to know: 1. What his ranking was. 2. Whether someone else had horse fighters. 3. Who had a considerable force of horse fighters west of him. |

##### AmbigSQL

We conduct user simulation slightly differently for AmbigSQL. Rather than having a separate step for knowledge-seeking intent summarization, we directly condition $U$ on the target SQL query. As demonstrated in Table A23, the prompt includes the target SQL query, the original user request, and the clarification question sampled from the Assistant. In the example given in Table A23, the last line is the ground truth disambiguated query, and in practice, this would be the generation target of $U$.

**Table A22: In-context example given as part of a prompt to an LLM for user simulation with Abg-CoQA. The purple text represents the system prompt used for this task, which contains the information-seeking intents summarized from Table A21. The entire conversation is used for this example to demonstrate grounding between a conversation and intents.**
| The following is a snippet from a conversation between an Assistant and a User who is asking some questions about the Story below. The user only wants to know the following information: 1. What his ranking was. 2. Whether someone else had horse fighters. 3. Who had a considerable force of horse fighters west of him. |
| --- |
| $[$Passage Omitted$]$ |
| User: What was his ranking? |
| Assistant: General |
| User: Did someone else have horse fighters? |
| Assistant: yes |
| User: Who? |
| Assistant: Do you want to know who had 2,500 horse fighters initially? |
| User: No, I want to know who had a considerable force of horse fighters west of him. |
| Assistant: General (Bishop) Polk. |

**Table A23: In-context example given as part of a prompt to an LLM for user simulation with AmbigSQL. The purple text represents the system prompt used for this task, which contains ground truth SQL query goal. The entire conversation is used for this example to demonstrate SQL query-grounded request disambiguation.**
| A user is asking an assistant to retrieve some information from a SQL database. The command that the assistant should ultimately return is as follows:<br>SELECT county FROM campuses where campus = ’California State University-Chico’<br>The assistant will ask some questions to clarify the user’s intent. The user should respond with a rephrased request that reflects their desired query. |
| --- |
| User: what is the county? |
| Assistant: Are you asking for a list of all of the counties in the database? |
| User: I’m looking for the county of the campus ’California State University-Chico’ |

## Appendix H Additional Qualitative Examples

Table A24 includes an erroneous trajectory produced by the ACT model in the 50 conversation setting of PACIFIC. In this particular example, both the provided passage and the provided table provided similar information regarding net profit/loss after tax. In the dataset, the ground truth answer selected a span from the passage, whereas the ACT model produced a clarification question and then eventually an answer using tabular information. The SFT model directly assumed the intent of the user and similarly produced an answer from the tabular information.

Table A25 includes another pair of erroneous trajectories in the 50 conversation setting of PACIFIC. The requested information was accessible through the provided table data, but both the SFT model and the ACT model failed to produce the correct answer. This example was not annotated as requiring a clarifying question, so it simply indicates that there is much room for improvement in terms of downstream task performance.

Table A26 includes a pair of trajectories resulting from SFT and ACT in the 50 conversation setting of Abg-CoQA. The requested information is given in the portion of the passage in the left panel. The SFT model asked an off-topic clarification question and failed to bring the qestioning on track. The ACT model successfully asked an on-track clarification question and eventually produced the correct answer.

Table: Table A24: Comparison of PACIFIC trajectories using different tuning approaches. Left: snippet of from a passage from the PACIFIC test set. Middle: trajectory resulting from the SFT model in response to the user query. Right: trajectory resulting from the ACT model. Red text: sampled from $U$. Both the SFT and ACT model answered the question incorrectly.

Table: Table A25: Comparison of PACIFIC trajectories using different tuning approaches. Left: snippet of from a passage from the PACIFIC test set. Middle: trajectory resulting from the SFT model in response to the user query. Right: trajectory resulting from the ACT model. Red text: sampled from $U$. Both the SFT and ACT model answered the question incorrectly, and neither asked a clarification question.

Table: Table A26: Comparison of Abg-CoQA trajectories using different tuning approaches. Left: snippet of a relevant passage from the Abg-CoQA test set. Middle: trajectory resulting from the SFT model in response to the user query. Right: trajectory resulting from the ACT model. Red text: sampled from $U$. Ground truth outcome: Meghan asked Lizzie,“Are you awake?”

## Appendix I Additional Experimental Details

### I.1 Compute Resources

We conduct all experiments using one Google Compute Engine Virtual Machine with 8x 80GB A100 GPUs. All of our tuning experiments use full-model multi-GPU tuning with Deepspeed. Full ACT with 250 conversations (1,923 training examples) from PACIFIC took the longest amount of time and required approximately 16 hours to run for 12 epochs.

Beyond the experiments reported in the paper, there were many preliminary experiments that took place as a part of this overall research project that were ultimately directionally different from our final contribution.

### I.2 Training Hyperparameters

For all of our SFT experiments, we tune the model for up to 8 epochs. We choose the best-performing model with learning rates from $\{1e-4,2e-5,1e-5\}$ with the AdamW optimizer.

For all of our RL tuning experiments, we allow the model to train for up to 12 epochs, and select the checkpoint that results in the highest reward margin on the validation set (which is an action-based preference dataset constructed as described in Section 3.2 using each task’s original validation set). For all experiments, we use a batch size of 4, and a maximum sequence length of $1,280$.

##### Hyperparameters for Equation 2

For experiments with Zephyr 7B on PACIFIC, we achieve our strongest results using $\beta=0.01$ and a learning rate of $5e-7$. On AmbigSQL, we use $\beta=0.01$ and a learning rate of $5e-7$. On AmbigSQL, we use $\beta=0.5$ and a learning rate of $5e-7$.

## Appendix J Assets Used

All resources used have been cited appropriately in the paper. In this section, we enumerate each of the existing artifacts used in our work along with their license.

Existing Models

- •
Gemma []: Gemma Open-Source License. [https://ai.google.dev/gemma/terms](https://ai.google.dev/gemma/terms)
- •
Gemini Ultra 1.0 and Gemini Pro 1.5 (gemini-1.5-pro-preview-0409)  []: Accessed through the Google Cloud Vertex AI Platform. [https://cloud.google.com/products/gemini?hl=en](https://cloud.google.com/products/gemini?hl=en)
- •
MiniLM-L6-v2 []: Apache 2.0. [https://huggingface.co/sentence-transformers/all-MiniLM-L6-v2](https://huggingface.co/sentence-transformers/all-MiniLM-L6-v2)
- •
Mistral 7B-v0.1 []: Apache 2.0. [https://huggingface.co/mistralai/Mistral-7B-v0.1](https://huggingface.co/mistralai/Mistral-7B-v0.1)
- •
Zephyr 7B-$\beta$ (with Mistral 7B as a Base Model) []: MIT Open-Source License. [https://huggingface.co/HuggingFaceH4/zephyr-7b-beta](https://huggingface.co/HuggingFaceH4/zephyr-7b-beta)

Existing Datasets

- •
Abg-CoQA []: MIT Open-Source License. [https://github.com/MeiqiGuo/AKBC2021-Abg-CoQA](https://github.com/MeiqiGuo/AKBC2021-Abg-CoQA)
- •
PACIFIC []: MIT Open-Source License. [https://github.com/dengyang17/PACIFIC/tree/main](https://github.com/dengyang17/PACIFIC/tree/main)
- •
Spider []: CC BY-SA 4.0. [https://yale-lily.github.io/spider](https://yale-lily.github.io/spider)

Existing Algorithms and Software

- •
Direct Preference Optimization []: CC BY 4.0.
- •
Google Cloud Pipeline Components: Apache 2.0. [https://cloud.google.com/vertex-ai/docs/pipelines/components-introduction](https://cloud.google.com/vertex-ai/docs/pipelines/components-introduction)
- •
HuggingFace Transformers []: Apache 2.0. [https://github.com/huggingface/transformers/tree/main](https://github.com/huggingface/transformers/tree/main)
- •
PyTorch []: PyTorch Open Source License. [https://github.com/pytorch/pytorch/tree/main](https://github.com/pytorch/pytorch/tree/main)
- •
Vertex AI SDK: Apache 2.0. [https://cloud.google.com/vertex-ai/docs/python-sdk/use-vertex-ai-python-sdk](https://cloud.google.com/vertex-ai/docs/python-sdk/use-vertex-ai-python-sdk)

## Peer Reviews

confidence: 2
contribution: 3
initial_rating: 8
presentation: 3
questions: None
soundness: 3
strengths: 1. This paper proposes a feasible way to optimizing multi-turn conversation modeling for LLMs, which overcome some obstacles faced by existing methods.
2. Their proposed method ACT is sample-efficient based on online DPO, and achieves good performance on three real-world conversational tasks. 
3. The paper is well-written and the experiments are convincing.
summary: This paper proposes a novel online optimization algorithm: action-based contrastive self-training, which facilitates data-efficient dialogue policy learning for modeling multi-turn conversation. The authors demonstrate their method on multiple real-world conversational tasks: tabular-grounded QA, machine reading comprehension and AmbigSQL. They also propose a way to evaluate LLM's ability to function as conversational agents. Their method ACT achieves substantial improvements than DPO and other baselines.
weaknesses: This paper conducts experiments on limited applications of dialogue tasks; there are also many variants for DPO based methods, however, the authors have not compared them as baselines.

---

confidence: 5
contribution: 3
initial_rating: 6
presentation: 3
questions: see above
soundness: 3
strengths: 1. This paper is clear in writing. It is easy to understand the proposals and experiments. 
2. Diversified tasks of the evaluation datasets. I recognize the efforts author made to experiment on different tasks (e.g. SQL, tableQA etc.)
summary: The paper introduces Action-Based Contrastive Self-Training (ACT), an algorithm designed to enhance large language models' (LLMs) ability to handle ambiguity in multi-turn conversations. Current LLM-based conversational agents often fail to ask clarifying questions when faced with ambiguous input, opting instead to overhedge or guess the user's intent. ACT addresses this by enabling data-efficient dialogue policy learning through contrasting different conversational actions, even without explicit action labels, using a preference optimization approach based on Direct Preference Optimization (DPO).

The authors demonstrate ACT's effectiveness across several real-world tasks, including tabular-grounded question answering, machine reading comprehension, and AmbigSQL—a new task focused on disambiguating complex SQL queries. Their experiments show that ACT outperforms standard tuning methods like supervised fine-tuning and DPO, particularly in scenarios with limited data. Additionally, the paper proposes a workflow for evaluating LLMs' ability to recognize and reason about ambiguity in conversations. The results suggest that incorporating action-based preferences via ACT enhances LLMs' performance in modeling multi-turn dialogues and improves their conversational skills.
weaknesses: 1. The biggest weakness of the paper should be the choice of weak baselines and this japardizes the contributions claims of the paper. 
One paper on the top of my head is https://arxiv.org/pdf/2404.19733. This paper has many identical settings: online sampling and a heuristic to filter trajectories. I believe this paper should be a baseline to compare. 
Maybe the authors have similar ablation comparisons in Table 6. I would like to see some clear discussions on the baselines and ablations. 


2. Related to weakness 1, this paper doesn't discuss DPO variants built for tasks that require multi-step trajectories. This paper is proposing a new DPO algorithm but it has a very small section to discuss relevant DPO works. I would suggest the authors check into DPOs for conversational tasks or reasoning tasks that require COT. This will provide a more justified view of the paper contributions.

---

confidence: 3
contribution: 3
initial_rating: 8
presentation: 3
questions: Figure 3 was critical to my understanding of your approach. It would help the text to label figure 3 with the notation used in the text, and to refer to specific parts of the figure in the text to better connect the two. Without the figure I would have been completely lost in section 3. 

I found all of the sections on "conversations in the wild" difficult to follow and kind of disconnected from the rest of the text. Can you clarify what specific problem you are trying to address with these tests?

In Algorithm 2 you say (line 14-16) that the _trajectory_ is assigned to the winning or losing labels--but in the text it is just the sampled y_j that is assigned to these depending on the conversation outcome. These should me made consistent with each other.

I would like to see details of the user simulator U and action classifier A in the main text. Making your text less wordy and shortening the tables to just the key results will help make room to discuss these critical pieces more. The other results from the tables, and things like the ablations, can be expounded on more fully in the appendices. That's what appendices are for: extra results and things that don't turn out to be as interesting. 

You could also omit most or all of the DPO-Dist results from the main text--it never gets close to the best results. You can mention this in the main text and then detail it more in the appendices.

Line 304: How do you guarantee that the responses from Gemini Ultra model M _should_ be rejected? Won't it often come up with a good response?

Line 313: I admit I haven't focused on this aspect for some time, but surely there's something better than SentenceBERT for evaluation now?

Line 354: why switch metrics between datasets? Why not just stick with F1, even though your AmbigSQL dataset is balanced? It seems like being consistent would help us get a better sense of how challenging (or not) the AmbigSQL dataset is. 

Lines 425-427: ACT does better than frontier LLMs when it has 250 examples to learn from. I assume these are generated examples, and therefore you don't need human labeling. It makes me wonder (1) how much does this depend on the models you use being updated with human labeled data (since, if I understand correctly, the success of the method does depend on prior model alignment) and (2) why not try with more examples than 250?

Line 448: It seems odd to me that ACT outperforms Zephyr SFT on the overall trajectory outcome but not action recognition. Does the A model show bias somehow to prefer asking clarifying questions? 

Line 527: this paragraph can just be a single sentence--just tell us prior alignment was helpful and how much, don't need to discuss more.

Finally, there wasn't much (any?) discussion of the limitations of user simulations. In particular, I always worry that humans are less predictable than simulations--how might this affect your results?
soundness: 4
strengths: First and foremost, the authors present extensive comparisons showing that their approach leads to better conversational outcomes, both in terms of recognizing the need to clarify a user prompt, and in resolving the user's information need. The difference is sometimes quite large, with 10-20% improvements over SFT or a modified DPO approach. It is a significant result, showing that off-policy learning techniques can be bested by even this quasi-online learning approach. While not alone in finding this, the authors make an important contribution to showing the limits of off-policy learning and the result is timely as more and more effort is focused on trying to get better performance out of more reasonably sized models. The addition of the new AmbigSQL data set should prove useful as it is more easily evaluated automatically.
summary: The authors present ACT, a framework for fine-tuning LLMs to respond better to ambiguous queries. The approach relies on online preference optimization, using a DPO-like objective, where the user responses and action classifications are provided by some other LLM user simulation and a trained action classifier, and the agent responses are provided by the model under tuning. The authors design a particular, detailed approach to generating conversational examples from which the model learns, and show that it is highly effective and with relatively few examples enables mid-size (~7B parameters) LMs to outperform very large LLMs even with 10 examples in their prompts. Finally, the authors provide a new dataset of ambiguous queries that are resolved to SQL queries, again showing that the ACT framework provides better results by learning to ask clarifying questions.

Updated ratings after reading author responses. In particular the presentation has improved and the paper is easier to understand. Thank you to the authors for their efforts.
weaknesses: The paper is probably over-stuffed with results, and is generally very wordy making it difficult to read. It is saved by the clear algorithms and figures, but the text should be shortened considerably. This would also allow for more discussion of the AmbigSQL data set, which is a significant contribution, but which is barely described in the text. As an example, I found that the first three sentences of the paragraph at L350 ("Implicit Ambiguity Recognition") all say essentially the same thing. This could be shortened to make room for more informative text. Similarly, I don't know that we need to see every possible result in the main results tables. Focus on the main results/models to tell your story, and omit the rest to make the tables easier to read. I didn't find the ablation experiments useful in this case--you could have summarized the entire section in one short paragraph. 

The AmbigSQL data might be too easy to learn, as some models achieve near perfect performance on it.

The paper is novel, but not exceptionally so. One thing you could do after shortening the rest of the paper is to consider the use of user simulators more, and find parallels between earlier work and yours. I think the novelty of the paper lies mostly in the exact implementation of data generation for preference optimization, summarized in Algorithm 1 and Figure 3, and it would be good to focus on that specifically.

---

confidence: 3
contribution: 3
initial_rating: 5
presentation: 2
questions: - Why is the SFT results reported in Table 1 and 2 do not improve with more data? Can you try a cross validation split?
soundness: 2
strengths: Originality 
The paper proposes a novel DPO algorithms for handle ambiguity, which to the best of my knowledge is novel in this settings.

Clarity 
The paper is overall clear (Algorithm 2 is pretty helpful to understand the overall process).
summary: The paper proposes Action-Based Contrastive Self-Training (ACT), to improve large language models' (LLMs) conversational skills, particularly in handling ambiguity and learning optimal dialogue policies. The paper shows results in three conversational tasks, including tabular-grounded question answering, machine reading comprehension, and text-to-SQL generation, highlighting the importance of considering action-based preferences for conversational tasks.
weaknesses: Significance
Low overall significance. The experiments focus on a specific sub-domain of dialogue systems (SQL-based), and a particular skill, which larger language model already posses. Moreover, the results focus on a single LLM, and report dubious SFT performance. This diminish the significance of the proposed approach.

Meta-review: This paper presents Action-Based Contrastive Self-Training (ACT), a framework for fine-tuning LLMs to address ambiguity in multi-turn conversations. The approach leverages a preference optimization objective, building on DPO, to contrast different conversational actions without requiring explicit action labels. ACT is demonstrated on tasks including tabular-grounded question answering, machine reading comprehension, and AmbigSQL, a new dataset designed for disambiguating SQL queries. The paper also introduces a workflow for evaluating LLMs' ability to handle ambiguity in dialogues.

The strengths of the paper are:

1. The paper introduces a novel online DPO method, ACT, which demonstrates sample efficiency and effectively addresses challenges in multi-turn conversational modeling for LLMs.
2. The authors provide experimental results across various conversational tasks, including SQL and TableQA, showing some performance improvements, e.g., in some cases 10–20% over existing methods like SFT and modified DPO.
3. The inclusion of the new AmbigSQL dataset could be a valuable resource to the field, enabling more straightforward automated evaluation and furthering research on handling ambiguity in conversational tasks.

As the paper has been extensively extended during the author response period, I will focus on the concerns that seem to remain in the current version:

1. While the authors provided clarifications on their DPO method and highlighted its focus on conversational modeling improvements, the method of the paper doesn't seem very creative or original. It is yet another variant of DPO aimed at a particular goal (clarifying question optimization).

 2. Experimental results: The most compelling results seem to be on the PACIFIC dataset, but this dataset is small and domain-specific (finance). The models evaluated in this work are quite small scale, not going beyond 7B. The experiments shown in the paper rely on 250 conversations or less, but without data scaling curves, it is more difficult to appreciate the contribution of the proposed method. As sample training size is small for all the experiments, it would be important to show mean and variance across different runs.

During the reviewer–AC discussion period, most reviewers sided with accepting the paper, but the dissenting reviewer kept their rating at 5 and expressed concerns about the experiments (see weakness 2, which is mostly a paraphrase of their points). I think this reviewer makes valid points, and the authors should seriously consider their concerns for the next version of the paper. However, I think these concerns are not serious enough to override the other reviewers' consensus to accept, so I recommend acceptance.

Decision: Accept (Poster)