Nested Language Generation

• Nested Language Generation is a paradigm that models language as hierarchical structures, decomposing text into tokens, sentences, paragraphs, and chapters.
• It employs layered encoders and decoders, combining transformers and LSTMs to capture both global organization and local linguistic detail.
• Adversarial training and inter-layer attention mechanisms are utilized to ensure coherence and enhance the fidelity of generated long-form texts.

Nested language generation denotes a family of generation and representation-learning paradigms in which linguistic output is modeled as a hierarchy rather than as a single flat sequence. In the long-document setting, the hierarchy may be explicitly nested as tokens, sentences, paragraphs, and chapters; in task-oriented natural language generation, it may separate sentence planning from surface realization through stacked decoder layers; and in structured-output settings it may target arbitrarily deep JSON schemas rather than free text. Across these variants, the defining assumption is that global organization and local realization should be learned at different levels of abstraction, with coherence enforced across levels rather than deferred to a single decoder state (Rozental, 2019).

1. Conceptual scope and formalization

A central motivation for nested language generation is the observation that a flat encoder–decoder must jointly learn lexicon, grammar, discourse ordering, and surface word choice. In spoken-dialogue NLG, this problem is formulated as the tension between sentence planning, which decides the overall sentence structure, and surface realization, which determines specific word forms and flattens the sentence structure into a string (Su et al., 2018). In long-form text, the analogous issue is document-scale coherence: a model must preserve consistency across sentences, paragraphs, and chapters rather than optimize only token-level fluency (Rozental, 2019).

The notion of nesting can be formalized at multiple representational levels. For hierarchically annotated documents, each sentence $i$ consists of tokens $\{w_{i,1},\dots,w_{i,m_i}\}$, sentences aggregate into paragraphs, and paragraphs into chapters. AGENT explicitly treats these as distinct levels with increasing latent dimensionality $$D_{\mathrm{sentence}} < D_{\mathrm{paragraph}} < D_{\mathrm{chapter}}$$ (Rozental, 2019). In structured-output settings, nested JSON offers a complementary formalization in which objects and arrays recursively contain further objects, arrays, or primitive values. DeepJSONEval defines the nesting depth $d(J)$ recursively, with depth $0$ for primitives and $1 + \max d(v)$ for an object or array (Zhou et al., 30 Sep 2025).

These formulations share a common premise: generation is easier to control when the model represents intermediate structure explicitly. This suggests that “nested language generation” is best understood not as one architecture, but as a design principle in which linguistic or semantic organization is decomposed into levels, and each level is trained to remain compatible with the level above and below.

2. Hierarchical representation learning for nested texts

In "Adversarial Generation and Encoding of Nested Texts" (Rozental, 2019), AGENT is designed for encoding, generating and refining documents that consist of a long and coherent text, such as an entire book, provided they are hierarchically annotated, that is, divided into sentences, paragraphs and chapters. Its core mechanism is hierarchical representation learning. Tokens are first embedded and contextualized via a transformer encoder $f_{\mathrm{tok}}$, producing token vectors $h_{i,j} \in \mathbb{R}^{D_{\mathrm{token}}}$. A bidirectional LSTM “Compressor” $f_{\mathrm{enc}}^{(s)}$ then compresses a sentence into a single vector,

$$z_s^{(i)} = f_{\mathrm{enc}}^{(s)}\bigl(h_{i,1},\dots,h_{i,m_i}\bigr) \quad \in \mathbb{R}^{D_{\mathrm{sentence}}}.$$

Paragraph representations are constructed by stacking sentence vectors into

$\{w_{i,1},\dots,w_{i,m_i}\}$0

adding positional and segment embeddings, applying a transformer encoder $\{w_{i,1},\dots,w_{i,m_i}\}$1, and compressing again with a bidirectional LSTM to obtain

$\{w_{i,1},\dots,w_{i,m_i}\}$2

The same pattern repeats at chapter level, so that for paragraph vectors $\{w_{i,1},\dots,w_{i,m_i}\}$3,

$\{w_{i,1},\dots,w_{i,m_i}\}$4

