💬 Natural language understanding

About 17 minutes to read · every paper named here has its own page in this library

What it is

When someone tells a phone assistant "wake me at seven tomorrow", the software has to recognise the request (setting an alarm) and pull out its details (the time, the day). When a student asks a search engine who won a battle, a system has to find a passage and pick out the answer. Both jobs belong to natural language understanding: getting from a string of words to something a program can act on.

NLU is usually placed inside natural language processing, the wider field that covers every computational treatment of language, from tokenizing to translating. It is often contrasted with natural language generation, which goes the other way, from data or meaning to text. The split is useful but not sharp. Many tasks need both directions, and some modern systems are trained to do both with a single network (Dong et al. 2019).

"Understanding" in NLU is an engineering label. It names a family of tasks on which a system can be scored. It is not a claim that the system grasps language the way a person does. Whether such a claim could ever be justified is a live research question (see Open questions).

The component tasks fall into a few groups:

• Intent detection and slot filling. This is the core of voice assistants and task-oriented chatbots: classify the user's goal and fill a frame of arguments (Coucke et al. 2018).
• Textual entailment, also called natural language inference (NLI). The system decides whether a hypothesis follows from a premise, contradicts it, or is neither (Parikh et al. 2016).
• Reading comprehension and question answering. The system answers questions about a passage (Rajpurkar et al. 2016).
• Semantic parsing. The system translates a sentence into a logical form or an executable query.
• Coreference resolution. The system links the expressions that refer to the same entity.
• Commonsense inference. The system fills in what a text leaves unsaid about people, events and the physical world (Sap et al. 2019).

Supporting analyses feed these tasks: named entity recognition, word sense disambiguation, semantic role labeling and dependency parsing.

How it works

From words to representations

Every NLU system first turns text into units, typically words or subword tokens (see subword tokenization). Each unit is then mapped to a vector.

Early neural systems used fixed word embeddings. These rest on distributional semantics, an idea usually traced to Harris (1954) and Firth (1957). Contemporary systems instead compute contextual vectors with a pretrained Transformer encoder, the architecture introduced by Vaswani et al. (2017).

BERT pre-trains such an encoder by hiding some input tokens and asking the network to restore them from both sides of the context. A second objective predicts whether two sentences follow each other. The same network is then fine-tuned for a target task by adding a small output layer (Devlin et al. 2019).

Task heads

On top of the encoder, each task needs its own output head.

• Classification tasks such as sentiment, entailment or intent read a pooled sentence vector and apply a softmax over labels.
• Sequence labelling tasks such as slots or entities predict a tag for every token.
• Extractive reading comprehension predicts where an answer starts and ends inside the passage. BiDAF does this (Seo et al. 2016), and so does fine-tuned BERT on SQuAD (Devlin et al. 2019).

The standard span model, as in BiDAF, scores each passage position i (Seo et al. 2016):

P(start = i) = exp(wₛ · hᵢ) / Σⱼ exp(wₛ · hⱼ)
P(end = k)   = exp(wₑ · hₖ) / Σⱼ exp(wₑ · hⱼ)

Here hᵢ is the contextual vector of the i-th passage token, and wₛ and wₑ are learned weight vectors for the start and the end. The sum over j runs over all passage tokens. The predicted answer is the span (i, k), with k not before i, that maximises the product of the two probabilities.

Training minimises the negative log-probability of the gold start and end positions. Gated self-matching networks use the same loss, but they produce the two positions with a pointer network rather than with two independent softmaxes (Wang et al. 2017).

Pairs of texts

Inference and question answering compare two texts. Before pretraining took over, much of the design effort went into how the two texts interact.

• The decomposable attention model softly aligned words across premise and hypothesis, compared the aligned pieces and summed the evidence. This proved enough to rival large recurrent encoders on entailment (Parikh et al. 2016).
• BiDAF let attention run from passage to question and from question to passage at every position, without collapsing the passage into a single vector (Seo et al. 2016).
• In a BERT-style encoder, both texts are simply concatenated with a separator, and self-attention handles the interaction (Devlin et al. 2019).

Spoken input

In a voice assistant, NLU sits after speech recognition. The Snips platform trained its recognizer's language model jointly with the intent-and-slot engine, so that the two are consistent and specialised to each assistant's domain. The whole pipeline ran offline, in real time, on a Raspberry Pi 3 (Coucke et al. 2018).

History

