No that’s not what I meant: Handling Third Position Repair in Conversational Question Answering (2023)

Abstract: The ability to handle miscommunication is crucial to robust and faithful conversational AI. People usually deal with miscommunication immediately as they detect it, using highly systematic interactional mechanisms called repair. One important type of repair is Third Position Repair (TPR) whereby a speaker is initially misunderstood but then corrects the misunderstanding as it becomes apparent after the addressee’s erroneous response. Here, we collect and publicly release REPAIR-QA, the first large dataset of TPRs in a conversational question answering (QA) setting. The data is comprised of the TPR turns, corresponding dialogue contexts, and candidate repairs of the original turn for execution of TPRs. We demonstrate the usefulness of the data by training and evaluating strong baseline models for executing TPRs. For stand-alone TPR execution, we perform both automatic and human evaluations on a fine-tuned T5 model, as well as OpenAI’s GPT-3 LLMs. Additionally, we extrinsically evaluate the LLMs’ TPR processing capabilities in the downstream conversational QA task. The results indicate poor out-of-the-box performance on TPR’s by the GPT-3 models, which then significantly improves when exposed to REPAIR-QA.

## introduction participants in conversation need to work together on a moment by moment basis to achieve shared understanding and coordination @xcite @xcite @xcite . one of the key interactional mechanisms that enables this is called repair @xcite -see fig. 1 : a set of universal, highly systematised @xcite , local methods for dealing with miscommunication as it is detected. miscommunication likewise arises in humanmachine conversation. therefore, the ability to interpret and generate effective repair sequences is crucial to robust conversational ai technology, and to ensuring that natural language understanding (nlu) output and/or subsequent system responses remain faithful to what the user intended. considerable attention has been paid to computational models for the interpretation and generation of self-repair (see @xcite @xcite @xcite among others): a class of repairs whereby the speaker corrects themselves on the fly within the same conversational turn (e.g. "user: i want to go to london uhm sorry paris"). similarly, the crucial role of generating and responding to clarification requests (e.g. "pardon/what/who?") in conversational models has long been recognised (see @xcite @xcite @xcite among others), but existing systems either remain limited (e.g. @xcite ) or do not support this at all -see @xcite for an overview of existing models of repair. in this paper, we focus on an important class of repairs that has, to our knowledge, been neglected in the nlp community, likely due to the unavail-ability of data: third position repair (tpr; @xcite ; aka repair after next turn). these occur when the addressee initially misunderstands the speaker (fig. 1 at t1, the trouble source turn), responds based on this misunderstanding (at t2), which in turn reveals the misunderstanding to the addressee who then goes on to correct the misunderstanding (at t3). our contributions are: (1) we collect, analyse and release repair-qa, the first large dataset of third position repairs (tpr) in a conversational qa setting together with candidate repair outcomes (rewrites) for training repair execution models; and (2) we then use repair-qa to: (a) train and intrinsically evaluate strong baseline models for the execution of tprs; and (b) systematically probe the tpr processing capabilities of gpt-3-curie and gpt-3-davinci with and without exposing them to examples from repair-qa. ## the repair-qa dataset in this section, we describe our method for eliciting third position repairs (tpr) from amt crowd workers (henceforth annotators). overall, we set this up as a dialogue completion task whereby the annotators are given a dialogue snippet in which a miscommunication has occurred: they are given t1 (fig. 1 ; the trouble source) and t2 (the erroneous system response). they are then asked to provide a (third position) correction at t3 to resolve the miscommunication. method: eliciting tprs we built our dialogue completion tasks on amazon mechanical turk (amt). annotators were paid @xmath011 per hour). to generate the dialogue completion tasks in order to elicit tprs, we start from the ambigqa dataset @xcite since it contains ambiguous questions (i.e. questions that have multiple interpretations and answers) and their corresponding unambiguous questions along with their answers. for each ambiguous question, q, and the corresponding pair of unambiguous questions with their answers, (q 1 , a 1 ) and (q 2 , a 2 ), we build a dialogue snippet to be completed by the annotator with a tpr as follows: (1) we build an informative context, c, that differentiates between questions q 1 and q 2 ; (2) the answers in ambigqa are mostly short, noun phrase answers, which do not reveal how the ambiguous question was interpreted or reveal the apparent miscommunication to the annotator. to remedy this, we transform these short answers to full sentential form using the rule-based approach of @xcite . this allows us to derive sentential forms for a 1 , call it a ′ 1 ; statistics and quality control the repair-qa dataset consists of 3305 examples (training: 2657, test: 648) which are chosen and annotated from the 4749 examples from the ambigqa dataset. each conversation in repair-qa consists of two different tprs yielding a total 6610 tpr annotations. limitations as such, repair-qa has two important limitations: (1) tprs can in general sometimes -but rarely -occur at a distance of more than two turns from the trouble-source turn @xcite . but the tprs we collected are always in the third turn following the trouble source: this is an artefact not just of our data collection design as a unilateral dialogue completion task, but also of the architecture of most conversational qa models that repair-qa is designed to be useful for; and ## tpr execution we cast the tpr execution task as a sequence to sequence problem, where input to the model is the dialogue history up to and including the tpr turn, and the model is trained to generate a rewrite of the ambiguous, trouble-source question, reflecting the correction in the tpr. we use a pre-trained t5 model @xcite for our experiments and compare against openai's gpt-3 (brown et al., 2020) when prompted with tpr examples. ## extrinsic evaluation of gpt-3's tpr capabilities in conversational qa in this section, we use repair-qa to evaluate the tpr processing capabilities of openai's gpt-3 davinci model extrinsically in an end-to-end, conversational qa setting. we do this by comparing: prompting bleu em unknown w/o tpr examples 11.40 11.71% 230 with tpr examples 16.98 31.90% 57 if (a) and (b) are identical or highly similar, we can infer that the model was able to interpret the tpr correctly; independently of whether the responses are faithful. we compute the automatic evaluation on the model's response in (b) while treating the model's response in (a) as the ground truth. this would evaluate if the model was consistent in generating responses for both the rewrite and the tpr dialogue snippet. this evaluation is performed under two prompting conditions: with tpr examples: where the model is exposed to 10 tpr examples in the prompt; and; without tpr examples: where the model is prompted without any tpr examples. in both conditions, the preamble instructs davinci to generate unknown as the answer if the question is either nonsense, trickery, or davinci has no clear answer. in addition, in both cases, the model is instructed to provide short form, noun phrase answers (for details of all of the preambles used, see appendix, sec. c). there could in general be two reasons for unknown predictions after a tpr: (i) the davinci's closed-book knowledge is insufficient to answer the (disambiguated, corrected) question; or; (ii) it was unable to interpret the tpr sequence. since we are interested only in (ii), we exclude all cases where the model was not able to answer the unambiguous question (i.e case (a) above), viz. the reference rewrite (the meaning of the tpr). this way we ensure that the model can actually answer the target, rewritten / corrected question. after these are excluded, the 'unknown' column in for cases where both (a) and (b) above receive answers from gpt3, we perform automatic evaluation to measure the similarity between them: this is also shown in as is evident in even when the model is exposed to tpr sequences in the prompt (the "with tpr examples" condition) the model's performance still leaves a lot to be desired: the model's responses to the tprs matches the expected response only in 31.9% of cases. to verify the meaningfulness of the 31.9% exact match and the corresponding low bleu score of 16.98 between model responses in (a) and (b), we went on to do a manual inspection of the data. ---------------------- user: who created the quote keep calm and carry on? system: british government tpr: i wanted to know the name of the ministry though. rewrite: which ministry created the quote keep calm and carry on? response to ( a we can see different answers when prompted with the dialogue including the tpr ((b) above) and when prompted with the rewrite (unambiguous form of the input; (a) above). such inconsistent answers are frequent from the model even when repair-qa examples are provided in the prompt. for more certainty, we further computed more focused bleu scores only in cases where there was no exact match between the model's responses in (a) and (b). the bleu scores on these not exactly matching responses, with and without exposure to tpr examples were 8.81 and 8.08 respectively. this shows that the model provides different, inconsistent answers for a large part of the repair-qa dataset even when exposed to tpr examples in the prompt; which in turn shows that the model is not able to interpret or integrate the tpr for too large a part of repair-qa. on a very small proportion of cases, davinci provides responses which are similar (usually a partial match as in the second example above: "british ministry of information" vs. "ministry of information"), which is captured by the bleu score metric. ## conclusion the ability to interpret and generate repairs is essential to robust and faithful conversational ai. in this paper, we focused on third position repair (tpr) that's been largely neglected in the nlp community. we collect, analyse and release the first large dataset of tprs and use it to evaluate strong baseline repair execution models, as well as the conversational qa performance of open ai's davinci model when it encounters tprs. the results show very poor out-of-the-box performance on tprs which then improves when the model is exposed to repair-qadataset. but even then, davinci does not exhibit an acceptable performance on tprs when evaluated end to end in a conversational qa setting. this is a symptom of the sparsity of tprs in the original dialogic data used to pretrain davinci and llms in general; and suggests that llm researchers should be more selective in how they compile the datasets used for pretraining. for this paper, we did not have a chance to evaluate later releases of llms (e.g. gpt3.5; gpt4) -it would be telling to see how much performance improvement the later models might exhibit on tprs. our evaluation methods above in conjunction with the repair-qa dataset can be used easily to perform these evaluations. finally, we hope that this paper inspires further computational research into miscommunication phenomena in dialogue in the context of recent astonishing successes with llms.