ReQA: An Evaluation for End-to-End Answer Retrieval Models

TL;DR

ReQA introduces a new benchmark for evaluating end-to-end answer retrieval models at scale, emphasizing the importance of scalable, sentence-level retrieval methods beyond traditional passage-based QA.

Contribution

The paper presents ReQA, a novel benchmark for large-scale answer retrieval, and provides baseline evaluations using neural and classical retrieval techniques.

Findings

Baseline neural models show competitive performance.

Classical retrieval methods remain effective for large-scale retrieval.

ReQA facilitates future research in scalable answer retrieval.

Abstract

Popular QA benchmarks like SQuAD have driven progress on the task of identifying answer spans within a specific passage, with models now surpassing human performance. However, retrieving relevant answers from a huge corpus of documents is still a challenging problem, and places different requirements on the model architecture. There is growing interest in developing scalable answer retrieval models trained end-to-end, bypassing the typical document retrieval step. In this paper, we introduce Retrieval Question-Answering (ReQA), a benchmark for evaluating large-scale sentence-level answer retrieval models. We establish baselines using both neural encoding models as well as classical information retrieval techniques. We release our evaluation code to encourage further work on this challenging task.

Tables

Table 1. Table 1: The number of questions and candidates in the constructed datasets ReQA SQuAD and ReQA NQ.

	SQuAD	NQ
Questions	87,599	74,097
Candidate Sentences	91,707	239,013
Candidate Paragraphs	18,896	58,699

Table 2. Table 2: Token-level statistics of the constructed datasets. Average Length is the average number of tokens in the question and sentence-level answer text. Query Coverage is the percentage of tokens in the question that also appear in the sentence-level answer.

	SQuAD	NQ
Average Length (tokens)
Question	10.1	9.1
Answer	24.0	22.9
Query Coverage (%)
Mean	31.7	24.3
Standard Deviation	18.9	16.9

Table 3. Table 3: The distribution of question types in ReQA SQuAD and ReQA NQ. A question is assigned to a question type if it starts with the question type word. Note, types what and which include questions where a preposition (e.g.  at, by, in, on, with ) appears before the wh- word.

Question Type	SQuAD	NQ
what	47.7	15.3
who	9.6	32.6
how	9.3	5.0
when	6.2	20.3
which	5.5	2.0
where	3.8	13.1
why	1.4	0.6
other	16.5	11.1

Table 4. Table 4: Mean reciprocal rank (MRR) and recall@K performance of neural baselines on ReQA SQuAD and ReQA NQ.

Model	MRR	R@1	R@5	R@10
ReQA SQuAD
USE-QA	0.539	0.439	0.656	0.727
QALite	0.412	0.325	0.507	0.576
InferSent	0.317	0.240	0.402	0.468
ReQA NQ
USE-QA	0.234	0.147	0.317	0.391
QALite	0.172	0.103	0.233	0.297
InferSent	0.080	0.043	0.109	0.145

Table 5. Table 5: Time and space tradeoffs of different models. Latency was measured on an Intel Xeon CPU E5-1650 v3 @ 3.50GHz, which has 6 cores and 12 threads.

Model	Size	Latency121212This is the latency for encoding a single piece of text. However, by batching the encoding requests, it’s possible to significantly reduce the amortized encoding time. In practice, batch sizes of 200 provide an amortized speedup of up to 5x.	Memory
	(MB)	(ms)	(MB)
USE-QA	392.9	17.3	71.8
QALite	2.6	10.2	3.6

Table 6. Table 6: Performance of various models on paragraph-level retrieval.

Model	MRR	R@1	R@5	R@10
ReQA SQuAD
USE-QA	0.634	0.533	0.756	0.823
QALite	0.503	0.407	0.613	0.689
InferSent	0.369	0.279	0.469	0.548
BM25151515BM25 statistics were computed over the first 10,000 questions of each dataset, due to slow scoring speed.	0.602	0.517	0.702	0.755
ReQA NQ
USE-QA	0.366	0.247	0.486	0.578
QALite	0.274	0.177	0.366	0.450
InferSent	0.145	0.082	0.199	0.258
BM25	0.103	0.066	0.140	0.175

Equations

