Question answering

Question answering (QA) sounds like one task but is really three. They differ in where the answer comes from and how it’s produced: extract it from a given passage, retrieve the passage first and then extract, or generate it freely. These distinctions still structure how every modern QA system is built, including retrieval-augmented LLMs (systems that look up documents before a large language model writes its answer).

Extractive QA: predict a span

The classic benchmark, SQuAD (a large public set of questions, each paired with a passage that holds the answer), gives a question and a passage known to contain the answer. The answer is a contiguous span of that passage, meaning a run of consecutive words. The model scores every token (a word or word piece) twice: how likely it is to be the start of the answer, and how likely it is to be the end. The answer is the best valid span (start ≤ end):

passage = "the Eiffel Tower is in Paris France".split()
start = [0, 0, 0, 0, 0, 3, 0]        # per-token START scores the model predicts
end   = [0, 0, 0, 0, 0, 3, 1]        # per-token END scores

best = (-1, None)
for i in range(len(passage)):
    for j in range(i, min(i + 3, len(passage))):   # spans up to length 3, with i <= j
        if start[i] + end[j] > best[0]:
            best = (start[i] + end[j], (i, j))

i, j = best[1]
print("Q: where is the Eiffel Tower?")
print(f"answer span: {' '.join(passage[i:j+1])!r}  (score {best[0]})")

Q: where is the Eiffel Tower?
answer span: 'Paris'  (score 6)

The model is really doing token classification (span labeling): score each position as start/end, then pick the highest-scoring legal span. This is the canonical task you fine-tune BERT for (take the pretrained BERT language model and train it a bit more on QA examples). Because the answer is copied verbatim from the passage, it can’t hallucinate, which means it can’t invent facts the text never stated. Its weakness is that the answer must be present as a literal span.

Open-domain QA: retrieve, then read

Extractive QA assumes you’re handed the right passage. Open-domain QA drops that: the question arrives alone (“Where is the Eiffel Tower?”), and the system must first find relevant text. The pipeline is retriever → reader. A retriever pulls candidate passages from a large corpus, using either BM25 (ranking by shared keywords) or dense embeddings (ranking by closeness in meaning). Then a reader (extractive QA) pulls the answer span from them. This two-stage pattern is the direct ancestor of RAG. Swap the extractive reader for a generative LLM and retriever-reader becomes retrieval-augmented generation.

Generative QA, and evaluation

Generative QA writes the answer in free text with a seq2seq model (a network that reads one text and writes another) or an LLM, rather than copying a span. It can synthesize across multiple passages and phrase the answer naturally. But being generation, it can hallucinate an answer that isn’t supported. Extractive QA is scored with Exact Match (is the predicted span exactly the gold answer?) and F1 (token overlap, for partial credit). Generative answers need fuzzier or model-based scoring because many phrasings are correct.

In one breath

• QA has three flavors: extractive (answer is a span of a given passage), open-domain (retrieve the passage first, then extract), and generative (write the answer freely).
• Extractive QA (SQuAD) predicts per-token start/end scores and returns the best legal span (the demo: Paris) — really token classification, the canonical BERT fine-tune; it can’t hallucinate but needs the answer present verbatim.
• Open-domain QA is retriever → reader — find candidate passages (BM25/dense), then read the answer — the direct ancestor of RAG.
• Generative QA writes free-text answers (synthesize, paraphrase) but can hallucinate; evaluation uses Exact Match + F1 for spans, fuzzier scoring for generation.
• Modern QA = RAG (retrieve + generative reader); extractive span QA still wins when the answer must be provably grounded.

Quick check

Next

The retriever-reader pattern here grows directly into RAG; span prediction is sequence labeling over the passage; and the generative reader is seq2seq. Conversational QA continues in dialogue systems.