Rule-based understanding goes back to a few early programs: Weizenbaum's ELIZA (1966), Woods's LUNAR question-answering system over a lunar-rock database (1973), and Winograd's SHRDLU (1972). ELIZA relied on pattern matching rather than any analysis of meaning. LUNAR and SHRDLU worked inside narrow, hand-built worlds.

From 2005, the PASCAL Recognizing Textual Entailment challenges moved evaluation to open text by framing inference as a shared task. The third round appeared in 2007 (Giampiccolo et al. 2007). MCTest, released in 2013, offered fictional children's stories with multiple-choice questions. On its MC500 set a lexical baseline answered about 58% of test questions, and an off-the-shelf entailment system did worse than that baseline (Richardson et al. 2013).

The decisive change was scale. In 2015 SNLI supplied entailment data large enough to train neural networks (Bowman et al. 2015), with about 570k labelled sentence pairs (Conneau et al. 2017). SQuAD followed in 2016 for span-based reading, with 107,785 question–answer pairs over 536 Wikipedia articles (Rajpurkar et al. 2016).

A burst of neural readers came next:

• BiDAF (Seo et al. 2016);
• gated self-matching networks (Wang et al. 2017);
• the recurrence-free QANet (Yu et al. 2018).

In the same period, sentence encoders trained on entailment data were shown to transfer to many downstream tasks (Conneau et al. 2017).

GLUE, released in 2018, gathered nine English sentence-level tasks under one score and one leaderboard (Wang et al. 2018). A few months later BERT raised the best GLUE score by 7.7 points, to 80.5, and set new results on eleven tasks (Devlin et al. 2019). The previous best had been OpenAI GPT's 72.8 (Dong et al. 2019).

A wave of variants followed:

• multi-task fine-tuning (Liu et al. 2019);
• permutation objectives (Yang et al. 2019);
• continual multi-task pretraining (Sun et al. 2019);
• hybrids of the masked and permuted objectives (Song et al. 2020).

As models approached GLUE's own estimate of non-expert human performance, SuperGLUE was first released in May 2019 as a harder successor. By July 2019 the top GLUE entry had passed that estimate (Wang et al. 2019).

The same years produced a critical literature. It showed that high scores could rest on artefacts of how datasets were built (Gururangan et al. 2018; Poliak et al. 2018; McCoy et al. 2019). A related, more fundamental argument, made in 2020, held that training on form alone cannot yield meaning (Bender & Koller 2020).

With large language models, evaluation moved again. The focus shifted to broad knowledge exams taken without fine-tuning (Hendrycks et al. 2020) and to their harder successors (Wang et al. 2024).

Methods

Neural readers and matching networks

Before pretraining, architecture engineering dominated.

BiDAF stacked six layers: character embedding, word embedding, a contextual recurrent layer, bidirectional attention flow, a modelling layer and a span output layer. When it was submitted it led the SQuAD leaderboard (Seo et al. 2016).

Gated self-matching networks added a relevance gate on the passage and let the passage attend to itself to collect distant evidence. A single model reached 71.3% exact match on the hidden SQuAD test set (Wang et al. 2017).

QANet replaced recurrence with convolution and self-attention, which made it train several times faster. It spent the saved compute on back-translation augmentation. A single model scored 84.6 F1 on the SQuAD test set (Yu et al. 2018).

DiSAN showed that direction-masked self-attention alone could encode sentences competitively, without recurrent or convolutional layers (Shen et al. 2017). For entailment, the decomposable attention model matched the best published SNLI accuracy, 86.3%, with roughly a tenth of the parameters of the strongest recurrent model (Parikh et al. 2016).

Moving from paragraphs to documents raised a further problem: scores from different paragraphs have to be comparable. Clark and Gardner trained on paragraphs both with and without the answer, and normalised the softmax jointly across paragraphs. This made confidence-based selection over many paragraphs work on TriviaQA (Clark & Gardner 2017).

Pretrained encoders

Pretraining changed the recipe to "pretrain once, fine-tune everywhere". BERT's masked-token objective, described under How it works, gave bidirectional context (Devlin et al. 2019).

• XLNet kept an autoregressive model but sampled random factorisation orders. On average, each token learns from both sides without seeing artificial mask symbols. In comparable settings it beat BERT on 20 tasks (Yang et al. 2019).
• MPNet folded the masked and permuted objectives into one framework and added position information for the tokens being predicted (Song et al. 2020).
• DeBERTa kept separate content and position vectors for each token and built attention from their cross-terms. Its 1.5B-parameter version was the first single model to pass the SuperGLUE human baseline (He et al. 2020).
• ERNIE 2.0 added seven pretraining tasks in sequence, each trained jointly with those before it. The tasks ranged from knowledge masking to discourse relations (Sun et al. 2019).