$$\text{MRR}=\frac{1}{|Q|}\sum _{i=1}^{|Q|}\frac{1}{{\text{rank}}_i}$$

$$\text{R@N}=\frac{1}{|Q|}\sum _{i=1}^{|Q|}\frac{|{\text{max}}_N(A_i)\cap A_i^{\ast }|}{|A_i^{\ast }|}$$

Full text

1 Introduction

Popular QA benchmarks like SQuAD (Rajpurkar et al., 2016) have driven impressive progress on the task of identifying spans of text within a specific passage that answer a posed question. Recent models using BERT pretraining (Devlin et al., 2019) have already surpassed human performance on SQuAD 1.1 and 2.0.

While impressive, these systems are not yet sufficient for the end task of answering user questions at scale, since in general, we don’t know which documents are likely to contain an answer. On the one hand, typical document retrieval solutions fall short here, since they aren’t trained to directly model the connection between questions and answers in context. For example, in Figure 1, a relevant answer appears on the Wikipedia page for New York, but this document is unlikely to be retrieved, as the larger document is not highly relevant to the question. On the other hand, QA models with strong performance on reading comprehension can’t be used directly for large-scale retrieval. This is because competitive QA models use interactions between the question and candidate answer in the early stage of modeling (e.g. through cross-attention) making it infeasible to score a large set of candidates at inference time.

There is growing interest in training end-to-end retrieval systems that can efficiently surface relevant results without an intermediate document retrieval phase (Gillick et al., 2018; Cakaloglu et al., 2018; Seo et al., 2019; Henderson et al., 2019). We are excited by this direction, and hope to promote further research by offering the Retrieval Question-Answering (ReQA) benchmark, which tests a model’s ability to retrieve relevant answers efficiently from a large set of documents. Our code is available at https://github.com/google/retrieval-qa-eval.

The remainder of the paper is organized as follows. In Section 2, we define our goals in developing large-scale answer retrieval models. Section 3 describes our method for transforming within-document reading comprehension tasks into Retrieval Question-Answering (ReQA) tasks, and details our evaluation procedure and metrics. Section 4 describes various neural and non-neural baseline models, and characterizes their performance on several ReQA tasks. Finally, Section 5 discusses related work.

2 Objectives

What properties would we like a large-scale answer retrieval model to have? We discuss five characteristics below that motivate the design of our evaluation.

First, we would like an end-to-end solution. As illustrated in Figure 1, some answers are found in surprising places. Pipelined systems that first retrieve topically relevant documents and then search for answer spans within only those documents risk missing good answers from documents that appear to have less overall relevance to the question.

Second, we need efficient retrieval, with the ability to scale to billions of answers. Here we impose a specific condition that guarantees scalability. We require the model to encode questions and answers independently as high-dimensional (e.g. 512d) vectors, such that the relevance of a QA pair can be computed by taking their dot-product, as in Henderson et al. (2017).111Other distance metrics are possible. Another popular option for nearest neighbor search is cosine distance. Note, models using cosine distance can still compute relevance through a dot-product, provided the final encoding vectors are L2-normalized. This technique enables retrieval of relevant answers using approximate nearest neighbor search, which is sub-linear in the number of documents, and in practice close to log(N). This condition rules out the powerful models like BERT that perform best on reading comprehension metrics. Note, these approaches could be used to rerank a small set of retrieved candidate answers, but the evaluation of such multi-stage systems is out of the scope of this work.

Third, we focus on sentence-level retrieval. In practice, sentences are a good size to present a user with a “detailed” answer, making it unnecessary to highlight specific spans for many use cases.222In cases where highlighting the relevant span within a sentence is important, a separate highlighting module could be learned that takes a retrieved sentence as input. While the experiments in this paper primarily target sentence-level retrieval, we recognize that some domains may be best served by retrieval at a different granularity, such as phrase or passage. The evaluation techniques described in Section 3 can be easily extended to cover these different granularities.

Fourth, a retrieval model should be context aware, in the sense that the context surrounding a sentence should affect its appropriateness as an answer. For example, an ideal QA system should be able to tell that the bolded sentence in Figure 2 is a good answer to the question, since the context makes it clear that “The official language” refers to the official language of Nigeria.

