A booking assistant trained on English London dialogues breaks when a Mandarin speaker asks about a Shanghai restaurant. Language is not the main reason. The model has never seen the entities: the restaurant names, districts and hotels that only exist locally. When the English benchmark MultiWOZ is localized to cities around the world, models trained only on English drop below 10% joint goal accuracy, the share of dialogue turns where every slot is right (GlobalWoZ). A deployed system does have one thing at hand in the target locale, though: a database of local entities. This proposal asks how to let a model trained only in English use a foreign-language database it has never seen, without any target-language labels.
The proposed answer is to put the database inside the decoder rather than the encoder or the training data. We use a conditional random field (CRF), a layer that scores a whole tag sequence at once, combining per-word scores with scores for moving from one tag to the next. To it we add a third kind of score: how well a stretch of words matches a database entry of a given slot type. The model learns in English how much to trust a database match, and that trust is a few scalar weights on match scores. Because those weights never touch words, they should carry over to Chinese, Arabic or Indonesian. At test time we replace the English database with the local one and change nothing else.
Core Claim
Entity knowledge given to a sequence labeler as language-independent span potentials, scored jointly by a CRF, transfers zero-shot across languages and locales better than the same knowledge given as encoder-side gazetteer features or as entity-swapping data augmentation. The CRF matters because database evidence arrives in span-shaped pieces that can overlap or partly match. Something has to settle the conflict between "the encoder thinks this is a time expression" and "these three tokens match a restaurant name at 0.8 similarity." Per-token classifiers cannot settle it without breaking spans apart.
Concretely, for an utterance $x$ with tags $y$ and a database $K$, the model scores
$$ s(y \mid x, K) = \sum_t E(x, t, y_t) + \sum_t A(y_{t-1}, y_t) + \sum_{(i,j,c) \in y} \lambda_c \, m_K(x_{i:j}, c), $$
The terms are defined as follows. $E$ is the per-token score from a multilingual encoder. $A$ is the usual learned tag-to-tag transition matrix. The last sum runs over the spans $x_{i:j}$ that $y$ labels with slot type $c$. $m_K(x_{i:j}, c)$ is the best match between that span and any entry of type $c$ in $K$. $\lambda_c$ is a learned per-slot trust weight. The match score is computed by a frozen multilingual sentence encoder, using cosine similarity of the span against each entry's native-script and romanized or English names, combined with character overlap. It is a number in $[0,1]$ in every language, and that is why $\lambda_c$ can transfer. For linear-chain decoding, the span term becomes extra scores on entering the begin tag and on staying inside the tag over any matched span. Exact Viterbi decoding therefore still applies. The parallel inference of Bregman CRFs, which matches standard CRF F1 and trains up to 7.3x faster, is an optional speedup when many candidate spans are matched.
Relation to Prior Work
Two lines of work motivate the gap. The localization datasets show that the failure is about entities: GlobalWoZ builds local ontologies and reports that translating entity names fails 60% of the time in real searches. Multi2WOZ finds that conversational ability transfers through specialized pretraining while exact state tracking stays poor. Both fix the problem with data, through curated translation or pretraining. Neither changes how the model decodes.
The closest methods supply knowledge differently. BiToD uses its bilingual database to swap entity mentions into training utterances (Mixed-Language Pre-training), which lifts zero-shot Chinese-to-English mBART from 4.64% to 55.39% joint goal accuracy. That knowledge is baked into the weights at training time, so it cannot follow a database that changes after deployment. Building Dialogue Understanding Models for Low-resource Language Indonesian from Scratch is the nearest work touching all three directions. It pairs code-mixing with a BiLSTM-CRF, but its transitions are static and syntactic, it never reads the database at decoding time, and its best results use about 16K Indonesian dialogues. We keep its CRF and drop its need for target labels.
CRF work supplies the mechanism. Multi-Task Cross-Lingual Sequence Tagging from Scratch and Low-Resource NER with Cross-Lingual Character-Level Neural CRFs show that CRF taggers transfer structure across related languages by sharing character models. Both still need some target supervision and use no outside knowledge. Phrase Grounding by Soft-Label Chain CRF is the precedent for conditioning CRF potentials on external evidence, there image regions, rather than fixed tag grammar. Its ablation is a warning: the CRF structure itself added only 0.4% accuracy. We take this to mean the gain has to come from the knowledge factor, not from the chain, and our ablations are built to test that.
A constraining result comes from generative tagging. Zero-Shot Cross-Lingual Sequence Tagging as Seq2Seq Generation shows that a carefully templated mT5 beats an XLM-R classification head by 5.0 Slot F1 across MASSIVE languages. That weakens any claim that CRFs win on tag grammar alone. We do not make that claim. On MASSIVE, where there is no database, we expect the CRF to match a softmax head, not beat a tuned mT5.
Research Program
We build three components. The first is the knowledge-conditioned CRF tagger on top of XLM-R, trained on English utterances with the English database. The second is a training procedure that keeps $\lambda_c$ honest. During source training we corrupt the database each step: we drop about a third of the entries and add distractor entries of the same type drawn from other cities. The model then learns that a match is strong but fallible evidence, and does not learn to copy whatever matches. Without this corruption, the model would learn on English that every gold entity is in the database, and it would over-trust partial matches abroad. The third is a thin rule-based state accumulator. It maps tagged spans to their matched database values and carries them across turns, so span tagging can be scored as joint goal accuracy and compared with the dialogue-state literature.
The analysis has three parts. We measure how $\lambda_c$ and match-score calibration hold up when the language changes. We break errors down by whether the gold entity is in the target database, partly matched, or missing. We also measure how accuracy degrades as the target database is made sparser. The last point checks that the model falls back to the encoder instead of failing when the database is incomplete, a target-side version of the retrieval-failure fallback noted in cross-lingual knowledge-grounded generation.
Baselines
The naive reference is XLM-R with a per-token softmax head, fine-tuned on English and applied directly. GlobalWoZ's reported number for English-trained zero-shot transfer to localized dialogues is below 10% joint goal accuracy. BiToD's vanilla mBART zero-shot number is 4.64%. We rerun the softmax tagger ourselves so all systems share an encoder.
The strongest existing method on a database-backed benchmark is BiToD's Mixed-Language Pre-training with mBART, reported at 55.39% joint goal accuracy for zero-shot Chinese to English. On GlobalWoZ the strongest reported result is its data augmentation (SUC and MBUC) at up to 60% joint goal accuracy. That uses the localized ontology during training, which our setting forbids, so we treat it as an upper reference rather than a competitor. We reimplement entity swapping on the same XLM-R tagger so the comparison isolates the knowledge mechanism rather than the backbone. We also report BiToD's own mBART pipeline. We beat MLT if our tagger, with no entity swapping, exceeds the reimplemented swapping baseline on target-language joint goal accuracy by more than seed variance over five seeds. We also beat it if the two combined exceed either alone. The second outcome would show the mechanisms are complementary.
Three ablations isolate the ingredient. The first gives the same match scores to the encoder as extra input features (encoder-side gazetteer), with a CRF on top. The second keeps the span potentials but replaces the CRF with softmax logits plus a hard legal-tag mask. The third removes database corruption during training. All systems use the same encoder, the same English training data, the same target database at test time, and the same hyperparameter search budget, tuned only on English development data. Choosing settings on the target language would quietly break the zero-shot setting.
Why not just…?
Why not just augment training with swapped entities, as BiToD does? This is the most serious threat. Its 55.39% result shows that entity knowledge alone covers most of the gap. Two facts favor our approach. Augmentation needs the target database at training time and has to be redone whenever the database changes. A gap of about 17 points to the bilingual ceiling of 72.16% also remains. Whether decoding-time potentials add to augmentation is a question the experiments answer directly, through the combined run. If swapping alone matches our tagger, the claim is wrong and we will report it.
Why not just translate the user's utterance into English and run the English model? GlobalWoZ reports a 60% failure rate for translated entity names in real searches, and local names are exactly what translation distorts. Zero-shot reading comprehension via multilingual representations also found translation worse than working in the shared multilingual space. We still run translate-test with the English tagger, then project spans back by alignment, as a reference.
Why not just constrain a generative model to emit only database entries, with a prefix tree over entity names? This is a real competitor. It also reads the database at test time and needs no CRF. Its weakness is that hard constraints force a database entry even when the gold entity is missing, and they inherit the word-order sensitivity documented for mT5 tagging. We run trie-constrained mT5 with the template design from the Seq2Seq tagging work. The comparison that settles this is the split by database coverage. Constrained generation should be close to us when entities are present and should fall behind when they are missing. If it does not, the CRF offers no advantage here.
Why not just add the match scores as encoder features and keep a softmax head? That is the first ablation. If it ties the full model, then the placement of the knowledge does not matter, and the contribution reduces to cross-lingual gazetteer matching.
Proposed Experiments
The main testbeds are BiToD and GlobalWoZ. BiToD covers zero-shot Chinese to English and English to Chinese with its shared bilingual database. GlobalWoZ covers zero-shot English training evaluated on its localized-entity test sets across typologically distant languages, using its scraped local ontologies as the test-time database only. Its template construction gives span labels for the slotted entities, which yields slot F1 alongside joint goal accuracy. MASSIVE is a control with no database. There the model reduces to an ordinary CRF tagger, and the check is that it neither helps nor hurts relative to a softmax head. No reported result was found on Lacuna for an absolute zero-shot MASSIVE Slot F1 baseline, so we report only our own reruns.
The metrics are slot F1, joint goal accuracy, and the coverage-split error rates. The decisive checks are three. First, on localized test sets, the full model must beat both the encoder-side gazetteer ablation and the masked-softmax ablation. If it does not, the CRF and the potential placement are not doing the work. Second, the trust weights learned in English must stay calibrated in every target language. We measure this as precision at each match-score level, and expect the precision-versus-score curve to look similar for English and the target language. Third, as the target database is thinned from complete to half coverage, accuracy should degrade smoothly toward the no-database tagger rather than falling below it. That last check is the one most likely to fail, and failure would mean the model has learned to depend on the database rather than to weigh it.
References
- GlobalWoZ: Globalizing MultiWoZ to Develop Multilingual Task-Oriented Dialogue Systems
- Bregman Conditional Random Fields: Sequence Labeling with Parallelizable Inference Algorithms
- Multi2WOZ: A Robust Multilingual Dataset and Conversational Pretraining for Task-Oriented Dialog
- BiToD: A Bilingual Multi-Domain Dataset For Task-Oriented Dialogue Modeling
- Building Dialogue Understanding Models for Low-resource Language Indonesian from Scratch
- Multi-Task Cross-Lingual Sequence Tagging from Scratch
- Low-Resource Named Entity Recognition with Cross-Lingual, Character-Level Neural Conditional Random Fields
- Phrase Grounding by Soft-Label Chain Conditional Random Field
- Zero-Shot Cross-Lingual Sequence Tagging as Seq2Seq Generation for Joint Intent Classification and Slot Filling
- A Model of Cross-Lingual Knowledge-Grounded Response Generation for Open-Domain Dialogue Systems
- Zero-shot Reading Comprehension by Cross-lingual Transfer Learning with Multi-lingual Language Representation Model