Year: 2021

Abstract:
A conventional approach to entity linking is to first find mentions in a given document and then infer their underlying entities in the knowledge base. A well-known limitation of this approach is that it requires finding mentions without knowing their entities, which is unnatural and difficult. We present a new model that does not suffer from this limitation called EntQA, which stands for Entity linking as Question Answering. EntQA first proposes candidate entities with a fast retrieval module, and then scrutinizes the document to find mentions of each candidate with a powerful reader module. Our approach combines progress in entity linking with that in open-domain question answering and capitalizes on pretrained models for dense entity retrieval and reading comprehension. Unlike in previous works, we do not rely on a mention-candidates dictionary or large-scale weak supervision. EntQA achieves strong results on the GERBIL benchmarking platform.

heading: 1 INTRODUCTION
text: We consider the most general form of entity linking (EL) in which a system, given a document, must both extract entity mentions and link the mentions to their corresponding entries in a knowledge base (KB). EL is a foundational building block in automatic text understanding with applications to question answering (QA) (Ferrucci, 2012), information retrieval (Xiong et al., 2017; Hasibi et al., 2016; Balog et al., 2013; Reinanda et al., 2015), and commercial recommendation systems (Yang et al., 2018; Slawski, 2015).
The output space in EL is intractably large. Any subset of all possible spans in the document linked to any KB entries (typically in the order of millions) can be a system output. To get around the intractability, existing methods decompose EL into mention detection (MD) and entity disambiguation (ED) and tackle them with varying degrees of independence. In all cases, however, the order of these two subproblems is MD followed by ED: first the system identifies potential entity mentions, and then the mentions are resolved to KB entries. Previous works either assume that mentions are given (Gupta et al., 2017), run an off-the-shelf named-entity recognition (NER) system to extract mentions and resolve them by ED (MD→ED pipeline) (Hoffart et al., 2011; Ling et al., 2015; van Hulst et al., 2020), or train an end-to-end model that jointly performs MD→ED by beam search (Kolitsas et al., 2018; Cao et al., 2021).
A limitation of performing MD before ED is that it requires finding mentions of unknown entities. By definition, a mention needs an entity (i.e., a mention of what?). Existing methods suffer from the dilemma of having to predict mentions before what they refer to, which is unnatural and difficult. For example, the MD→ED pipeline heuristically extracts mentions from spans of named entities found by a third-party NER system, and the performance bottleneck is often errors in MD propagated to ED. End-to-end models alleviate the problem of error propagation, but the search is only approximate and the dilemma, albeit to a lesser degree, remains.
In this work, we propose flipping the order of the two subproblems and solving ED before MD. We first find candidate entities that might be mentioned in the given document, then for each candidate find its mentions if possible. Our key observation is that while finding mentions is difficult without the knowledge of relevant entities, finding relevant entities is easy without the knowledge of their specific mentions. This simple change fundamentally solves the dilemma above since identifying mentions of a particular entity is well defined.
We cast the problem as inverted open-domain QA. Specifically, given a document, we use a dual encoder retriever to efficiently retrieve top-K candidate entities from the KB as “questions”. Then
we apply a deep cross-attention reader on the document for each candidate to identify mentions of the candidate in the document as “answer spans”. Unlike in standard QA, the model must predict an unknown number of questions and answers. We present a simple and effective solution based on thresholding. We call our model EntQA, standing for Entity linking as Question Answering.
Beyond conceptual novelty, EntQA also offers many practical advantages. First, EntQA allows us to piggyback on recent progress in dense entity retrieval and open-domain QA. For instance, we warm start EntQA with the BLINK entity retriever (Wu et al., 2020a) and ELECTRA finetuned on a QA dataset (Clark et al., 2019) to obtain an easy improvement. Second, EntQA has no dependence on a hardcoded mention-candidates dictionary which is used in previous works to reduce the search space and bias the model (Ganea & Hofmann, 2017; Kolitsas et al., 2018; Cao et al., 2021). The dictionary is typically constructed using a large KB-specific labeled corpus (e.g., Wikipedia hyperlinks), thus having no dependence on it makes our approach more broadly applicable to KBs without such resources. Third, training EntQA is data efficient and can be done with an academic budget, in contrast with GENRE (Cao et al., 2021) which requires industry-scale pretraining by weak supervision.
EntQA achieves strong performance on the GERBIL benchmarking platform (Röder et al., 2018). The in-domain F1 score on the test portion of the AIDA-CoNLL dataset is 85.8 (2.1 absolute improvement). The macro-averaged F1 score across 8 evaluation datasets is 60.2 (2.0 absolute improvement).1 We analyze EntQA and find that its retrieval performance is extremely strong (over 98 top-100 recall on the validation set of AIDA), verifying our hypothesis that finding relevant entities without knowing their mentions is easy. We also find that the reader makes reasonable errors such as accurately predicting missing hyperlinks or linking a mention to a correct entity that is more specific than the gold label.

