A dialogue state tracker is the component of a task-oriented assistant that reads each user turn and updates a structured record of what the user wants, for example "restaurant area = centre, people = 4". The strongest trackers do not simply read the whole conversation as flat text. They maintain a small, evolving graph over the schema, that is, over the list of slots the system can fill, and at each turn they add or remove links between slots. Two slots are linked when one refers back to the other, when both are updated in the same turn, or when they tend to appear together. These trackers are known to be fragile. When users pursue unusual combinations of goals, accuracy collapses. The usual cure for fragility is adversarial training, which trains the model on worst-case inputs found by an inner optimization. For text this is very expensive, because finding a single damaging word substitution can take thousands of forward passes through a large encoder.
Our proposal starts from one observation. In a schema-graph tracker, most failures should pass through a tiny discrete bottleneck: a wrong link between slots, or a wrong value carried over from the previous turn's state. That bottleneck has a few dozen slots and a few hundred possible links, against a vocabulary of tens of thousands of words. We therefore run the adversary directly on the structured state and the dynamic schema links, rather than on the words. Because the text encoder's output can be computed once and cached, each inner attack step backpropagates only through the small graph layers. The claim to be tested is that worst-case training in this structured space gives most of the robustness of text-level adversarial training, against both word-level attacks and counterfactual goal shifts, at a small fraction of the cost. It should also fix the cascading errors that arise when a tracker trusts its own previous prediction.
Core Claim
Take a tracker $f_\theta$ that predicts the belief state $B_t$ from the current utterance encoding $h_t$, the previous belief state $B_{t-1}$, and the dynamically built schema graph $G_t$. We train it with
$$\min_\theta \; \mathbb{E}_{t}\; \max_{\tilde B_{t-1},\,\tilde G_t \,:\, d(\tilde B_{t-1},B_{t-1}) + d(\tilde G_t,G_t)\le k} \mathcal{L}\big(f_\theta(h_t,\tilde B_{t-1},\tilde G_t),\,B_t\big).$$
Here $d$ counts changed slot values or flipped schema links, $k$ is a small perturbation budget, and $\mathcal{L}$ is the usual slot-prediction loss. The inner maximization relaxes link indicators and slot choices to continuous weights. It takes one or two gradient steps through the graph fusion layers only, then rounds to the top-$k$ discrete changes. The encoder is kept frozen during the inner loop, and $h_t$ is cached.
The new element is where the adversary acts. Prior work attacks text, attacks static graphs, or augments data offline. Here the adversary acts on the turn-by-turn schema structure that dialogue trackers build for themselves.
Where This Sits
The tracker we harden is Dynamic Schema Graph Fusion Network (DSGFNet). It builds co-reference, co-update, and co-occurrence links between slots at every turn and reports 56.7% joint goal accuracy on MultiWOZ 2.1. It assumes clean input and has never been stress-tested. Its explicit dynamic links are what give our adversary something small to attack.
Efficient Context and Schema Fusion Networks (CSFN-DST) drops the raw history and conditions only on the current turn and the previous predicted state. Its authors flag exposure bias: errors in the carried-over state cascade forward. Perturbing $B_{t-1}$ is aimed directly at that weakness. We use CSFN-DST as a second host architecture.
The motivating evidence comes from CoCo, which rewrites goals into rare slot combinations. TRADE drops from 49.4% to 18.6% joint goal accuracy on these rewrites, and TripPy drops by more than 25 points. CoCo attributes the failures to trackers leaning on slot co-occurrence. That is exactly a statement about spurious schema links, which is why we expect link-space attacks to reach the same failures. CoCo itself is offline, heuristic augmentation: it trains a T5 generator and filters, then retrains the tracker. It is not a worst-case search, and it remains our main competitor.
On the adversarial side, MeLA / MeLA-D supplies the method template. It perturbs graph structure and trains the network against those perturbations with a minimax objective, using a linear surrogate to cut cost. However, its graphs are static citation and co-authorship networks, and it still runs multi-step attacks every epoch. We differ in two ways: our graphs are rebuilt at every turn, and we cache the expensive encoder rather than approximate the whole network.
State-Aware Adversarial Training for Utterance-Level Dialogue Generation is the closest work inside dialogue. It adds state awareness to adversarial training for response generation, but the adversary works at the utterance level and there is no explicit schema graph.
Towards Improving Adversarial Training of NLP Models documents the cost we are trying to avoid: word-level attacks need thousands of forward passes. It is therefore the natural expensive upper reference.
Two cheaper defenses constrain our design. Dynamic Attention masks the most-attended tokens at inference time. Robustness Tokens trains ten input vectors on a frozen vision transformer in 200 steps. Both show that robustness need not require full retraining. Both were also evaluated only on coarse classification or vision tasks, and masking high-attention tokens is risky in a tracker whose job is to find exactly those tokens.
Research Program
The work has three parts, and they run in order.
The first part is diagnostic, and it decides whether the method is worth building. We attack a trained DSGFNet with word-level attacks and with CoCo counterfactuals, and on every failed turn we record whether the predicted schema links or the carried-over state differ from those built from gold input. If most failures leave the structured state intact, the bottleneck hypothesis is wrong. In that case we report the negative result and stop, rather than tune around it.
The second part builds structured-space adversarial training on DSGFNet and CSFN-DST, with a separate budget $k$ for links and for slot values. It uses the cached-encoder inner loop described above, plus a variant that unrolls perturbations over two consecutive turns to target cascades.
The third part is accounting. We report forward and backward passes per update, and wall-clock hours, for every training scheme, so that "cheap" is a measured quantity rather than a slogan.
Baselines
The naive reference is DSGFNet and CSFN-DST trained normally with gold previous states. The number to match on clean data is DSGFNet's reported 56.7% joint goal accuracy on MultiWOZ 2.1 and 55.8% on MultiWOZ 2.2, from Dynamic Schema Graph Fusion Network. We found no reported result on Lacuna for DSGFNet under CoCo counterfactuals or word-level attacks, so we measure these ourselves.
The strongest existing robustness method for this question is CoCo augmentation, because it targets the same co-occurrence failure. On TripPy it improved clean accuracy by 1.3% and recovered much of the counterfactual drop. We regenerate CoCo data with its published pipeline, retrain the same host trackers on it, and charge the generator and filter training to its compute bill. We also run it combined with our method.
The key ablation is random structured corruption: slot values and links are flipped uniformly at random, with the same budget $k$ and the same number of training steps. This isolates whether the worst-case choice matters or only the exposure to noisy states. A related baseline trains on the tracker's own predicted previous states, which directly addresses exposure bias.
We also run cheap embedding-space adversarial training, meaning one-step gradient perturbations of word embeddings. No citation for this appears on Lacuna, so we describe it only as the standard cheap text defense.
Dynamic Attention is applied at inference to the unmodified tracker. On a 20% subset of training dialogues we run full word-substitution adversarial training as an expensive ceiling.
All methods share the encoder, data, and number of epochs. Each receives the same hyperparameter search budget of twelve configurations, selected on clean validation plus a held-out attack.
Beating the field means three things at once. Our method must be at or above CoCo's counterfactual accuracy. It must stay within one point of clean accuracy. And it must use at most a third of CoCo's total compute or of embedding-space training's per-step cost. It must also clearly beat random corruption at matched budget.
Why not just…?
Why not just use CoCo augmentation? This is the real threat. CoCo's counterfactuals already target co-occurrence shortcuts and produced clean gains. Our argument has two parts. First, CoCo samples rare goals from a dictionary rather than searching for the worst case, so trackers can remain exposed to adaptive attacks. Second, it needs a separate generator, filters, and full retraining. The experiments settle this with head-to-head counterfactual accuracy, word-attack accuracy, and total compute. If CoCo matches us on all three, the contribution reduces to the diagnostic, and we will say so.
Why not just corrupt the previous state randomly, or train on predicted states? This is the cheapest version of our idea and could plausibly be enough. Nothing in the file shows that worst-case search helps in state space specifically. The matched-budget random-corruption ablation exists to answer exactly this question. If random corruption matches worst-case corruption, we report random structured noise as the recommended cheap method.
Why not just do fast adversarial training on word embeddings? It is cheap per step, but it still backpropagates through the full encoder in every inner step. It also perturbs continuous embeddings that correspond to no real input, so it gives no direct protection to the schema links. We compare robustness against counterfactuals and discrete word attacks at equal wall-clock time.
Why not just apply Dynamic Attention at inference? It needs no training, but Dynamic Attention masks the most-attended tokens. In a tracker, those are often the slot values that must be copied as spans. We expect it to hurt clean accuracy on the non-categorical slots of MultiWOZ 2.2, where values must be extracted as exact character spans, and we measure that clean cost directly.
Why not just use MeLA-D's surrogate? Its linear surrogate is fitted to a fixed incidence structure. Our graphs are rebuilt at every turn, so a single surrogate cannot follow them. Caching the encoder gives exact gradients through the real graph layers at a similar cost.
Proposed Experiments
The benchmarks are MultiWOZ 2.1 and 2.2 for clean joint goal accuracy, CoCo counterfactual test sets rebuilt from MultiWOZ 2.1, and SGD unseen services for zero-shot transfer. For SGD unseen, DSGFNet reports 24.4% joint goal accuracy, and we check that hardening does not erase that transfer.
The attacks are word-level substitution attacks of the kind Dynamic Attention evaluates against, such as TextFooler and PWWS. We also run an adaptive structured attack that knows our training scheme. As a cascade test, we inject a single wrong slot at turn $t$ and count how many later turns remain wrong.
The metrics are clean and attacked joint goal accuracy, the rate of false schema links, cascade length, and training compute.
The decisive checks are three. First, the diagnostic must show that most attack successes corrupt the structured state. Second, worst-case structured training must beat matched random corruption on counterfactuals and word attacks. Third, it must reach CoCo's counterfactual robustness at a clearly lower compute cost. Failing the first check ends the method. Failing the second changes the recommendation to random structured noise.
References
- Dynamic Schema Graph Fusion Network for Multi-Domain Dialogue State Tracking
- Efficient Context and Schema Fusion Networks for Multi-Domain Dialogue State Tracking
- CoCo: Controllable Counterfactuals for Evaluating Dialogue State Trackers
- Adversarial Attacks and Robust Training for Hypergraph Neural Networks
- State-Aware Adversarial Training for Utterance-Level Dialogue Generation
- Towards Improving Adversarial Training of NLP Models
- Improving the Robustness of Transformer-based Large Language Models with Dynamic Attention
- Robustness Tokens: Towards Adversarial Robustness of Transformers