Finally, we believe a strong model should be general purpose, with the ability to generalize to new domains and datasets gracefully. For this reason, we advocate using a retrieval evaluation drawn from a specific task/domain that is never used for model training. In the case of our tasks built on SQuAD and Natural Questions (NQ), we evaluate on retrieval over the entire training sets, with the understanding that all data from these sets is off-limits for model training. Additionally, we recommend not training on any Wikipedia data, as this is the source of the SQuAD and NQ document text. However, should this latter recommendation prove impractical, then, at the very least, the use of Wikipedia during training should be noted when reporting results on ReQA, being as specific as possible as to which subset was used and in what manner. This increases our confidence that a model that evaluates well on our retrieval metrics can be applied to a wide range of open-domain QA tasks.333We strongly assert that when NLP models are used in applied systems, it is generally preferable to evaluate alternative models using data that is as distinct as reasonably possible from model training data. While this is common practice in some sub-fields of NLP such as machine translation, it is still unfortunately very common to assess other NLP models on dev and test data that is very similar to its training data (e.g., harvested from the same source using a common pipeline and a common pool of annotators). This makes it more difficult to interpret claims of models approaching “human-level” performance.

3 ReQA Evaluation

In this section, we describe our method for constructing Retrieval Question-Answering (ReQA) evaluation tasks from existing machine reading based QA challenges. To perform this evaluation over existing QA datasets, we first extract a large pool of candidate answers from the dataset. Models are then evaluated on their ability to correctly retrieve and rank answers to individual questions using two metrics, mean reciprocal rank (MRR) and recall at N (R@N). In Eq (1), $Q$ is the set of questions, and rank**i is the rank of the first correct answer for the $i$th question. In Eq (2), $A^{*}_{i}$ is the set of correct answers for the $i$th question, and $A_{i}$ is a scored list of answers provided by the model, from which the top N are extracted.

[TABLE]

[TABLE]

We explore using the ReQA evaluation on both SQuAD 1.1 and Natural Questions. However, the technique is general and can be applied to other datasets as well.

3.1 ReQA SQuAD

SQuAD 1.1 is a reading comprehension challenge that consists of over 100,000 questions composed to be answerable by text from Wikipedia articles. The data is organized into paragraphs, where each paragraph has multiple associated questions. Each question can have one or more answers in its paragraph.444Typically, multiple answers come from the same sentence. For example, the question “Where did Super Bowl 50 take place?” is associated with three answers found within the sentence “The game was played on February 7, 2016, at Levi’s Stadium in the San Francisco Bay Area at Santa Clara, California.” The answer spans are: [Santa Clara, California], [Levi’s Stadium] and [Levi’s Stadium in the San Francisco Bay Area at Santa Clara, California.].

We choose SQuAD 1.1 for our initial ReQA evaluation because it is a widely studied dataset, and covers many question types.555SQuAD 2.0 adds questions that have no answer in the paragraph. While these questions are useful for testing machine reading over fixed passages, their value in a large-scale retrieval evaluation is less clear. Specifically, we can’t be sure that such questions aren’t answered by another sentence in the larger corpus. To turn SQuAD into a retrieval task, we first split each paragraph into sentences using a custom sentence-breaking tool included in our public release. For the SQuAD 1.1 train set, splitting 18,896 paragraphs produces 91,707 sentences. Next, we construct an “answer index” containing each sentence as a candidate answer. The model being evaluated computes an answer embedding for each answer (using any encoding strategy), given only the sentence and its surrounding paragraph as input. Crucially, this computation must be done independently of any specific question. The answer index construction process is described more formally in Algorithm 1.

Similarly, we embed each question using the model’s question encoder, with the restriction that only the question text be used. For the SQuAD 1.1 train set, this gives around 88,000 questions.

After all questions and answers are encoded, we compute a “relevance score” for each question-answer pair by taking the dot-product of the question and answer embeddings, as shown in Algorithm 2. These scores can be used to rank all (around 92,000) candidate answers for each question, and compute standard ranking metrics such as mean reciprocal rank (MRR) and recall (R@k).777Rarely, the same question is asked in different contexts. For example, the question “How tall is Mount Olympus?” appears twice in SQuAD, with answers on the pages for both Greece and Cyprus. In this case, we consider both answers correct for the purposes of our evaluation metrics.