heading: 2 MODEL
text: Let E denote the set of entities in a KB associated with a text title and description. Let V denote the vocabulary and X = { x ∈ VT : 1 ≤ T ≤ Tmax } the set of all documents up to length Tmax. EL is the task of mapping x ∈ X to y ∈ P(Y(x)) where Y(x) = {(s, t, e) : 1 ≤ s ≤ t ≤ |x| , e ∈ E} is the set of all possible linked spans in x and P is the power set. The size of the output space is O(2T 2 max|E|) where |E| is typically very large (e.g., around 6 million in Wikipedia) and Tmax can also be large (e.g., > 3000 in AIDA), ruling out any naive exhaustive search as a feasible approach.
EntQA decomposes EL into two subproblems: entity retrieval and question answering. More specifically, given a document x ∈ X ,
1. The retriever module retrieves top-K candidate entities that might be mentioned in x. 2. The reader module extracts mentions of each candidate entity in x (or rejects it), then
returns a subset of globally reranked labeled mentions as the final prediction.
Our approach bears superficial similarities to a standard framework in open-domain QA that pipelines retrieval and span finding (Karpukhin et al., 2020, inter alia), but it has the following important differences. First, instead of retrieving passages given a question, it retrieves questions (i.e., candidate entities) given a passage. Second, even when considering a single question, there can be multiple answer spans (i.e., mentions) instead of one. Both the number of gold entities present in a document and the number of mentions of each gold entity are unknown, making this setting more challenging than standard QA in which we only need to find a single answer span for a single question on a passage.
Input representation. Both the retriever and the reader work with text representations of documents and entities, thus applicable to a zero-shot setting (e.g., linking to a new KB at test time by reading entity descriptions). We use the title φtitle(e) ∈ V+ and the description φdesc(e) ∈ V+ to represent an entity e ∈ E . Since a document x ∈ X is generally too long to encode with a Transformer encoder which has a quadratic dependency on the input length, we break it down in mx ∈ N overlapping passages p1(x) . . . pmx(x) ∈ VL of length L with stride S (e.g., L = 32 and S = 16) and operate at the passage-level similarly as in QA (Alberti et al., 2019). When a document is long,
1We will release code to reproduce our experiments upon publication.
individual passages may lose global information. For long documents, we find it beneficial to carry a document-level topical text ψtopic(x) ∈ V+ across passages in that document (e.g., first sentence). We emphasize that we do not use any extra information outside the document. In our experiments we simply set ψtopic(x) = x1 ∈ V (i.e., the first token in the document).
Notation. We write encθS : VT → Rd×T to denote a Transformer encoder that maps any token sequence to the same-length sequence of corresponding contextual embeddings; the symbol S is used to distinguish different encoders. We assume the usual special tokens in the input popularized by BERT (Devlin et al., 2019): [CLS] to represent the whole input and [SEP] to indicate an input boundary. We write ⊕ to denote the text concatenation (we insert a special symbol to represent the concatenation). We write Mi ∈ Rd to denote the i-th column of matrix M ∈ Rd×T .