The encoder stack combines self-attention blocks with RNN compression. At token level, AGENT uses an Evolved Transformer encoder of $\{w_{i,1},\dots,w_{i,m_i}\}$5 layers; at sentence and paragraph levels, it adds positional and segment embeddings and passes the sequence through transformer blocks followed by a bidirectional LSTM. Decoding is explicitly hierarchical as well. At each level, a symmetrical bidirectional-LSTM “Decompressor” expands a parent vector back into a sequence of hidden states, and an Evolved Transformer decoder reconstructs either token embeddings or sentence embeddings. Because each representation must support downward reconstruction, the hierarchy is not merely a latent summary; it is a constrained multiscale encoding of document structure.

This architecture makes long-range organization an explicit modeling target. The chapter vector is required to remain informative about paragraphs, the paragraph vector about sentences, and the sentence vector about tokens. A plausible implication is that such a design distributes representational burden across scales rather than forcing all document structure into token-level recurrence or self-attention alone.

3. Objective functions and coherence constraints

AGENT trains each level $\{w_{i,1},\dots,w_{i,m_i}\}$6 with a composite loss

$\{w_{i,1},\dots,w_{i,m_i}\}$7

The first component is sequence reconstruction. If $\{w_{i,1},\dots,w_{i,m_i}\}$8 denotes the matrix of lower-level vectors and $\{w_{i,1},\dots,w_{i,m_i}\}$9 the $$D_{\mathrm{sentence}} < D_{\mathrm{paragraph}} < D_{\mathrm{chapter}}$$0-level decoder, then

$$D_{\mathrm{sentence}} < D_{\mathrm{paragraph}} < D_{\mathrm{chapter}}$$1

or, when decoding discrete tokens, the usual cross-entropy over the embedding matrix (Rozental, 2019). This objective enforces downward recoverability of the hierarchy.

The second component is a generalized Masked Language Modeling objective. At level $$D_{\mathrm{sentence}} < D_{\mathrm{paragraph}} < D_{\mathrm{chapter}}$$2, a subset $$D_{\mathrm{sentence}} < D_{\mathrm{paragraph}} < D_{\mathrm{chapter}}$$3 of vectors $$D_{\mathrm{sentence}} < D_{\mathrm{paragraph}} < D_{\mathrm{chapter}}$$4 is masked, and the model minimizes

$$D_{\mathrm{sentence}} < D_{\mathrm{paragraph}} < D_{\mathrm{chapter}}$$5

where prediction is computed by re-encoding via the level-$$D_{\mathrm{sentence}} < D_{\mathrm{paragraph}} < D_{\mathrm{chapter}}$$6 encoder plus a feed-forward head and a softmax over the level-specific vocabulary. Unlike standard MLM at token level, this formulation applies to tokens, sentences, or paragraphs, depending on scale.

The third component is a generalized coherence objective inspired by Next Sentence Prediction. The vectors at level $$D_{\mathrm{sentence}} < D_{\mathrm{paragraph}} < D_{\mathrm{chapter}}$$7 are split into two segments $$D_{\mathrm{sentence}} < D_{\mathrm{paragraph}} < D_{\mathrm{chapter}}$$8, with some random replacement of $$D_{\mathrm{sentence}} < D_{\mathrm{paragraph}} < D_{\mathrm{chapter}}$$9 by out-of-context vectors. After re-encoding into $d(J)$0, the model regresses the fraction $d(J)$1 of replaced items: $d(J)$2 The paper characterizes this as generalized Next-Sentence-Prediction for coherence (Rozental, 2019).

Taken together, these losses make coherence a multiscale supervisory signal. The reconstruction term enforces hierarchical consistency, the MLM term enforces in-level contextual compatibility, and the coherence term penalizes out-of-context substitutions. The paper’s discussion states that long-range coherence is enforced by the upward coherence losses at each scale, ensuring that only embeddings consistent with their context survive. This suggests a view of nested generation in which coherence is not an emergent by-product of local fluency, but a directly optimized property of latent structure.

4. Adversarial generation and top-down traversal

AGENT extends hierarchical encoding with an adversarial generation scheme for long text generation (Rozental, 2019). For each level $d(J)$3, paragraph and above, a Generator $d(J)$4 draws noise $d(J)$5, passes it through $d(J)$6 dense layers with tanh activations, and produces a synthetic embedding $d(J)$7. The Discriminator $d(J)$8 does not classify latent vectors directly; instead, it takes the lower-level reconstruction $d(J)$9 and applies a small CNN over the sequence to classify real versus fake. Training solves the minimax objective