3.2 ReQA NQ

Natural Questions (NQ) consists of over 320,000 examples, where each example contains a question and an entire Wikipedia article. The questions are real questions issued by multiple users to the Google search engine, for which a Wikipedia page appeared in the top five search results. The examples are annotated by humans as to whether the returned article contains an answer to the question, and if so where. For roughly 36% of examples, the article is found to contain a “short answer”: a span of text (or rarely multiple spans) that directly answers the question.

Our procedure for converting NQ into a ReQA task is similar to that described for SQuAD above. We restrict to questions with a single-span short answer, contained within an HTML $<$P$>$ (paragraph) block, as opposed to answers within a list or table. When applied to the NQ training set, this filtering produces around 74,000 questions. As with SQuAD, we consider the enclosing paragraph as context (available for the model in building an answer embedding), and split the paragraph into sentences. The target answer is the sentence containing the short answer span. Each sentence in the paragraph is added to the answer index as a separate answer candidate, resulting in around 240,000 candidates overall.999Since NQ includes the entire Wikipedia article, we could consider adding all sentences from all paragraphs as candidate answers. However even restricting to sentences from paragraphs containing short answers already produced a large index and challenged existing models, so we opted not to increase the search space further.

As with ReQA SQuAD, we advocate excluding all of Wikipedia from model training materials. Models satisfying this restriction give us more confidence that they can be extended to perform answer retrieval in new domains.

3.3 Dataset Statistics

The number of questions and candidate answers in the ReQA SQuAD and ReQA NQ datasets is shown in Table 1. While the number of questions is similar, ReQA SQuAD has around 2.6x fewer candidate answer sentences, making it an easier task overall. This difference is due to the fact that SQuAD itself was constructed to have many different questions answered by the same Wikipedia paragraphs.

Table 2 lists the average number of tokens in question and sentence-level answer text, as well as the “query coverage”, which is the percentage of tokens in the question that also appear in the answer. The token coverage for ReQA SQuAD is much larger than for ReQA NQ, indicating more lexical overlap between the question and answer. This is likely due to the original SQuAD construction process whereby writers “back-wrote” questions to be answerable by the given documents. By comparison, NQ questions are naturally occurring anonymized, aggregated search queries, where users had no access to the answering document ahead of time.

Table 3 shows the distribution of question types for each dataset. Nearly half (47.7%) of ReQA SQuAD questions are what questions, with the next most frequent being who (9.6%) and how (9.3%). ReQA NQ is more balanced across question types, with the leading types being who (32.6%), when (20.3%) and what (15.3%).

We note that neither dataset contains many why questions. Performing well on this type of question may require additional reasoning ability, so it would be interesting to explore why questions further through more targeted ReQA datasets.

3.4 Discussion

A defining feature of the SQuAD dataset is that the questions are “back-written”, with advance knowledge of the target answer and its surrounding context. One concern when adapting this data for a ReQA task is that questions may become ambiguous or underspecified when removed from the context of a specific document and paragraph. For example, SQuAD 1.1 contains the question “What instrument did he mostly compose for?”. This question makes sense in the original context of the Wikipedia article on Frédéric Chopin, but is underspecified when asked in isolation, and could reasonably have other answers. One possible resolution would be to include the context title as part of the question context. However this is unrealistic from the point of view of end systems where the user doesn’t have a specific document in mind.

This concern can be avoided by switching from “back-written” datasets to “web-search based” datasets. These include MS MARCO (Nguyen et al., 2016), TriviaQA (Joshi et al., 2017) and Natural Questions (Kwiatkowski et al., 2019). For these sets, questions are taken from natural sources, and a search engine is used in the process of constructing QA pairs.

However, there is an important caveat to mention when using web-search data to build ReQA tasks. In these datasets, the answers are derived from web documents retrieved by a search engine, where the question is used as the search query. This introduces a bias toward answers that are already retrievable through traditional search methods. By comparison, answers in SQuAD 1.1 may be found in “off-topic” documents, and it is valuable for an evaluation to measure the ability to retrieve such answers. Since both types of datasets (back-written and web-search based) have their advantages, we believe there is value in evaluating on ReQA tasks of both types.

4 Models and Results