heading: 2.1 RETRIEVER
text: Given a passage p ∈ V+ in document x and an entity e ∈ E , the retriever computes
P = encθP ([CLS]p⊕ ψtopic(x)[SEP]) Ee = encθE([CLS]φtitle(e)⊕ φdesc(e)[SEP])
scoreθretr(p, x, e) = P > 1 E e 1
At inference time, we precompute Ee ∈ Rd for each e ∈ E and use Faiss (Johnson et al., 2019) for fast top-K retrieval.
Training. We train the retriever by a multi-label variant of noise contrastive estimation (NCE). Given a passage p in document x, we have a set of multiple gold entities E(p) ⊂ E that are mentioned in the passage and optimize the per-example objective
max θ ∑ e∈E(p) log
( exp ( scoreθretr(p, x, e) ) exp ( scoreθretr(p, x, e) ) + ∑ e′∈N(E,p) exp ( scoreθretr(p, x, e ′) )) (1)
where N(E , p) ⊂ E\E(p) is a set of negative examples that excludes all gold entities E(p). The objective effectively constructs |E(p)| independent NCE instances, each of which treats a gold entity as the only correct answer while ensuring that other gold entities are not included in negative examples. We obtain 90% of N(E , p) by sampling entities uniformly at random from E\E(p) and 10% by hard negative mining (i.e., using highest-scoring incorrect entities under the model), which is well known to be beneficial in entity retrieval (Gillick et al., 2019; Wu et al., 2020a; Zhang & Stratos, 2021).

heading: 2.2 READER
text: Let e1:K = (e1 . . . eK) ∈ EK denote K candidate entities for a passage p in document x. For each k ∈ {1 . . .K}, the reader computes a joint encoding of (p, x, ek) by
Hk = encθH([CLS]p⊕ ψtopic(x)[SEP]φtitle(ek)⊕ φdesc(ek)[SEP]) then defines a conditional distribution over mention spans of ek in p by
pθstart(s|p, x, ek) = exp
( w>startH k s )∑|p|+1 i=1 exp ( w>startH k i
) ∀s ∈ {1 . . . |p|+ 1} pθend(t|p, x, ek) = exp ( w>endH k t
)∑|p|+1 i=1 exp ( w>endH k i
) ∀t ∈ {1 . . . |p|+ 1} pθspan(s, t|p, x, ek) = pθstart(s|p, x, ek)× pθend(t|p, x, ek) ∀s, t ∈ {1 . . . |p|+ 1}
where wstart, wend ∈ Rd are additional parameters. The reader also multitasks reranking: it uses wrerank ∈ Rd to define a conditional distribution over candidate entities by
pθrerank(ek|p, x, e1:K) = exp
( w>rerankH k s )∑K k′=1 exp ( w>rerankH k′ s ) ∀k ∈ {1 . . .K}
Training. We obtain candidates e1:K from a fully trained retrieval module to make training consistent with test time. During training, we always include all gold entities as candidates (i.e., E(p) ⊂ e1:K). LetM(p, e) denote the set of gold mention spans of e ∈ E in p; if e is not present in p, we defineM(p, e) = {(1, 1)}. We optimize the per-example objective
max θ K∑ k=1 1(ek ∈ E(p)) log pθrerank(ek|p, x, e1:K) + ∑
(s,t)∈M(p,ek)
log pθspan(s, t|p, x, ek) (2)
where 1(A) is the indicator function equal to one if A is true and zero otherwise. Note that the reader is trained to predict the [CLS] span for incorrect entities.

