Unsupervised Question Decomposition for Question Answering (2020)

Abstract: We aim to improve question answering (QA) by decomposing hard questions into simpler sub-questions that existing QA systems are capable of answering. Since labeling questions with decompositions is cumbersome, we take an unsupervised approach to produce sub-questions, also enabling us to leverage millions of questions from the internet. Specifically, we propose an algorithm for One-to-N Unsupervised Sequence transduction (ONUS) that learns to map one hard, multi-hop question to many simpler, single-hop sub-questions. We answer sub-questions with an off-the-shelf QA model and give the resulting answers to a recomposition model that combines them into a final answer. We show large QA improvements on HotpotQA over a strong baseline on the original, out-of-domain, and multi-hop dev sets. ONUS automatically learns to decompose different kinds of questions, while matching the utility of supervised and heuristic decomposition methods for QA and exceeding those methods in fluency. Qualitatively, we find that using sub-questions is promising for shedding light on why a QA system makes a prediction.

## introduction it has been a long-standing challenge in ai to answer questions of any level of difficulty @xcite . question answering (qa) systems struggle to answer complex questions such as "what profession do h. l. mencken and albert camus have in common?" since the required information is scattered in different places @xcite . however, qa systems accurately answer simpler, related questions such as "what profession does h. l. mencken have?" and "who was albert camus?" @xcite . thus, a promising strategy to answer hard questions is divide-and-conquer: decompose a hard question into simpler sub-questions, answer the sub-questions with a qa system, and recompose the resulting answers into a final answer, as shown in figure 1 . this approach leverages strong performance on simple questions to help answer harder questions @xcite . existing work decomposes questions using a combination of hand-crafted heuristics, rule-based algorithms, and learning from supervised decompositions @xcite , which each require significant human effort. for example, decomprc @xcite decomposes some questions using supervision and other questions using a heuristic algorithm with fine-grained, special case handling based on part-onus ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? pseudo decomp. hard question simple question of-speech tags and over 50 keywords. prior work also assumes that sub-questions only consist of words from the question, which is not always true. decomposing arbitrary questions requires sophisticated natural language generation, which often relies on many, high-quality supervised examples. instead of using supervision, we find it possible to decompose questions in a fully unsupervised way. we propose an algorithm for one-to-n unsupervised sequence transduction (onus) that learns to map from the distribution of hard questions to that of many simple questions. first, we automatically create a noisy "pseudo-decomposition" for each hard question by using embedding similarity to retrieve sub-question candidates. we mine over 10m possible sub-questions from common crawl with a classifier, showcasing the effectiveness of parallel corpus mining, a common approach in machine translation @xcite , for qa. second, we train a decomposition model on the mined data with unsupervised sequence-to-sequence learning, allowing onus to improve over pseudo-decompositions. as a result, we are able to train a large transformer model to generate decompositions, surpassing the fluency of heuristic/extractive decompositions. figure 2 overviews our approach to decomposition. we validate onus on multi-hop qa, where questions require reasoning over multiple pieces of evidence. we use an off-the-shelf single-hop qa model to answer decomposed sub-questions. then, we give sub-questions and their answers to a recomposition model to combine into a final answer. we evaluate on three dev sets for hotpotqa, a standard benchmark for multi-hop qa @xcite , including two challenge sets. onus proves to be a powerful tool for qa in the following ways. first, qa models that use decompositions outperform a strong roberta baseline @xcite ) by 3.1 points in f1 on the original dev set, 10 points on the out-of-domain dev set from @xcite , and 11 points on the multi-hop dev set from @xcite . our method is competitive with state-of-the-art methods sae @xcite and hgn @xcite that use additional, strong supervision on which sentences are relevant to the question. second, our analysis shows that sub-questions improve multi-hop qa by using the single-hop qa model to retrieve question-relevant text. qualitative examples illustrate how the retrieved text adds a level of interpretability to otherwise black-box, neural qa models. third, onus automatically learns to generate useful decompositions for all four question types in hotpotqa, highlighting the general nature of onus over prior work, such as ibm watson @xcite and decomprc @xcite , which decompose different question types separately. without finetuning, our trained onus model can even decompose some questions in visual qa @xcite and knowledge-base qa @xcite , as well as claims in fact verification @xcite , suggesting promising future avenues in other domains. ## method we now formulate the problem and describe our high-level approach, with further details in §3. the goal of this work is to leverage a qa model that is accurate on simple questions for answering hard questions, without using annotated question decompositions. here, we consider simple questions to be "single-hop" questions that require reasoning over one paragraph or piece of evidence, and we consider hard questions to be "multi-hop." our aim is to train a multi-hop qa model m to provide the correct answer a to a multihop question q about a given context c (e.g., several paragraphs). normally, we would train m to maximize log p m (a|c, q). to facilitate learn-ing, we leverage a single-hop qa model that may be queried with sub-questions s 1 , . . . , s n , whose "sub-answers" a 1 , . . . , a n may be given to m . m may then maximize the potentially easier objective log p m (a|c, q, [s 1 , a 1 ], . . . , [a n , s n ]). supervised decomposition models learn to map each question @xmath0; . . . ; s n ] of n sub-questions s @xmath1, d) examples. in this work, we do not assume access to strong (q, d) supervision. to leverage the single-hop qa model without supervision, we follow a three-stage approach: 1) map a question q into sub-questions s 1 , . . . , s n via unsupervised techniques, 2) find sub-answers a 1 , . . . , a n with the single-hop qa model, and 3) use s 1 , . . . , s n and a 1 , . . . , a n to predict a. ## experimental setup we now detail the implementation of our approach. ## results on question answering we compare variants of our approach that use different learning methods and different pseudodecomposition training sets. as a baseline, we compare roberta with decompositions to roberta without decompositions. we use the best hyperparameters for the baseline to train our roberta models with decompositions (see appendix §d.3 for hyperparameters). we report results on 3 dev set versions: (1) the original version, 9 (2) the multi-hop version from jiang and bansal (2019a) who created some distractor paragraphs adversarially to test multi-hop reasoning, and (3) the out-of-domain (ood) version from @xcite who retrieved distractor paragraphs with the same procedure as the original version but excluded the original paragraphs. ## analysis to better understand our system, we now analyze our pipeline by examining the model for each stage: decomposition, single-hop qa, and recomposition. ## related work answering complex questions has been a longstanding challenge in natural language processing. prior work explored decomposing questions with supervision and heuristic algorithms. ibm watson @xcite decomposes questions into sub-questions in multiple ways or not at all. decomprc @xcite largely frames subquestions as extractive spans of a question, learning to predict span-based sub-questions via supervised learning on human annotations. in other cases, de-comprc decomposes a multi-hop question using a heuristic algorithm or not at all. watson and de-comprc use special case handling to decompose different questions, while our algorithm is fully automated and requires little hand-engineering. more traditional, semantic parsing methods map questions to compositional programs, whose subprograms can be viewed as question decompositions in a formal language @xcite . examples include classical qa systems like shrdlu @xcite and lunar @xcite , as well as neural seq2seq semantic parsers @xcite and neural module networks @xcite . such methods usually require strong, program-level supervision to generate programs, as in visual qa @xcite and on hotpotqa @xcite . some models use other forms of strong supervision, e.g., the sentences needed to answer a question, as annotated by hotpotqa. such an approach is taken by sae @xcite and hgn @xcite , whose methods may be combined with ours. unsupervised decomposition complements strongly and weakly supervised decomposition approaches. our unsupervised approach enables methods to leverage millions of otherwise unusable questions, similar to work on unsupervised qa @xcite . when decomposition examples exist, supervised and unsupervised learning can be used in tandem to learn from both labeled and unlabeled examples. such semi-supervised methods outperform supervised learning for tasks like machine translation @xcite . other work on weakly supervised question generation uses a downstream qa model's accuracy as a signal for learning to generate useful questions. weakly supervised question generation often uses reinforcement learning @xcite @xcite @xcite , where an unsupervised initialization can greatly mitigate the issues of exploring from scratch @xcite . ## conclusion we proposed a qa system that answers a question via decomposition, without supervised question decompositions, using three stages: (1) decompose a question into many sub-questions using one-to-n unsupervised sequence transduction (onus), (2) answer sub-questions with an off-the-shelf qa system, and (3) recompose sub-answers into a final answer. when evaluated on three hotpotqa dev sets, our approach significantly improved qa over an equivalent model that did not use decompositions. our approach relies only on the final answer as supervision but works as effectively as state-ofthe-art methods that rely on much stronger supervision, such as supporting fact labels or example decompositions. we found that onus generates fluent sub-questions whose answers often match the gold-annotated, question-relevant text. overall, this work opens up exciting avenues for leveraging methods in unsupervised learning and natural language generation to improve the interpretability and generalization of machine learning systems.