Turning a knowledge graph into text means taking a small set of facts, such as (Alan Bean, birthPlace, Wheeler, Texas), and writing a sentence that states each fact once, with the right entity in the right role. Fine-tuned neural models do this fluently, but they still drop facts, invent facts, and swap subject and object. Hand-written templates never make those errors, but their text is so uniform that models trained on it learn the templates instead of the facts. We propose a middle path built from an old idea in computational lexicons, inheritance hierarchies. Relations are organized into a taxonomy of meaning classes. Each class carries a small inventory of grammatical constructions, for example active, passive, relative clause, possessive noun phrase, or prepositional phrase, and every relation below it inherits these constructions. Individual relations override defaults only where they are irregular, for instance when a relation requires a particular preposition. Because every generated sentence comes from a known construction applied to known triples, we know exactly where each fact is realized and which entity fills which role. The text varies in systematic ways and is still guaranteed to be faithful.
The central bet is about what this structure buys. We do not expect it to produce more fluent text than a fine-tuned model. We expect it to produce training and test data whose variation is organized along the axes on which graph-to-text models fail: voice and argument order, which drive role swaps, and relations never seen in training, which drive the drop on unseen categories. The hierarchy lets us vary those axes on purpose and hold out combinations on purpose. Flat templates and free-form paraphrasing cannot do either.
Core Claim
Our claim is that a construction-inheritance grammar over relation classes can serve as a data source with two uses. The first is training augmentation that reduces role inversion and fact omission in fine-tuned graph-to-text models, especially on unseen WebNLG categories. The second is a diagnostic test set that isolates role inversion through minimal pairs. The specific novelty is that the variation is governed by inheritance. Unseen relations receive valid constructions through their class, so diversity transfers to relations no one wrote templates for. We can also hold out whole cells of the grid of constructions and relation classes, which turns "does the model generalize compositionally?" into a controlled experiment rather than a post-hoc observation.
Relation to Prior Work
Three lines of work motivate the proposal by documenting the problem. Neural verbalizers produce fluent text but need extra machinery to stay faithful. TEKGEN fine-tunes T5 on distantly aligned Wikidata–Wikipedia pairs and then needs a separate BERT filter to discard hallucinated outputs. Stage-wise Fine-tuning for Graph-to-Text Generation adds embeddings that mark each token's role in its triple and its tree depth, yet the paper still reports subject/object confusion. Graformer injects shortest-path distances into attention. All three put structure into the input side of the model. We put structure into the supervision.
Template-based benchmark construction gives the second kind of motivation, the shortcut problem. COVR builds compositional test splits from 15 templates and finds that VisualBERT falls from roughly 68% to as low as 1.6% on held-out combinations. Automatic Generation of Contrast Sets from Scene Graphs swaps entities into six regex templates and finds LXMERT dropping from 83.9% to 67.2%. FVQA 2.0 builds adversarial splits from ConceptNet triples but needs human filtering to remove nonsensical template transfers. Both Bitton et al. and FVQA 2.0 handle substitution with surface heuristics, so they break whenever a new filler needs a different preposition or argument frame. That is precisely what inheritance is designed to handle. Commonsense Knowledge Mining from Pretrained Models writes one flat template per relation for single triples. Our grammar generalizes this to multi-triple text with class-level sharing.
The method comes from the lexicon literature. Issues in Relating Syntax and Semantics formalizes constructions such as the passive and the dative alternation as form–meaning pairings that inherit from abstract parents. On Representing Governed Prepositions shows that prepositions governed by a predicate can be inherited from semantic predicate classes. MAGEAD shows that non-monotonic inheritance, where a child class can override a parent's defaults, lets a dialect reuse regular rules and override only its exceptions. That adaptation took about six hours of a linguist's work, which is our evidence that authoring cost can stay small. A Transfer Model Using Typed Feature Structure Rewriting uses typed hierarchies so that specific items encode only their idiosyncrasies.
Two papers constrain the design. The rewriting approach in that transfer model suffered search blowup under full unification. We avoid this by restricting the grammar to deterministic default inheritance with explicit override priority, with no general unification. Lean Semantic Interpretation reaches 94–97% precision with hierarchies, but recall falls to 31% when the ontology lacks coverage. That paper is the direct warning for our approach, and we design for coverage as described below.
Research Program
We will build a verbalization grammar for the DBpedia properties used in WebNLG 2017. A shallow class hierarchy of a few dozen classes sits above the properties, for example location-of-entity, membership, creation-by-agent, temporal-event, and measured-quantity. Each class defines a construction inventory, and each construction specifies three things: which argument becomes the grammatical subject, which function words it governs, and how it can embed into another construction, so that facts sharing an entity can be chained with a relative clause or apposition. Leaf relations override defaults only where needed, for example "is a member of" against "plays for".
A multi-triple generator then picks an ordering of the facts, picks constructions for each fact, and composes them. It produces a text together with a record of which span realizes which fact and which entity fills which role. Coverage of unseen relations is handled by assigning a new property to a class, using an LLM classifier with a fallback to the root class's generic constructions. We report how often the fallback fires, which tells us directly whether we have reproduced the Romacker et al. recall problem.
The grammar's output is used in two ways. First, it is mixed into the fine-tuning data of a strong T5 graph-to-text model. Second, it generates a role-inversion diagnostic made of minimal pairs: the same graph with the relation direction flipped, rendered with constructions that put the two entities in the same linear order. A model that relies on word order rather than on the graph will fail these pairs. Because inheritance gives a clean grid of relation classes against constructions, we can also train on some cells and test on others.
Baselines
The naive reference point is an off-the-shelf T5-large fine-tuned on WebNLG 2017 alone, with triples given as flat, delimited strings. This shows how much any of the additions matter.
The strongest existing method is the best configuration of Stage-wise Fine-tuning for Graph-to-Text Generation: T5-large with intermediate Wikipedia fine-tuning plus role and tree-position embeddings. It reports BLEU 66.07 on WebNLG Seen and 53.87 on Unseen. It is the strongest competitor because it targets the same failures, role confusion and structure loss, through architecture rather than data. We will reproduce it with the released recipe and treat our reproduced numbers as the reference. Our method adds grammar-generated data to that same recipe under an identical tuning budget. We consider it beaten if Unseen BLEU improves by more than seed variance across three seeds and the role-swap rate on our diagnostic falls, with Seen BLEU staying within about one point. We expect no large Seen gain and will not claim one.
The key ablation is a flat-template baseline with matched diversity. Each WebNLG relation receives hand-written templates in the same number and spread of constructions as the grammar provides, but no inheritance. Unseen relations therefore get only a generic fallback, and annotators are given equal authoring time. This isolates whether the hierarchy itself matters or merely the volume of varied templated text. A second ablation removes the non-monotonic overrides, so every leaf uses its class defaults, to measure how much grammaticality depends on exceptions.
The final baseline is LLM paraphrasing. Single-fact template outputs are paraphrased by an instruction-tuned LLM and filtered for fidelity using an NLI-style check. It receives a data budget matched to the grammar's output.
No reported result was found on Lacuna for Graformer or TEKGEN on WebNLG, so neither serves as a numeric reference.
Why not just…?
Why not just fine-tune a strong model with structural embeddings and stop there? That model is our main baseline, and its reported 53.87 Unseen BLEU against 66.07 Seen shows that much of the gap lies in unseen relations, where structural embeddings add no new lexical knowledge. The authors also still observe role confusion. Our claim is complementary, not competing: the grammar is added to that model's training data. If the combination does not lower role swaps or raise Unseen scores, the proposal fails on its central claim.
Why not just write more flat templates? This is the real threat. The matched-diversity flat-template ablation is designed to answer it. On seen relations we expect flat templates to do about as well. The hierarchy should win only where inheritance does work flat templates cannot: unseen relations and held-out cells of the grid of classes and constructions. If flat templates match the grammar there too, we will report that the gain comes from diversity rather than hierarchy, and the contribution shrinks to a diagnostic.
Why not just have an LLM paraphrase templates? Paraphrasing adds diversity, but it gives no record of where each fact is realized and no control over which constructions appear. FVQA 2.0 needed human filtering for exactly this reason. Paraphrasing is run as a baseline at matched budget. If, after fidelity filtering, it matches our gains, then the grammar's remaining value is the held-out construction split and the role-inversion diagnostic, which paraphrasing cannot produce systematically.
Proposed Experiments
On WebNLG 2017 we report BLEU, METEOR, TER and BERTScore separately for Seen and Unseen, averaged over three seeds, for every system above. Fidelity is measured on a sample of 500 outputs per system. Annotators mark omitted facts, hallucinated facts and swapped roles, and the annotation is blind to system identity.
The first decisive check is the role-inversion diagnostic. Every system is scored on minimal pairs of direction-flipped graphs that share surface entity order. We expect the naive baseline and the structural-embedding baseline to show measurable swap rates, and grammar-augmented training to reduce them more than either the flat-template or the paraphrase baseline does.
The second decisive check is compositional and modeled on COVR's held-out combinations. We train with certain constructions withheld from certain relation classes and test on those cells. Comparing hierarchy against flat templates on these cells is the cleanest test of whether inheritance, rather than template volume, drives generalization.
We also report coverage, meaning the share of unseen properties that fall back to the root class. We report authoring cost in hours, compared against the MAGEAD-style expectation that inheritance keeps it small. Finally, a grammaticality rating with and without overrides tests whether non-monotonic exceptions are needed or whether class defaults suffice.
References
- Knowledge Graph Based Synthetic Corpus Generation for Knowledge-Enhanced Language Model Pre-training
- Stage-wise Fine-tuning for Graph-to-Text Generation
- Modeling Graph Structure via Relative Position for Better Text Generation from Knowledge Graphs
- COVR: A Test-Bed for Visually Grounded Compositional Generalization with Real Images
- Automatic Generation of Contrast Sets from Scene Graphs: Probing the Compositional Consistency of GQA
- FVQA 2.0: Introducing Adversarial Samples into Fact-based Visual Question Answering
- Commonsense Knowledge Mining from Pretrained Models
- Issues in Relating Syntax and Semantics
- On Representing Governed Prepositions and Handling "Incorrect" and Novel Prepositions
- MAGEAD: A Morphological Analyzer and Generator for the Arabic Dialects
- A Transfer Model Using a Typed Feature Structure Rewriting System with Inheritance
- Lean Semantic Interpretation