$0$0

A notable implementation detail is that, during adversarial training, gradients from $0$1 propagate back into $0$2 only, while the Hierarchical Encoder/Decoder remains fixed. By decoding $0$3 through $0$4, the model enforces that generated vectors lie in the manifold of real embeddings. The paper explicitly motivates this by noting that pure Gaussian noise rarely lands in valid text regions.

Document generation then proceeds top-down. One samples root noise $0$5, obtains $0$6, recursively decompresses $0$7 into child vectors $0$8 for $0$9, and finally decodes token-by-token with the lowest-level Transformer decoder. After each level-$1 + \max d(v)$0 decomposition, the model may apply “Copyediting via MLM,” performing $1 + \max d(v)$1 iterations of local masked re-prediction: $1 + \max d(v)$2 The paper states that this “smooths” the vectors toward regions consistent with training co-occurrence patterns (Rozental, 2019).

This top-down traversal distinguishes AGENT from standard left-to-right generation. Instead of producing tokens directly from a single autoregressive state, it generates a tree of latent representations and then refines each local region with MLM-based copyediting. A plausible implication is that text planning and text polishing are separated both structurally and temporally: global layout is sampled first, while local consistency is repaired during decomposition.

5. Hierarchical decoders and linguistic pattern ordering

A second major formulation of nested language generation appears in "Investigating Linguistic Pattern Ordering in Hierarchical Natural Language Generation" (Su et al., 2018). Here the task is not document-scale hierarchy, but sentence-level decomposition of NLG into nested decoder layers. The model retains a single bidirectional-GRU encoder,

$1 + \max d(v)$3

and replaces the standard decoder with $1 + \max d(v)$4 stacked GRU layers. Each decoder layer $1 + \max d(v)$5 maintains hidden states $1 + \max d(v)$6, generates output tokens $1 + \max d(v)$7, and conditions on both its own previous output $1 + \max d(v)$8 and the previous layer’s output at the same time step $1 + \max d(v)$9: $f_{\mathrm{tok}}$0

$f_{\mathrm{tok}}$1

The hierarchy is linguistic. The bottom layer(s) perform the role of planning by selecting and roughly ordering content-bearing parts of speech, while successive layers insert additional linguistic patterns until a full sentence emerges. In the E2E Challenge experiments, the model uses four decoder layers with words grouped by POS into $f_{\mathrm{tok}}$2, $f_{\mathrm{tok}}$3, $f_{\mathrm{tok}}$4, and $f_{\mathrm{tok}}$5. Six different permutations of layer ordering are tried (Su et al., 2018).

To let one layer align to the previous layer’s hidden states, the model adds content-based inter-layer attention. At decoder step $f_{\mathrm{tok}}$6 of layer $f_{\mathrm{tok}}$7, attention weights are computed over time steps $f_{\mathrm{tok}}$8 of layer $f_{\mathrm{tok}}$9 using dot, general, or concat scoring, yielding

$h_{i,j} \in \mathbb{R}^{D_{\mathrm{token}}}$0

and the context is concatenated to the GRU input. Training uses a cross-entropy loss at each layer,

$h_{i,j} \in \mathbb{R}^{D_{\mathrm{token}}}$1

with total loss $h_{i,j} \in \mathbb{R}^{D_{\mathrm{token}}}$2. Scheduled sampling is used both within and across layers, and curriculum learning controls when upper layers start back-propagating.