In this section we evaluate neural models and classic information retrieval techniques on the ReQA SQuAD and ReQA NQ benchmark tasks.

4.1 Neural Baselines

Dual encoder models are learned functions that collocate queries and results in a shared embedding space. This architecture has shown strong performance on sentence-level retrieval tasks, including conversational response retrieval (Henderson et al., 2017; Yang et al., 2018), translation pair retrieval (Guo et al., 2018; Yang et al., 2019b) and similar text retrieval (Gillick et al., 2018). A dual encoder for use with ReQA has the schematic shape illustrated in Figure 3.

As our primary neural baseline, we take the recently released universal sentence encoder QA (USE-QA) model from Yang et al. (2019c)101010https://tfhub.dev/google/universal-sentence-encoder-multilingual-qa/1. This is a multilingual QA retrieval model that co-trains a question-answer dual encoder along with secondary tasks of translation ranking and natural language inference. The model uses sub-word tokenization, with a 128k “sentencepiece” vocabulary (Kudo and Richardson, 2018). Question and answer text are encoded independently using a 6-layer transformer encoder (Vaswani et al., 2017), and then reduced to a fixed-length vector through average pooling. The final encoding dimensionality is 512. The training corpus contains over a billion question-answer pairs from popular online forums and QA websites like Reddit and StackOverflow.

As a second neural baseline, we include an internal QA model (QALite) designed for use on mobile devices. Like USE-QA, this model is trained over online forum data, and uses a transformer-based text encoder. The core differences are reduction in width and depth of model layers, reduction of sub-word vocabulary size, and a decrease in the output embedding size from 512 dimensions to only 100.

Finally, we include the text embedding system InferSent, which, although not explicitly designed for question answering tasks, nevertheless produces strong results on a wide range of semantic tasks without requiring additional fine-tuning (Conneau et al., 2017). Note, however, that at 4096 dimensions, its embeddings are significantly larger than the other baselines presented. Other systems in this class include Skip-thought (Kiros et al., 2015), ELMo (Peters et al., 2018), and the Universal Sentence Encoder111111The non-QA versions of the Universal Sentence Encoder produce general semantic embeddings of text..

Table 4 presents the ReQA results for our baseline models. As expected, the larger USE-QA model outperforms the smaller QALite model. The recall@1 score of 0.439 on ReQA SQuAD indicates that USE-QA is able to retrieve the correct answer from a pool of 91,707 candidates roughly 44% of the time. The ReQA NQ scores are lower, likely due to both the larger pool of candidate answers, as well as the lower degree of lexical overlap between questions and answers.

Table 5 illustrates the tradeoff between model accuracy and resource usage.

4.2 BM25 Baseline

While neural retrieval systems are gaining popularity, TF-IDF based methods remain the dominant method for document retrieval, with the BM25 family of ranking functions providing a strong baseline (Robertson and Zaragoza, 2009). Unlike the neural models described above that can directly retrieve content at the sentence level, such methods generally consist of two stages: document retrieval, followed by sentence highlighting (Mitra and Craswell, 2018). Previous work in open domain question answering has shown that BM25 is a difficult baseline to beat when questions were written with advance knowledge of the answer (Lee et al., 2019).

To obtain our baseline using traditional IR methods, we constructed a paragraph-level retrieval task which allows a direct comparison between the neural systems in Table 4 and BM25.131313We opted not to evaluate BM25 on sentence-level retrieval as earlier work has shown that traditional term-based document retrieval technologies are unsuccessful when applied to sentence-level retrieval Allan et al. (2003). We evaluate BM25 by measuring its ability to recall the paragraph containing the answer to the question.141414Our experiments make use of the implementation at https://github.com/nhirakawa/BM25 with default hyperparameter settings. To get a paragraph retrieval score for our neural baselines, we run sentence retrieval as before, and use the retrieved sentence to select the enclosing paragraph. As shown in Table 6, the USE-QA neural baseline outperforms BM25 on paragraph retrieval.

5 Related Work