heading: 2.3 INFERENCE
text: At test time, we process a new document x ∈ X in passages p ∈ VL independently as follows:
1. Retrieve top-K highest scoring entities e1:K under scoreθretr(p, x, e).
2. For each candidate k, extract top-P most likely mention spans (sk1 , t k 1) . . . (s k P , t k P ) under
pθspan(s, t|p, x, ek) while discarding any span less probable than (1, 1).
3. Return a subset of the surviving labeled mentions (s, t, ek) with pθrerank(ek|p, x, e1:K) × pθspan(s, t|p, x, ek) > γ as the final prediction.
We do not apply any further processing to combine passage-level predictions other than merging duplicate labeled spans (s, t, e) in the overlapping sections. This inference scheme is simple yet effective. For each candidate entity, the reader scrutinizes the passage with deep cross-attention to see if there are any mentions of the entity and has a chance to reject it by predicting (1, 1). The reader delays its final decision until it has processed all candidates to globally reconsider labeled mentions with ranking probabilities. Figure 1 shows a successful prediction on a passage from the validation portion of AIDA.

heading: 3 EXPERIMENTS
text: We evaluate EntQA on the GERBIL benchmarking platform (Röder et al., 2018), which offers reliable comparison with state-of-the-art EL methods on numerous public datasets.

heading: 3.1 SETTING
text: Datasets. We follow the established practice and report the InKB Micro F1 score on the in-domain and out-of-domain datasets used in Cao et al. (2021). Specifically, we use the AIDA-CoNLL dataset (Hoffart et al., 2011) as the in-domain dataset: we train EntQA on the training portion of AIDA, use the validation portion (AIDA-A) for development, and reserve the test portion (AIDA-B) for indomain test performance. We use seven out-of-domain test sets: MSNBC, Derczynski (Der) (Derczynski et al., 2015), KORE 50 (K50) (Hoffart et al., 2012), N3-Reuters-128 (R128), N3-RSS-500 (R500) (Röder et al., 2014), and OKE challenge 2015 and 2016 (OKE15 and OKE16) (Nuzzolese et al., 2015). We refer to Table 6 in Kolitsas et al. (2018) for the datasets’ statistics. For the KB, we use the 2019 Wikipedia dump provided in the KILT benchmark (Petroni et al., 2021), which contains 5.9 million entities.
Model details. We initialize the passage encoder encθP and the entity encoder encθE in the retriever module with independent BLINK retrievers pretrained on Wikipedia hyperlinks (Wu et al., 2020a) and optimize the NCE objective (1) with hard negative mining. We initialize the joint encoder encθH in the reader module with ELECTRA-large (Clark et al., 2019) finetuned on SQuAD 2.0 (Rajpurkar et al., 2018) and optimize the reader objective (2). We break up each document x ∈ X into overlapping passages of length L = 32 with stride S = 16 under WordPiece tokenization. For each passage in x, we concatenate the input with the first token of the document ψtopic(x) = x1, which corresponds to the topic in AIDA but not in other datasets. We use 64 candidate entities in training for both the retriever and the reader; we use 100 candidates at test time. We predict up to P = 3 mention spans for each candidate entity. We use γ = 0.05 as the threshold in all experiments, chosen after trying values 0.01, 0.1, and 0.05 on the validation set. For optimization, we use Adam (Kingma & Ba, 2015) with learning rate 2e-6 for the retriever and 1e-5 for the reader; We use a linear learning rate decay schedule with warmup proportions 0.06 for the retriever (4 epochs) and 0.2 for the reader (2 epochs). The batch size is 4 for the retriever and 2 for the reader. The retriever is trained on 4 GPUs (A100) for 24 hours; the reader is trained on 2 GPUs for 12 hours.
Baselines. We compare with state-of-the-art EL systems that represent a diverse array of approaches. Hoffart et al. (2011) and van Hulst et al. (2020) use the MD→ED pipeline; despite the limitation of pipelining MD with ED, the latter achieve excellent performance by solving MD with a strong NER system (Akbik et al., 2018). Kolitsas et al. (2018) use an end-to-end model that sequentially performs MD and ED; to make the problem tractable, they drastically prune the search space with a mention-candidates dictionary and the model score. Cao et al. (2021) propose GENRE, a sequence-to-sequence model for EL. The model conditions on the given document and autoregressively generates a labeled version of the document by at each position either copying a token, starting or ending a mention span, or, if the previous generation was the end of a mention m, generating the entity title associated with m token by token. At inference time, GENRE critically relies on a prefix tree (aka. trie) derived from Wikipedia to constrain the beam search so that it produces a valid entity title in the KB.

