💬 NLP

Structures Facilitate Retrieve, Rerank, and Generate

This paper introduces SF-Re2G, a document-grounded dialogue system that leverages document structural information to enhance passage representation, improve retrieval and reranking through subgraph grouping, and generate more context-aware responses.

Original authors: Yeqin Zhang, Haomin Fu, Xujie Zhang, Cam-Tu Nguyen

Published 2026-06-03

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Yeqin Zhang, Haomin Fu, Xujie Zhang, Cam-Tu Nguyen

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to answer a complex question by reading a massive, multi-volume encyclopedia. In the past, computer systems trying to do this (called Document-Grounded Dialogue Systems) treated the encyclopedia like a giant, unorganized pile of loose papers. They would chop the text into random-sized chunks, search through them, and try to stitch an answer together.

The authors of this paper, Zhang and colleagues, argue that this "pile of papers" approach misses the most important part: the structure. Real documents aren't just random text; they have chapters, headings, tables, and steps that logically connect to one another.

Here is how their new system, SF-Re2G, works, explained through simple analogies:

1. The Problem: The "Blind Search"

Imagine you are looking for a specific recipe in a cookbook.

Old Way: The computer cuts the book into random strips of paper. Some strips are just a list of ingredients; others are a whole paragraph about the history of cooking. When you ask, "How long do I bake this?", the computer might grab a strip that says "Preheat oven" but misses the strip right next to it that says "Bake for 20 minutes" because they were cut apart.
The Issue: The old systems ignore the fact that related information usually sits right next to each other in the book's "table of contents" or hierarchy.

2. The Solution: SF-Re2G (Structure-Facilitated Retrieve, Rerank, and Generate)

The authors propose a system that respects the "book's" layout. They break the process down into three steps, like a team of three specialists:

Step 1: The Scout (Retrieval)

The Job: Find the most relevant pages in the encyclopedia.
The Innovation: Instead of just looking for words that match, the Scout learns to recognize "neighborhoods."
The Analogy: Imagine the Scout is a detective. If the detective finds a clue about a "crime," they know to also look at the "police station" and the "courtroom" pages because those are logically connected in the city map (the document structure).
How it works: The system uses a special training method called "contrastive learning." It teaches the computer that pages sitting under the same chapter heading are "neighbors." If the computer picks a wrong page that is too similar to the right one (a "hard negative"), it learns to tell them apart by looking at their structural context.

Step 2: The Judge (Reranking)