Empirically, the model is evaluated on the E2E Challenge dataset of 50 K restaurant descriptions. The flat seq2seq baseline has BLEU $h_{i,j} \in \mathbb{R}^{D_{\mathrm{token}}}$3. For the human-inspired hierarchy NOUN$h_{i,j} \in \mathbb{R}^{D_{\mathrm{token}}}$4VERB$h_{i,j} \in \mathbb{R}^{D_{\mathrm{token}}}$5ADJ/ADV$h_{i,j} \in \mathbb{R}^{D_{\mathrm{token}}}$6others, the hierarchical decoder alone reaches BLEU $h_{i,j} \in \mathbb{R}^{D_{\mathrm{token}}}$7, the repeat-input mechanism yields BLEU $h_{i,j} \in \mathbb{R}^{D_{\mathrm{token}}}$8, curriculum learning yields BLEU $h_{i,j} \in \mathbb{R}^{D_{\mathrm{token}}}$9, and all enhancements yield BLEU $f_{\mathrm{enc}}^{(s)}$0. Across all six POS orderings, hierarchical decoding consistently doubles BLEU compared to flat seq2seq, with the best ordering VERB$f_{\mathrm{enc}}^{(s)}$1ADJ/ADV$f_{\mathrm{enc}}^{(s)}$2NOUN$f_{\mathrm{enc}}^{(s)}$3others peaking at BLEU $f_{\mathrm{enc}}^{(s)}$4. Adding inter-layer attention yielded minor or no gain in most settings (Su et al., 2018).

The analysis emphasizes that ordering matters because it changes the balance of what each layer must insert. Orders in which the bottom layers emit very few tokens force the next layer to insert many words at once, hurting learning. The paper also notes that adverbs in the dataset overwhelmingly modify adjectives, so inserting ADJ/ADV before VERB consistently outperforms the reverse. More generally, nested generation here functions as a controlled insertion process, where linguistic pattern ordering determines how abstract plans are expanded into final text.

6. Evaluation regimes, limitations, and adjacent directions

Nested language generation raises distinct evaluation problems because correctness is distributed across levels. In free-text systems such as AGENT and hierarchical decoder NLG, evaluation centers on reconstruction fidelity, layer-wise prediction accuracy, BLEU, and ROUGE-style surface overlap (Rozental, 2019, Su et al., 2018). In structured nested outputs, DeepJSONEval makes the hierarchical dimension explicit through three scores: a Syntax Score requiring valid JSON and schema match, a Hierarchical Key Matching Score defined over sets of property paths, and a Strict Exact-Match Score requiring exact identity between output and gold JSON (Zhou et al., 30 Sep 2025). Although DeepJSONEval targets information extraction rather than long-form text generation, this suggests a broader evaluation principle: nested generation quality can be measured not only by local token correctness but also by preservation of hierarchical paths and parent–child consistency.

The limitations identified in the literature are correspondingly structural. AGENT reports heavy compute for multi-scale encoding/decoding, reliance on correct hierarchical splits, and potential mode collapse at high levels (Rozental, 2019). The hierarchical decoder work states that no single universal hierarchy works best across domains and that a small additional POS-distribution analysis is advisable; it also notes that the current setup uses a fixed 4-layer architecture, and that deeper or more fine-grained hierarchies might further improve long-sentence coherence (Su et al., 2018). DeepJSONEval shows that even state-of-the-art LLMs struggle with deep nested extraction tasks beyond four levels, with average strict-score drops of 17.2–37.5 points from Medium to Hard as nesting depth increases (Zhou et al., 30 Sep 2025).

The research directions proposed across these works converge on stronger structural supervision. AGENT suggests dynamic hierarchy depths, improved PNDB-style memory for proper nouns, or Wasserstein GAN losses for greater stability (Rozental, 2019). The hierarchical decoder study points toward stronger explicit structure, for example syntax trees in place of POS clustering (Su et al., 2018). DeepJSONEval recommends tree-structured losses that penalize missing or misordered subtrees, curriculum learning on JSON grammar, BNF-based constrained decoding during fine-tuning, dynamic schema adaptation, constrained beam search guided by schema automata, and tree-aware attention mechanisms (Zhou et al., 30 Sep 2025). A plausible implication is that nested generation research is moving from heuristic layering toward explicit tree-sensitive objectives and decoding constraints.

In this broader perspective, nested language generation is less a single model class than a structural doctrine. Whether the target is a long coherent document, a task-oriented response assembled from ordered linguistic patterns, or a deep JSON object extracted from text, the central problem remains the same: generation must preserve compatibility between global organization and local realization. The principal technical question is therefore how to learn, traverse, and evaluate hierarchical latent states so that each level contributes a distinct and verifiable part of the final output.