heading: 3.2 RESULTS
text: Table 1 shows the main results. EntQA achieves the best in-domain test F1 score for AIDA (+2.1) and is also performant on out-of-domain datasets (+7.1 on KORE 50 and +7.4 on N3-Reuters128, close second-best on Derczynski and N3-RSS-500). The performance is lower on OKE15 and OKE16 for the same reason pointed out by Cao et al. (2021): these datasets are annotated with coreference (i.e., they contain pronouns and common nouns linked to entities) which our model is not trained for, while many other systems have a component in their pipelines to handle these cases. We hypothesize that the performance on MSNBC is lagging because it has long documents (544 words per document on average) which are processed in relatively short passages under EntQA due to our computational constraints. Overall, EntQA achieves the best macro-averaged F1 score across the 8 evaluation datasets (+2.0).
We note that there is an issue of using different editions of Wikipedia between the systems. For instance, Hoffart et al. (2011) use the 2010 dump, van Hulst et al. (2020) and we use the 2019 dump, whereas Kolitsas et al. (2018) and Cao et al. (2021) use the 2014 dump (even though the latter use the 2019 dump for pretraining). Thus there is a concern that differences in performance are due to
different snapshots of Wikipedia. While we consider it out of scope in our work to fully address this concern, we find that using different editions of Wikipedia does not fundamentally change the performance of EntQA, which is consistent with GERBIL’s intent of being KB-agnostic. For instance, we obtained the same validation F1 on AIDA with our model trained on either the 2014 or 2019 dump. We use the KILT edition of Wikipedia mainly for convenience.

heading: 3.2.1 OTHER PRACTICAL HIGHLIGHTS
text: No dictionary. EntQA has no dependence on a mention-candidates dictionary. All previous works rely on a dictionaryD : V+ → P(E) that maps a mention stringm to a small set of candidate entities e ∈ E associated with empirical conditional probabilities p̂e|m > 0 (Hoffart et al., 2011, inter alia). For instance, it is an essential component of the search procedure in the end-to-end model of Kolitsas et al. (2018). While not mentioned in the paper or on the GitHub repository, GENRE (Cao et al., 2021) also uses the dictionary from Kolitsas et al. (2018) in their prefix tree to constrain the beam search (personal communication with one of the authors of the paper). Constructing such a dictionary typically assumes the existence of a large KB-specific labeled corpus (e.g., internal links in Wikipedia). EntQA is thus more broadly applicable to KBs without such resources (e.g., for small domain-specific KBs).
No model-specific pretraining. EntQA does not require model-specific pretraining; it only uses standard pretrained Transformers for initialization and is directly finetuned on AIDA. This is in contrast with GENRE which requires industry-scale pretraining by weak supervision. Specifically, GENRE is trained by finetuning BART (Lewis et al., 2020) on autoregressive EL training examples constructed from all Wikipedia abstract sections on 64 GPUs for 30 hours, followed by finetuning on AIDA. Thus training GENRE from scratch is beyond the means of most academic researchers, making it difficult to make substantial changes to the model. EntQA can be trained with academic resources and outperforms GENRE.