The approach spread to other languages. AraBERT, for example, trained a BERT-base model on about 24GB of Arabic text that had been morphologically segmented before subword tokenization (Antoun et al. 2020).

Domain adaptation could be done cheaply. Post-training BERT on in-domain reviews and on general reading-comprehension data improved review question answering and aspect-based sentiment analysis (Xu et al. 2019). For deployment, knowledge distillation compresses large encoders into small students (Jiao et al. 2020).

Multi-task learning, prompts and few-shot learning

MT-DNN refined a shared BERT encoder on all GLUE tasks at once, with one head per task type. Its representations adapted to new domains with very little data. With 0.1% of the SNLI training set it reached 82.1% dev accuracy, against 52.5% for plain BERT (Liu et al. 2019).

Intermediate training on a related labelled task before the target task also helps; Phang et al. (2018) called this approach STILTs. In the SuperGLUE baselines, an extra MultiNLI stage gained 2–5 points on BoolQ, CB and RTE, and an extra SWAG stage gained 8 points on COPA (Wang et al. 2019).

Pattern-Exploiting Training turns inputs into cloze questions and maps each label to a single word. It fine-tunes one masked model per pattern, then distils the ensemble on unlabelled text. This makes classification and inference with few-shot learning practical (Schick & Schütze 2021). It also anticipates the prompt engineering of later large models.

UniLM showed that one network can serve both understanding and generation by switching only its self-attention mask (Dong et al. 2019).

Explanations and knowledge

Another line of work asks systems to justify their answers. e-SNLI added free-text human explanations to every SNLI pair. A model seeing only the hypothesis could guess labels from artefacts, but those artefacts helped much less when the model also had to produce a correct explanation (Camburu et al. 2018).

On CommonsenseQA, one system first fine-tuned a language model to generate explanations and then fed its output to a classifier. It reached about 65% accuracy on version 1.0 (Rajani et al. 2019).

Links to knowledge representation appear in resources such as SocialIQA. Its questions follow the inference dimensions of a commonsense knowledge graph (Sap et al. 2019).

Beyond text

Language understanding also matters in multimodal models. Imagen, a text-to-image generator, found that enlarging its frozen text encoder improved image fidelity and prompt alignment more than enlarging the image generator did (Saharia et al. 2022). BLIP (Li et al. 2022) and MiniGPT-4 (Zhu et al. 2023) treat vision-language understanding as aligning images with a language model's representations.

Datasets and benchmarks

Arguably, evaluation benchmarks have shaped NLU more than any single method. The GLUE, SuperGLUE and MMLU timelines below suggest a cycle:

1. A new dataset exposes a gap between models and people.
2. Models close much of the gap, often within a year or two.
3. Analysis shows that part of the closing came from shortcuts.
4. A harder dataset follows.

Entailment

The RTE challenges set the task format (Giampiccolo et al. 2007). SNLI then supplied the training scale described under History (Bowman et al. 2015). Adversarial NLI later collected examples over several rounds, with annotators writing items specifically to fool strong models (Nie et al. 2020).

Reading comprehension

The reading datasets differ in how answers are formed and in which skill each is meant to test:

NarrativeQA asks questions about whole books and film scripts (Kočiský et al. 2018). Cosmos QA requires commonsense inference about what everyday passages leave unstated (Huang et al. 2019). DROP also tests the boundary with semantic parsing: pipelined parsers found logical forms for only about a third of its training questions (Dua et al. 2019).

Commonsense

SocialIQA has about 38k multiple-choice questions about motives, reactions and consequences in social situations. BERT-large scored 64.5% on it, while humans scored near 90% (Sap et al. 2019).

Its wrong options were built carefully. Some are correct answers to a related question about the same situation. This design was meant to remove the stylistic cues that otherwise give away distractors written by crowdworkers.

Aggregate suites and their saturation

GLUE grouped single-sentence, similarity and inference tasks. It added a diagnostic set of 550 expert-built NLI pairs, each tagged by linguistic phenomenon. Its best initial baseline averaged 69.0 (Wang et al. 2018).

Saturation came fast. In July 2019 XLNet's 88.4 exceeded GLUE's human estimate of 87.1 (Wang et al. 2019).