Open domain question answering is the problem of answering a question from a large collection of documents (Voorhees and Tice, 2000). Successful systems usually follow a two-step approach to answer a given question: first retrieve relevant articles or blocks, and then scan the returned text to identify the answer using a reading comprehension model (Jurafsky and Martin, 2018; Kratzwald and Feuerriegel, 2018; Yang et al., 2019a; Lee et al., 2019). While the reading comprehension step has been widely studied with many existing datasets (Rajpurkar et al., 2016; Nguyen et al., 2016; Dunn et al., 2017; Kwiatkowski et al., 2019), machine reading at scale is still a challenging task for the community.

Chen et al. (2017) recently proposed DrQA, treating Wikipedia as a knowledge base over which to answer factoid questions from SQuAD (Rajpurkar et al., 2016), CuratedTREC (Baudiš and Šedivý, 2015) and other sources. The task measures how well a system can successfully extract the answer span given a question, but it still relies on a document retrieval step. The ReQA eval differs from DrQA task by skipping the intermediate step and retrieving the answer sentence directly.

There is also a growing interest in answer selection at scale. Surdeanu et al. (2008) constructs a dataset with 142,627 question-answer pairs from Yahoo! Answers, with the goal of retrieving the right answer from all answers given a question. However, the dataset is limited to “how to” questions, which simplifies the problem by restricting it to a specific domain. Additionally the underlying data is not as broadly accessible as SQuAD and other more recent QA datasets, due to more restrictive terms of use.

WikiQA (Yang et al., 2015) is another task involving large-scale sentence-level answer selection. The candidate sentences are, however, limited to a small set of documents returned by Bing search, and is smaller than the scale of our ReQA tasks. WikiQA consists of 3,047 questions and 29,258 candidate answers, while ReQA SQuAD and ReQA NQ each contain over 20x that number of questions and over 3x that number of candidates (see Table 1). Moreover, as discussed in Section 3.4, restricting the domain of answers to top search engine results limits the evaluation’s applicability for testing end-to-end retrieval.

Cakaloglu et al. (2018) made use of SQuAD for a retrieval task at the paragraph level. We extend this work by investigating sentence level retrieval and by providing strong sentence-level and paragraph-level baselines over a replicable construction of a retrieval evaluation set from the SQuAD data. Further, while Cakaloglu et al. (2018) trained their model on data drawn from SQuAD, we would like to highlight that our own strong baselines do not make use of any training data from SQuAD. We advocate for future work to attempt a similar approach of using sources of model training and evaluation data that are distinct as possible in order to provide a better picture of how well models generally perform a task.

Finally, Seo et al. (2018) construct a phrase-indexed question answering challenge that is similar to ReQA in requiring the question and the answer be encoded separately of one another. However, while ReQA focuses on sentence-based retrieval, their benchmark retrieves phrases, allowing for a direct $F_{1}$ and exact-match evaluation on SQuAD. Seo et al. (2019) demonstrate an implementation of a phrase-indexed question answering system using a combination of dense (neural) and sparse (term-frequency based) indices.

We believe that ReQA can help guide development of such systems by providing a point of evaluation between SQuAD, whose passages are too small to test retrieval performance, and SQuAD-Open (Chen et al., 2017), which operates at a realistic scale but is expensive and slow to evaluate. In practice, our evaluation runs completely in memory and finishes within two hours on a developer workstation, making it easy to integrate directly into the training process, where it can, for instance, trigger early stopping.

6 Conclusion

In this paper, we introduce Retrieval Question-Answering (ReQA) as a new benchmark for evaluating end-to-end answer retrieval models. The task assesses how well models are able to retrieve relevant sentence-level answers to queries from a large corpus. We describe a general method for converting reading comprehension QA tasks into cross-document answer retrieval tasks. Using SQuAD and Natural Questions as examples, we construct the ReQA SQuAD and ReQA NQ tasks, and evaluate several models on sentence- and paragraph-level answer retrieval. We find that a freely available neural baseline, USE-QA, outperforms a strong information retrieval baseline, BM25, on paragraph retrieval, suggesting that end-to-end answer retrieval can offer improvements over pipelined systems that first retrieve documents and then select answers within. We release our code for both evaluation and conversion of the datasets into ReQA tasks.

Acknowledgments

We thank our teammates from Descartes and other Google groups for their feedback and suggestions. We would like to recognize Javier Snaider, Igor Krivokon and Ray Kurzweil. Special thanks goes to Jonni Kanerva for developing the tailored sentence-breaking algorithm.