heading: 3.3 ABLATION STUDIES
text: The final form of EntQA in Section 3.2 is the result of empirically exploring various modeling and optimization choices during development. We present an ablation study to illustrate the impact of these choices.
Retriever Table 2 shows an ablation study for the retriever module. We report top-100 recall (R@100) on the validation set of AIDA. The baseline retriever is initialized with BLINK (Wu et al., 2020a), uses the passage representation p⊕ x1, and is trained by optimizing the multi-label variant of NCE (1) that considers one gold entity at a time by excluding others in the normalization term. We see that the baseline retriever has an extremely high recall (98.2), confirming our hypothesis that it is possible to accurately infer relevant entities in a passage without knowing where they are mentioned. We also see that it is very important to use the proposed multi-label variant of NCE
instead of naive NCE that normalizes over all gold entities, which results in a massive decrease in recall (82.7). We consider optimizing the marginal log-likelihood (i.e., the log of the sum of the probabilities of gold entities, rather than the sum of the log), but it yields much worse performance (83.8). It is helpful to initialize with BLINK rather than BERT-large, use hard negatives in NCE, and append x1 to input passages.
Reader Table 3 shows an ablation study for the reader module. We report F1 on the validation set of AIDA. The baseline reader is initialized with ELECTRA-large (Clark et al., 2019) finetuned on SQuAD 2.0, uses the joint passage-entity input representation p⊕x1[SEP]φtitle(e)⊕φdesc(e), and is trained by optimizing (2). Candidate entities are obtained from the baseline retriever in Table 2. We see that BERT is less performant than ELECTRA for reader initialization, consistent with findings in the QA literature (Yamada et al., 2021). Training by optimizing the marginal loglikelihood is comparable to (2). Interestingly, we find that we can fit the reader just as well without using a SQuAD-finetuned ELECTRA, ranking probabilities, or x1 in passages. However, in our preliminary investigation we found that these variants generalized slightly worse outside the training domain, thus we kept our original choice. Lastly, we conduct an oracle experiment in which we provide only gold entities as candidates to the reader. In this scenario, the reader is very accurate (94.9 F1), suggesting that the main performance bottleneck is correctly distinguishing gold vs nongold entities from the candidates. We investigate this issue more in depth in the next section.

heading: 3.4 ERROR ANALYSIS
text: To better understand the source of errors made by EntQA, we examine passages in the validation set for which the model’s prediction is not completely correct. We partition them into three types: (1) over-predicting (i.e., the gold mentions are a strict subset of the predicted mentions), (2) underpredicting (i.e., the predicted mentions are a strict subset of the gold mentions), and (3) neither overnor under-predicting. Table 4 shows examples of each error type. We find that over-predicting often happens because the model correctly “fills in” entity mentions missing in the gold annotation. Under-predicting happens most likely because the threshold value is too large to catch certain mentions. Finally, many errors that are neither over- nor under-predicting are largely due to annotation noise. For instance, the predicted entity Headingly Stadium is a correct and more specific en-
tity for the span “headingley” than the gold entity Headingly (a suburb); the predicted span “the oval” is more suitable, or at least as correct as, the gold span “oval” for the entity The Oval.
We also consider distinguishing MD errors from ED errors on the validation set. EntQA obtains 87.5 overall F1. When we only measure the correctness of mention spans (equivalent to treating all entity predictions as correct), we obtain 92.3 F1. When we only measure the correctness of rejecting or accepting candidate entities, we obtain 64.5 F1 at the passage level and 89.3 F1 at the document level (i.e., consider the set of candidates from all passages). The reader’s relatively low passage-level F1 in rejecting or accepting candidates is consistent with the the oracle experiment in Table 3. That is, the main performance bottleneck of EntQA is discriminating gold vs non-gold entities from the candidates, though this should be taken with a grain of salt given the noise in annotation illustrated in Table 4.