SuperGLUE answered with eight harder tasks, including BoolQ, COPA, MultiRC, ReCoRD, WiC and the Winograd schemas (after Levesque, 2011). Coreference and word sense thus entered the suite. At launch, BERT-based systems trailed humans by close to 20 points on average (Wang et al. 2019). That margin also closed: DeBERTa's single 1.5B model scored 89.9, against a human baseline of 89.8 (He et al. 2020).

The MMLU authors noted that GLUE, SuperGLUE and commonsense suites had each saturated within about a year. They proposed a 57-subject exam taken zero-shot or few-shot. On it, the 175B GPT-3 reached 43.9%, while expert-level accuracy was estimated near 89.8% (Hendrycks et al. 2020).

By 2024 frontier models scored around 86–87% on MMLU. MMLU-Pro then filtered out easy items, raised the options per question from four to ten and cleaned label errors. This lowered accuracy by 16 to 33 percentage points across models (Wang et al. 2024).

MS MARCO had followed the same pattern earlier. Machines passed its first human baseline within about 15 months, and the authors had to build a stronger one (Bajaj et al. 2016).

Shortcuts

Many results show that benchmark gains can come from the dataset rather than from understanding.

• Crowd-written entailment hypotheses carry annotation artefacts, such as words that correlate with a label (Gururangan et al. 2018). A classifier that never sees the premise can therefore beat the majority baseline (Poliak et al. 2018).
• Models trained on MNLI adopt syntactic heuristics such as lexical overlap. HANS is a test set built to break these heuristics. On its items whose hypothesis is not entailed, BERT falls well below chance (McCoy et al. 2019; Bender & Koller 2020).
• Niven and Kao (2019) found a similar collapse for BERT on the Argument Reasoning Comprehension Task. Its results dropped to chance once adversarial negated examples were added (Bender & Koller 2020).
• Appending distracting but irrelevant sentences to SQuAD passages sharply misleads reading systems (Jia & Liang 2017).
• A hand analysis of the CNN/Daily Mail cloze task found that most answerable questions need only one matched sentence. About a quarter are damaged by coreference or anonymisation errors (Chen et al. 2016).

Dataset designers responded in several ways:

• they wrote questions without seeing the evidence (Joshi et al. 2017; Trischler et al. 2017);
• they kept only questions that a running model failed (Dua et al. 2019);
• they ran human-and-model adversarial loops (Nie et al. 2020);
• they required evidence from several sentences (Khashabi et al. 2018).

People and institutions

A few groups built much of the evaluation infrastructure.

Samuel R. Bowman co-led SNLI (Bowman et al. 2015), GLUE (Wang et al. 2018) and SuperGLUE (Wang et al. 2019). He also co-authored the study of annotation artefacts (Gururangan et al. 2018).

Christopher Manning, at Stanford University, co-authored SNLI (Bowman et al. 2015) and the critical examination of the CNN/Daily Mail task (Chen et al. 2016). Also at Stanford, Percy Liang's group produced SQuAD (Rajpurkar et al. 2016) and its adversarial stress tests (Jia & Liang 2017).

Ido Dagan, at Bar-Ilan University, helped organise the textual entailment challenges (Giampiccolo et al. 2007).

Commonsense and reading work is strongly associated with Yejin Choi, now at Stanford, through SocialIQA (Sap et al. 2019) and Cosmos QA (Huang et al. 2019).

Matt Gardner co-authored DROP (Dua et al. 2019) and the shared-normalisation method for multi-paragraph reading (Clark & Gardner 2017). Both were built in the ecosystem of the Allen Institute for Artificial Intelligence.

Several other authors each co-created a major dataset:

• Luke Zettlemoyer, at the University of Washington and Meta, co-created TriviaQA (Joshi et al. 2017).
• Eduard Hovy, now at the University of Melbourne, co-authored RACE (Lai et al. 2017).
• Dan Roth, at the University of Pennsylvania, co-authored MultiRC (Khashabi et al. 2018).
• Mohit Bansal, at the University of North Carolina at Chapel Hill, co-authored Adversarial NLI (Nie et al. 2020).

The diagnosis of entailment shortcuts owes much to three researchers who together introduced hypothesis-only baselines (Poliak et al. 2018):

• Adam Poliak, now at Bryn Mawr College;
• Rachel Rudinger, now at the University of Maryland, College Park;
• Benjamin Van Durme, at Johns Hopkins University and Microsoft.

