A dialogue state tracker is the component of a task-oriented assistant that records what the user wants: which hotel area, what price range, which train time. It rewrites that record after every turn. Recent trackers become far more data-efficient when they retrieve candidate slot–value pairs from an external knowledge base and read them alongside the conversation. On MultiWOZ 2.4 with 1% of the training data, such retrieval lifts a T5-base tracker from 16.37% to 34.89% joint goal accuracy (Knowledge-grounded Dialog State Tracking). The same paper reports the catch. Retrieved entries that look like the right answer but are wrong for this turn flow directly into the predicted state, and a value the user mentions that is missing from the knowledge base cannot be produced at all. Both failures have one root cause. The decoder is allowed to emit a knowledge-base value without showing where in the conversation the user asked for it.
We propose to reverse the order of operations. The tracker must first point to a span of the dialogue, meaning a user phrase, a system offer the user accepted, or an earlier slot in the state. Only then may it either copy that span verbatim or map it to a canonical value retrieved from the knowledge base. Retrieval is demoted from a source of answers to a lookup table for normalizing what was actually said. A confusable distractor can win only if some dialogue span supports it. A novel entity absent from the knowledge base survives because the span itself is copied. The central claim is that this ordering lets a small tracker keep the data efficiency that knowledge retrieval provides while making its errors under noisy retrieval both rarer and different in kind: missed values rather than confidently adopted distractors.
Core Claim and Mechanism
A pointer-generator is a decoder that at each step mixes generating a word from its vocabulary with copying a token from the input through attention (Pretrained Language Model for Text Generation: A Survey). Existing uses of copying and of knowledge in state tracking have treated the two as separate, parallel channels. TRADE copies tokens from the dialogue history (Transferable Multi-Domain State Generator for Task-Oriented Dialogue Systems). TripPy copies spans from user turns, system informs, and the prior state (TripPy: A Triple Copy Strategy for Value Independent Neural Dialog State Tracking). Neither consults a knowledge base, and both emit surface strings that need heuristic normalization, such as mapping "center of town" to the schema value centre. Knowledge-grounded tracking does the opposite. It prepends retrieved entries as flat text and generates freely. FiD-PGN adds a copy gate over retrieved passages in question answering (A Copy-Augmented Generative Model for Open-Domain Question Answering), but its pointer pools attention over every passage token, so a distractor entity of the right type is as copyable as the answer.
Our tracker instead factors each slot value through a mandatory dialogue anchor. For slot $s$, the model first computes a distribution $\alpha$ over candidate anchors $i$. These are dialogue spans, system-offered values, previous-state slots, and an explicit null anchor meaning the slot is not mentioned. The value distribution is then
$$P(v \mid s) = \sum_i \alpha_i \Big[ \lambda_i \,\mathbb{1}[v = \mathrm{text}_i] + (1-\lambda_i)\, q(v \mid \mathrm{text}_i, K_s) \Big],$$
The symbols are as follows. $\mathrm{text}_i$ is the anchor's surface string. $\lambda_i$ is a learned gate choosing verbatim copy. $K_s$ is the set of knowledge-base entries retrieved for slot $s$. $q$ is a pointer over whole entries in $K_s$, scored by encoder attention between the anchor and each entry.
A retrieved entry therefore enters the output only through a specific anchor. Copying whole entries yields canonical values. Setting $\lambda_i$ high handles open-set values. The null anchor gives the model a clean way to abstain when retrieval surfaces something the dialogue never supports.
We build this on T5-base and T5-large, following the backbone of Knowledge-grounded Dialog State Tracking. Slot names and natural-language slot descriptions are placed in the input so the model is schema-guided in the sense of Towards Scalable Multi-Domain Conversational Agents: The Schema-Guided Dialogue Dataset rather than tied to fixed per-slot heads. We supervise anchor pointing with span annotations where they exist. Where they do not, we treat the anchor as latent and marginalize over it as in the equation above. The added parameters are a few scoring projections that reuse cross-attention, in the spirit of FiD-PGN's 1,537-parameter copy head.
Research Program
The work has three parts. First, we build the anchored tracker and a matched unanchored tracker that differ only in whether knowledge-base entries can be selected directly or only through an anchor. Second, we build a controlled noise protocol for the retrieved context. This goes beyond Yu et al.'s observation of "baseline tolerance" to generic distractors. We inject confusable distractors: values of the same slot that are close in surface form or embedding to the gold value, such as a neighboring area or a similar restaurant name. We vary two things independently: how many distractors appear in the top-$k$, and their position relative to the gold entry. Third, we build a closed-set stress test in which we delete the gold entity from the knowledge base at test time, so that only a verbatim dialogue copy can recover it.
The analysis centers on two error measures. The first is the distractor adoption rate, the fraction of errors in which the predicted value is exactly an injected distractor. The second is the novel-value recovery rate. The prediction is that anchoring collapses the first toward zero and keeps the second close to the rate on in-knowledge-base values, while joint goal accuracy in the clean few-shot setting is no worse than the unanchored retrieval tracker.
Baselines
The naive reference point is T5-base trained on the same 1% MultiWOZ 2.4 split with no retrieval. Knowledge-grounded Dialog State Tracking reports 16.37% joint goal accuracy for its D3ST baseline in this regime. We rerun it rather than rely on the reported figure.
The strongest competitor at matched scale is knowledge-grounded tracking itself. That paper reports 34.89% joint goal accuracy with T5-base at 1% data, 55.32% with T5-XXL at 1% data using type-plus-value retrieval, and about 75.5% with full data, all on MultiWOZ 2.4. It is the right opponent because it already delivers the data-efficiency gain we want to keep, and its known weakness is exactly the one we target. We reimplement it with the same retriever, the same top-$k$, the same backbone, and the same training steps and hyperparameter search budget as our tracker. Because its retriever is trained with a contrastive loss, we give both systems the same hard-negative-mined retriever. Beating it means equal or better clean joint goal accuracy at 1% and 5% data, together with a statistically significant reduction in distractor adoption and higher novel-value recovery under the stress tests. A clean-accuracy gain alone would not count.
The copy-only reference is a TripPy-style span tracker without a knowledge base, with normalization done by string-matching heuristics. TripPy: A Triple Copy Strategy for Value Independent Neural Dialog State Tracking reports 55.3% joint goal accuracy on MultiWOZ 2.1 with full data, and no reported result was found on Lacuna for TripPy in the 1% regime. It tells us how much of our gain comes from anchoring alone versus from the knowledge-base lookup.
For large-model in-context tracking we cite RefPyDST, which reports 47.9% zero-shot joint goal accuracy on MultiWOZ 2.4 and 95% of full-supervision performance with 5% data using Codex (Diverse Retrieval-Augmented In-Context Learning for Dialogue State Tracking). We treat it as a ceiling reference at roughly a thousand times our parameter count, not as a matched comparison.
Two ablations isolate the key ingredient. The first removes the anchor requirement but keeps the entry-level knowledge-base pointer, which amounts to a FiD-PGN-style pooled copy over dialogue and entries. The second keeps anchoring but disables the knowledge-base lookup. This leaves verbatim copying only, and it measures the canonicalization benefit.
Why not just…?
Why not just train the existing knowledge-grounded tracker with hard-negative distractors? This is the most serious threat. Augmenting training with confusable candidates may teach an unanchored decoder to ignore them. CoCo shows that counterfactual augmentation helps: retraining TripPy on its counterfactuals improves the clean test set by 1.3% (CoCo: Controllable Counterfactuals for Evaluating Dialogue State Trackers). We therefore give both arms the same hard-negative training. The decisive evidence is on distractor types held out from training and on the closed-set test. Augmentation can suppress distractors it has seen, but it cannot make an unanchored generator emit an entity absent from both its vocabulary and the retrieved set. If the augmented baseline matches us on both held-out distractors and novel values, the claim fails and we will say so.
Why not just constrain decoding to retrieved values plus dialogue substrings? A trie-constrained decoder removes out-of-set hallucination cheaply. However, it still lets the model pick a retrieved distractor that no dialogue span supports, and that is the dominant failure reported for knowledge-grounded tracking. We run constrained decoding on top of the unanchored baseline. If it closes the distractor-adoption gap, anchoring adds nothing beyond it.
Why not just add a cross-encoder reranker before the tracker? A reranker scores each entry against the whole dialogue, and confusable distractors are precisely the entries that such whole-context scoring confuses. Our anchor score is a localized version of the same signal. We include a reranker trained on the same data with the same budget. Our prediction is that it lowers adoption of easy distractors but not of close-in-surface-form ones. If it performs as well as our tracker, the contribution reduces to a cheaper architecture rather than a better one.
Why not just use a large model with in-context learning? RefPyDST's reported numbers are strong, but they depend on a 175-billion-parameter model and multi-pass rescoring that the authors note adds latency. Our target is the small, deployable regime where Yu et al.'s T5-base result lives.
Proposed Experiments
The main experiment trains all matched systems on 1%, 5%, and 100% of MultiWOZ 2.4 and reports joint goal accuracy on the clean test set. It then reports joint goal accuracy under the confusable-distractor protocol with 0, 2, 5, and 10 injected distractors in top-$k$, both at boundary positions and in the middle of the retrieved list. For each condition we report distractor adoption rate alongside accuracy. Three seeds per cell, with bootstrap confidence intervals over dialogues, determine significance.
The second experiment uses CoCo's counterfactual construction on MultiWOZ 2.1: rare slot combinations with out-of-domain values. Here TRADE falls from 49.4% to 18.6% and TripPy loses over 25 points (CoCo: Controllable Counterfactuals for Evaluating Dialogue State Trackers). We ask whether anchoring shrinks this drop, and we add the closed-set variant in which counterfactual values are absent from the knowledge base.
The third experiment tests transfer to unseen services on the Schema-Guided Dialogue dataset, using categorical schema values as the knowledge base. The original baseline reports 0.356 joint goal accuracy on seen services and 0.254 on unseen services, and SGP-DST reports about 88% versus about 67% (Fine-Tuning BERT for Schema-Guided Zero-Shot Dialogue State Tracking). Both papers attribute much of the gap to out-of-vocabulary free-form values, which is exactly where verbatim anchor copying should help.
The decisive checks are three. First, anchoring must match the unanchored knowledge-grounded tracker at 1% clean data. Second, it must cut distractor adoption on held-out confusable distractors beyond what hard-negative training, constrained decoding, and reranking achieve. Third, it must recover knowledge-base-absent values at a rate close to that on present ones.
If anchoring costs clean accuracy because too many gold values lack a clean dialogue span, as with implicit accepts or inferred booleans, the per-slot breakdown will show where. That result would bound the idea to slots whose values are explicitly mentioned.
References
- Knowledge-grounded Dialog State Tracking
- Pretrained Language Model for Text Generation: A Survey
- Transferable Multi-Domain State Generator for Task-Oriented Dialogue Systems
- TripPy: A Triple Copy Strategy for Value Independent Neural Dialog State Tracking
- A Copy-Augmented Generative Model for Open-Domain Question Answering
- Towards Scalable Multi-Domain Conversational Agents: The Schema-Guided Dialogue Dataset
- Diverse Retrieval-Augmented In-Context Learning for Dialogue State Tracking
- CoCo: Controllable Counterfactuals for Evaluating Dialogue State Trackers
- Fine-Tuning BERT for Schema-Guided Zero-Shot Dialogue State Tracking