The Job: The Scout brings back a list of 100 potential pages. The Judge needs to pick the top 5 best ones.
The Innovation: The Judge doesn't look at the pages in isolation. It looks at them as a group.
The Analogy: Imagine you are hiring a team for a project. The old way was to interview candidates one by one. The new way is to interview them in "squadrons." If Candidate A is a great coder, but they are applying for a role that requires a graphic designer, and their "squadron" (the rest of the document section) is full of designers, the Judge realizes Candidate A is actually a perfect fit because the whole group supports that role.
How it works: The system groups the candidate pages into "subgraphs" (mini-clusters based on the document's tree structure). It scores a page not just on its own text, but on how well it fits with its structural neighbors.

Step 3: The Writer (Generation)

The Job: Write the final answer to the user.
The Innovation: The Writer uses the "subgraph" context to understand the full picture.
The Analogy: Imagine a journalist writing a story. If they only have a single sentence from a source, they might get it wrong. But if they have the whole paragraph and the surrounding context (the subgraph), they can write a much more accurate and nuanced story.
How it works: The system feeds the chosen pages plus their structural neighbors into the AI writer. This helps the AI understand things like "Step 3 follows Step 2" or "This table cell belongs to this row header," leading to better answers.

What Did They Find?

The team tested this system on two different "libraries" of knowledge:

MultiDoc2Dial: A collection of English documents (like government forms and FAQs).
Doc2Bot: A collection of Chinese documents (like health and insurance guides).

The Results:

Better Accuracy: By respecting the document's structure, the system found the right information more often than the old "loose paper" methods.
Smarter Answers: The answers generated were more accurate and flowed better.
The "Structure" Bonus: In documents with clear structures (like the Chinese insurance guides with clear tables and steps), the system saw a noticeable boost in performance. However, in documents where the structure was messy or less defined, the system still worked well, proving it doesn't break if the structure is weak, but it shines when the structure is strong.

In a Nutshell

The paper argues that treating a document like a flat stream of text is like trying to understand a city by looking at a pile of bricks. SF-Re2G is like giving the computer a map of the city, showing it how the buildings (paragraphs), streets (sections), and districts (documents) connect. This allows the computer to find the right information faster and build better answers.

Technical Summary: SF-Re2G – Structures Facilitate Retrieve, Rerank, and Generate

Problem Statement

Document-grounded dialogue systems (DGDS) aim to generate accurate responses by leveraging external documents. However, existing solutions, such as RAG and Re2G, typically treat documents as flat textual sequences divided into independent passages. This approach presents two critical limitations:

Granularity Issues: Fixed passage lengths fail to accommodate varying information needs. Long passages introduce noise for specific queries, while short passages lack sufficient context for complex questions.
Ignored Structural Information: Documents often possess inherent hierarchical structures (e.g., tables, section headers, logical steps). Treating them as flat sequences severs semantic connections between related elements (e.g., a table header and its corresponding cell), leading to suboptimal knowledge selection and response generation.

Current methods largely ignore these structural cues, resulting in performance bottlenecks in retrieving the correct knowledge and generating coherent responses.

Methodology: SF-Re2G

The authors propose SF-Re2G, a framework that systematically integrates document structural information into the three core stages of the DGDS pipeline: Retrieval, Reranking, and Generation. The system models documents as graphs where nodes represent passages of varying lengths (e.g., table cells, paragraphs).

1. Retrieval: Structural Contrastive Learning

The retrieval module utilizes a Bi-encoder architecture (based on DPR) but introduces two key enhancements to improve passage representation and negative sampling:

Top-Down Aggregation: Inspired by TreeJC, the model aggregates upper-level information (such as paragraph headings and document names) to enhance the representation of individual passages.
Structural Contrastive Learning: The authors recognize that passages within the same section of a document graph are semantically similar and difficult to distinguish. To address this, they introduce a hard negative sampling strategy where negative samples are drawn from the neighborhood of the positive passage within the document structure. This forces the model to learn finer semantic distinctions between neighboring nodes.
Loss Function: The model optimizes the negative log-likelihood, incorporating in-batch negatives and the structurally sampled hard negatives.

2. Reranking: Structure-Enhanced Scoring

The reranking module employs a Cross-Encoder to rescore the top- $k$ candidates from the retrieval stage.

Subgraph Construction: Retrieved candidates are grouped into subgraphs based on the document structure (e.g., grouping passages from the same document branch).
Contextual Input: Instead of scoring a passage in isolation, the reranker inputs the core passage alongside its neighboring passages within the same subgraph. The input format includes special tokens ([core] for the target passage and [others] for neighbors) to distinguish the target from its context.
Mechanism: This allows the model to leverage co-occurrence probabilities; if a neighbor passage matches the query, it boosts the score of the core passage, and vice versa.

3. Generation: Structure-Fused Weighting

The generation module uses a pre-trained BART model.

Weighted Fusion: The system adopts a weighting method similar to Re2G. The probability of generating a token is calculated by summing the probabilities of the generator conditioned on each retrieved passage, weighted by the structurally enhanced rerank scores ( $p_\eta$ ).
Subgraph Integration: The generator receives the dialog history, the core passage, and the sequential subgraph ( $G_{sub}$ ) as input. This allows the model to ground its response not just on the retrieved text but also on its structural context.
Training: The reranker and generator can be jointly trained without additional fine-tuning of the pre-trained BART backbone, using the generated results to correct the weights assigned by the reranker.

Key Contributions

Systematic Structural Integration: This work is the first to systematically study and integrate structural information across all stages (retrieval, reranking, and generation) of the DGDS pipeline, rather than isolating it to specific modules.
Novel Architecture (SF-Re2G): The authors introduce a method that leverages document graphs to handle variable passage lengths and utilizes structural contrastive learning for better negative sampling.
Empirical Validation: The method demonstrates superior performance compared to state-of-the-art approaches on both English (MultiDoc2Dial) and Chinese (Doc2Bot) datasets.

Experimental Results

The authors evaluated SF-Re2G on two datasets: MultiDoc2Dial (English) and Doc2Bot (Chinese).

Retrieval: The structural contrastive approach (DPRstruct) improved Recall@1 by approximately 2% on MultiDoc2Dial and 1% on Doc2Bot compared to standard DPR.
Reranking: The structure-enhanced reranker (CrossEncoderstruct) showed consistent improvements, particularly on Doc2Bot, where it achieved a ~1% average improvement across metrics (Recall@1, Recall@5, Recall@10, Rprec). On MultiDoc2Dial, where structural information is less distinct, the gains were marginal.
Generation: SF-Re2G achieved state-of-the-art performance on both datasets across F1, SacreBLEU, and ROUGE metrics. Notably, the authors observed that removing the subgraph context during generation hurt performance on Doc2Bot (where structure is rich) but slightly improved performance on MultiDoc2Dial. This suggests that structural context is most beneficial when the source documents possess clear, meaningful structures.

Significance and Claims

The paper claims that structural information in documents is a valuable, non-negligible resource for DGDS. The authors argue that current methods ignoring these elements result in suboptimal performance. By treating documents as graphs and utilizing structural relationships for contrastive learning and context fusion, SF-Re2G provides a more robust framework for knowledge selection and response generation. The results suggest that future research in this domain should prioritize the exploitation of document structure rather than treating documents as flat text sequences.