Industrial labs, often working with universities, drove much of the modelling. Google produced BERT (Devlin et al. 2019). Carnegie Mellon University and Google Brain together produced XLNet (Yang et al. 2019) and QANet (Yu et al. 2018).

At Microsoft, Jianfeng Gao and Xiaodong Liu co-authored MT-DNN (Liu et al. 2019), DeBERTa (He et al. 2020) and MS MARCO (Bajaj et al. 2016). Furu Wei, also at Microsoft, co-authored gated self-matching networks (Wang et al. 2017) and UniLM (Dong et al. 2019).

Caiming Xiong, at Salesforce, co-authored the explanation-based commonsense work (Rajani et al. 2019) and BLIP (Li et al. 2022).

Open questions

Meaning versus form

The deepest dispute concerns what NLU systems learn. Bender and Koller define meaning as a relation between expressions and something outside language:

M ⊆ E × I
C ⊆ E × S

Here E is the set of linguistic expressions and I the set of communicative intents, so M pairs each expression with what a speaker could mean by it. S is the set of standing, conventional meanings that can be evaluated against a world, and C pairs expressions with those.

On this view, understanding means recovering an intent i from an expression e. A system trained only to predict strings sees E and nothing else, so it receives no signal about I or S (Bender & Koller 2020).

Their thought experiment makes the point with an octopus that eavesdrops on two people. The octopus learns the pair's message statistics but cannot respond sensibly when something new happens. The argument echoes Searle (1980) and the grounding problem in cognitive science. It also draws on pragmatics, where meaning depends on intent, as in Grice's (1975) implicature.

The paper itself takes up grounding in distributional semantics. It also reviews probing studies, such as Tenney et al. (2019) and Hewitt and Manning (2019), which show that language models encode formal structure like agreement and dependency structure (Bender & Koller 2020). Whether that structure, or richer grounded input, amounts to meaning is exactly what remains contested.

Evaluation that lasts

GLUE, SuperGLUE and MMLU each lost most of their headroom within a few years of release (Wang et al. 2019; He et al. 2020; Wang et al. 2024). Several fixes are in use:

• adversarial collection (Nie et al. 2020);
• harder formats (Wang et al. 2024);
• diagnostic sets tagged by phenomenon (Wang et al. 2018).

All of them buy time without settling what a fixed test set can certify.

Prompt sensitivity adds a further problem. Across 24 prompt wordings, MMLU scores move by 4–5 points, against about 2 points on MMLU-Pro (Wang et al. 2024).

Human baselines are themselves unstable. They depend on who the annotators are and on how the baseline is assembled. Crowdworkers score 34.5% on MMLU, against an estimated 89.8% for experts (Hendrycks et al. 2020). MS MARCO's baseline had to be rebuilt from its five best editors (Bajaj et al. 2016).

Robustness and reasoning

Shortcut learning remains unsolved. Models that rely on overlap, on artefacts in hypotheses, or on distracting sentences can still post high in-distribution scores (McCoy et al. 2019; Gururangan et al. 2018; Jia & Liang 2017).

Discrete reasoning (counting, arithmetic, comparison) exposed a wide gap for span-extraction readers (Dua et al. 2019). Social and contextual commonsense also lagged far behind humans when those datasets were introduced (Sap et al. 2019; Huang et al. 2019).

It is unresolved whether explanation-based training yields more faithful reasoning or only more fluent rationales. Generated explanations transferred to new datasets in fluent form, yet accuracy there fell slightly (Rajani et al. 2019).

Social bias carried over from training data is a related concern. The explanation work on CommonsenseQA found gender bias inherited from that dataset (Rajani et al. 2019). In the multimodal setting, Imagen's authors reported skews toward lighter skin tones and Western gender stereotypes, and they withheld the model partly for that reason (Saharia et al. 2022).

Coverage and deployment

Most benchmarks are English. Monolingual models for languages such as Arabic show that a dedicated model can do better than a multilingual one. AraBERT beat multilingual BERT on most of its sentiment, named-entity and question-answering benchmarks (Antoun et al. 2020). The broader agenda lives in multilingual NLP and low-resource languages.

Practical systems also need small, private and fast models. This motivates distillation (Jiao et al. 2020) and on-device understanding (Coucke et al. 2018).

What remains open is how to keep the accuracy of large pretrained encoders while meeting these constraints. A second open problem is making NLU interpretable enough to tell whether a correct answer was reached for the right reasons. That is the concern of research on interpretability.

The library in figures