heading: 4 RELATED WORK
text: Our work follows the recent trend of formulating language tasks as QA problems, but to our knowledge we are the first to propose reduction to inverted open-domain QA. Most previous works supply questions as input to the system, along with passages in which answer spans are found. They differ only in question formulation, for instance a predicate in semantic role labeling (He et al., 2015), a relation type along with its first argument in KB completion (Levy et al., 2017; Li et al., 2019), an entity category in (nested) NER (Li et al., 2020), an auxiliary verb or a wh-expression in ellipsis resolution (Aralikatte et al., 2021), and other task-specific questions (McCann et al., 2018). In contrast, we solve question formulation as part of the problem by exploiting recent advances in dense text retrieval.
A notable exception is CorefQA (Wu et al., 2020b), from which we take direct inspiration. In this approach, the authors formulate coreference resolution as QA in which questions are coreferring spans and answers are the spans’ antecedents (i.e., earlier spans that belong to the same coreference cluster). Since coreferring spans are unknown, the authors rely on the end-to-end coreference resolution model of Lee et al. (2017) that produces candidate spans by beam search. In contrast, EntQA handles varying numbers of questions in a simpler framework of text retrieval.
As in this work, some previous works propose methods to handle varying numbers of answer spans for a given question. But their methods are based on one-vs-all classification (i.e., each label is associated with a token-level binary classifier) or reduction to tagging (i.e., spans are expressed as a BIO-label sequence) (Wu et al., 2020b; Li et al., 2019; 2020). We found these methods to be ineffective in preliminary experiments, and instead develop a more effective inference scheme in which the model delays its final prediction to the end for global reranking (Section 2.3).
We discuss pros and cons of EntQA vs other models in practice. While EntQA outperforms GENRE without large-scale weakly supervised pretraining, it involves dense retrieval which incurs a large memory footprint to store and index dense embeddings as pointed out by Cao et al. (2021). But it can be done on a single machine with ample RAM (ours has 252G) which is cheap. Bypassing dense retrieval is a unique strength of the autoregressive approach of GENRE and orthogonal to ours; we leave combining their strengths as future work. Our model requires a threshold γ for inference, but we find that it is easy to pick a good threshold; we also argue that it can be a useful feature in a real-world setting in which the practitioner often needs a customized trade-off between precision and recall. The threshold-based inference implies another unique feature of EntQA not explored in this work: it can naturally handle nested entity mentions. We leave nested linking as future work.

heading: 5 CONCLUSIONS
text: Existing methods for entity linking suffer from the dilemma of having to predict mentions of unknown entities. We have presented EntQA, a new model that solves this dilemma by predicting entities first and then finding their mentions. Our approach is based on a novel reduction to inverse open-domain QA in which we retrieve an unknown number of questions (candidate entities) and predict potentially multiple answer spans (mentions) for each question. Our solution is a simple pipeline that takes full advantage of progress in text retrieval and reading comprehension. EntQA achieves new state-of-the-art results on the GERBIL benchmarking platform without relying on a KB-specific mention-candidates dictionary or expensive model-specific pretraining.

Review summaries:
This paper proposes a new paradigm for entity linking. The proposed method EntQA retrieves candidate entities first, and then uses candidate entities as queries to find mention spans.  EntQA addresses the issue of finding mentions without knowing their entities and offers many practical advantages. Experimental results show that EntQA can achieve good performance without mention-candidates dictionaries and large-scale task-specific weak supervision. 

This paper improves on the stat-of-the-art in entity linking.  Entity linking involves connecting entities to their mentions in test passages. Current solutions rely on finding mentions first before running entity disambiguation stage which is difficult because mentions are being searched for unknown entities in the first stage. The authors address this challenge by rearranging the standard QA pipeline by learning questions first (finding entities) and searching for answers (mentions) at a later stage. This approach appears to be well-researched. The authors tested their model on GERBIL benchmarking platform and achived very positive results. 

Standard entity linking first does mention detection and then the actual linking of mentions to entities in the knowledge base, and the authors propose to flip this by using open domain QA. They first use the text to find candidate entities in the knowledge base. Then for each of these candidates, they look for possible mentions in the text. The model performs well on average, and has some nice advantages such as no mention-candidates dictionary and simplicity of generalization to out-of-domain tasks.