RSF-GLLM: Bridging the Semantic Gap in Multi-Hop Knowledge Graph QA via Recurrent Soft-Flow and Decoupled LLM Generation

Source: arXiv:2607.06527 · Published 2026-07-07 · By Sambaran Bandyopadhyay, Ananth Muppidi

TL;DR

This paper addresses the semantic gap problem in multi-hop question answering (QA) over knowledge graphs (KGs), where intermediate reasoning nodes often lack lexical overlap with the query. Traditional retrieve-then-read pipelines fail to adaptively learn to bridge these gaps due to broken differentiability in discrete retrieval. RSF-GLLM proposes a novel two-stage framework that decouples differentiable graph reasoning from answer generation. The core is the Recurrent Soft-Flow (RSF) module, which uses a GRU-based query updater and a dynamic gating mechanism to propagate continuous soft relevance scores on the KG. This enables traversing semantically dissimilar bridge nodes by relying on structural graph cues rather than lexical similarity. A flow sparsity regularization guides soft probabilities to converge to discrete, interpretable reasoning paths. These paths are then textualized and used to fine-tune a large language model (LLM) for grounded answer generation.

Empirically, RSF-GLLM achieves state-of-the-art accuracy on two standard multi-hop KGQA benchmarks, WebQSP and ComplexWebQuestions (CWQ), with Hit@1 of 90.45% and 67.39% respectively. Importantly, it matches or outperforms prior LLM-based methods while requiring orders of magnitude less inference time and compute by avoiding expensive iterative LLM calls during retrieval. Ablations confirm the effectiveness of the dynamic gating to handle the semantic gap and the GRU-based recurrent query update for intent evolution. The paper provides theoretical guarantees on sparsity-driven convergence to crisp paths and faithful reconstruction of reasoning chains, ensuring interpretability and structural grounding.

Key findings

• RSF-GLLM achieves 90.45% Hit@1 on WebQSP, surpassing prior LLM+KG methods like RoG (85.7%) and DECAF (82.1%) using a single LLM call.
• On CWQ, RSF-GLLM reaches 67.39% Hit@1, competitive with more expensive agentic models despite a 19.3% subgraph coverage ceiling.
• The Recurrent Soft-Flow module has only 176M parameters, 38× smaller than comparable retrieval-augmented LLM models (RoG with 6.7B params), reducing training memory from 64.5GB to 2.7GB.
• Ablation removing content bias scoring reduces Hit@10 by 6.4%, disabling query update reduces 5.6%, removing dynamic gating costs 2.4%, and turning off flow sparsity costs 3.6%.
• Flow sparsity regularization (λ1=0.1) optimizes a balance between over-diffuse distributions and premature hard decisions, achieving ∼4 effective candidate paths (Fig 2).
• The dynamic gating parameter λ(t) statistically correlates with query stages, suppressing semantic bias when bridging semantic gaps (e.g., intermediate nodes with zero lexical overlap).
• Theoretical analysis proves global minima of flow sparsity lie at simplex vertices (discrete paths), supports structural-only traversal of semantic gap nodes, and guarantees valid backtracking to reconstruct reasoning chains.
• Compared to agentic search methods requiring 50+ LLM calls per query, RSF-GLLM completes inference in 0.25s on A100 GPU with a single LLM call for generation.

Threat model

The adversary is implicit: a knowledge graph QA attacker may try to confuse the model by exploiting semantic gaps where intermediate KG nodes lack lexical overlap with the question, causing retrieval failures. The model assumes the KG and its structure are fixed and trustworthy, with no adversarial modification. The adversary cannot alter graph structure or inject falsified facts but may leverage the lack of lexical clues to induce reasoning errors. The defense focuses on overcoming these inherent semantic gaps by leveraging structural signals in a differentiable, learnable manner.

Methodology — deep read

1. Threat model & assumptions: The adversary is not explicitly modeled; the focus is on robust, faithful multi-hop QA over Knowledge Graphs where intermediate bridge nodes lack lexical overlap with queries. The system assumes access to the KG structure and entity/relation embeddings. The adversary cannot alter the KG or induce adversarial noise but may exploit semantic gaps.

2. Data: Two public KGQA benchmarks are used—WebQSP (~4700 queries, 2-hop reasoning) and ComplexWebQuestions (CWQ, involving up to 4-hop complex queries). Entities are pre-linked to Freebase entities. For efficiency, subgraphs within K-hop neighborhoods (K=2 for WebQSP, K=4 for CWQ) around retrieved topic entities are extracted.

3. Architecture: RSF-GLLM has a two-stage architecture. The first stage is the differentiable Recurrent Soft-Flow (RSF) module which learns soft multi-hop flows over the KG subgraph. It propagates relevance scores from an anchor node via relation-aware structural flow Φ(t), combined with a content bias ρ(t) modulated by a dynamic gate λ(t). A GRU-based query updater updates the query intent vector after each hop using the soft read context vector c(t).

The RSF module outputs continuous posterior distributions π(t) over candidate nodes at each hop. A flow sparsity regularization enforces low-entropy peaked distributions promoting discrete, interpretable paths. During path extraction, a greedy backtracking algorithm follows maximum-probability predecessors to reconstruct causal reasoning chains.

The second stage fine-tunes a pretrained LLM (e.g., Qwen3-8B or LLaMA2-7B) on training data formed by concatenating the original question with the textualized reasoning paths. The LLM generates grounded answers autoregressively.

4. Training regime: RSF module is first trained alone for up to 10 epochs using AdamW optimizer (learning rate 5e-5, weight decay 0.01) to minimize cross-entropy (KL divergence) between the predicted final node distribution and ground truth answer node, plus the entropy-based flow sparsity loss weighted by λ1=0.1. The LLM is then fine-tuned on textualized paths for answer generation with standard causal language modeling loss, freezing the RSF module.

5. Evaluation protocol: Metrics include Hit@1, F1 scores on test splits. Baselines include embedding-based, graph-based, LLM-only zero-shot, and LLM+KG methods. Efficient inference timing and GPU memory use are measured. Ablations disable individual RSF components to quantify contribution. Path extraction fidelity is analyzed theoretically and empirically.

6. Reproducibility: Code and data preprocessing details are provided; the KG and datasets are public (WebQSP, CWQ). Training and inference were performed on NVIDIA A100 80GB GPU. Exact seed and hyperparameter sweeps are not detailed; frozen LLM weights noted. The RSF module is lightweight and practical to train compared to prior GNN+LLM approaches.

Concrete example: For the query “What awards did the director of Inception win?”, anchor retrieval identifies “Inception”. The RSF module constructs a subgraph and iteratively propagates flows first to “Christopher Nolan” (bridge node without lexical overlap to the query 'awards') solely via dynamic gating allowing pure structural traversal, then to award nodes. Paths are textualized into strings such as “Inception → Christopher Nolan → Academy Award” that are fed into the fine-tuned LLM to generate the final grounded answer. This example demonstrates bridging semantic gaps through structural clues and the dynamic gate mechanism.

Technical innovations

• A Recurrent Soft-Flow (RSF) differentiable graph reasoning module that propagates continuous, gated node relevance scores guided by a GRU-based recurrent query updater over multi-hop KGQA subgraphs.
• A dynamic gating mechanism that adaptively modulates between structure-only and content-biased flow propagation to bridge semantic gaps where intermediate nodes share no lexical overlap with the query.
• Entropy-based flow sparsity regularization that theoretically guarantees convergence from soft distributions to discrete, interpretable reasoning paths, enabling faithful post-hoc path extraction within a differentiable framework.
• A decoupled two-stage Graph-to-LLM design that separates lightweight structural inference from grounded answer generation, significantly reducing computational cost compared to agentic LLM traversal approaches.

Datasets

• WebQSP — approx. 4,700 queries — public KGQA dataset linked to Freebase with up to 2-hop reasoning
• CWQ (Complex WebQuestions) — size not specified, multi-hop with up to 4-hop compositional queries — public dataset linked to Freebase

Baselines vs proposed

• RoG (LLaMA2-7B): Hit@1 = 85.7% on WebQSP vs RSF-GLLM (Qwen3-8B): 90.45%
• DECAF (FiD-3B): Hit@1 = 82.1% on WebQSP vs RSF-GLLM (Qwen3-8B): 90.45%
• GNN-RAG (LLaMA2-7B): Hit@1 = 80.6% on WebQSP vs RSF-GLLM (Qwen3-8B): 90.45%
• RSF-GLLM (Qwen3-8B) inference time per query ~0.25s on A100 vs RoG >9,671s per epoch, GNN-RAG ~737s/epoch
• Removing content bias from RSF drops Hit@10 on WebQSP by 6.4%
• Disabling GRU query update reduces Hit@10 by 5.6% (WebQSP ablation)
• Without dynamic gating, Hit@10 drops by 2.4%, and without flow sparsity by 3.6%

Figures from the paper

Figures are reproduced from the source paper for academic discussion. Original copyright: the paper authors. See arXiv:2607.06527.

Fig 2: Effect of λ1 on Hit@1 and entropy. Optimal at λ1 = 0.1.

Fig 3: presents the mean λ(t) values aggregated across all 4-hop questions in the CWQ test set. The results reveal an

Limitations

• CWQ test coverage by BFS-extracted subgraphs (K=4) is limited (80.7% ceiling), restricting maximal achievable recall and accuracy.
• No explicit adversarial or noisy KG evaluation; robustness to malformed or corrupted graphs is untested.
• The approach relies on accurate dense retrieval of topic entities; errors here may propagate downstream with no explicit mitigation.
• Fine-tuning the LLM requires availability of reasoning paths; closed-source or proprietary LLMs might limit practical deployment or explainability.
• Experiments do not explore extensive hyperparameter sensitivity beyond λ1 or ablations on larger LLM scales.
• The dynamic gating mechanism is a learned scalar per hop; more complex gate designs or learned gating policies are not explored.

Open questions / follow-ons

• How does RSF-GLLM perform under adversarial or noisy KG perturbations that introduce spurious edges or corrupt node features?
• Can the dynamic gating mechanism be generalized or replaced by more expressive meta-learned policies to better handle diverse semantic gap patterns?
• How well does the approach scale to larger graphs with more hops beyond K=4, and can dynamic subgraph expansion methods address coverage limitations seen on CWQ?
• Could joint end-to-end training or tighter integration of RSF and LLM modules further improve fidelity and reduce generation hallucinations?

Why it matters for bot defense

For bot-defense and CAPTCHA practitioners interested in bot detection via behavioral or knowledge graph reasoning signals, RSF-GLLM demonstrates a promising methodology for extracting and interpreting multi-hop logical chains from structured data with improved fidelity and efficiency. Its dynamic gating approach to bridging semantic gaps could inspire designs for detecting automated navigation or probing attempts that manipulate graph-like contexts in challenge-response settings. Additionally, the decoupled architecture with explicit reasoning path textualization offers greater interpretability and auditability, critical for verifying bot vs human behavior at scale. However, adaptation to more adversarial or real-time environments would require further robustness validations.

Cite

@article{arxiv2607_06527,
  title={ RSF-GLLM: Bridging the Semantic Gap in Multi-Hop Knowledge Graph QA via Recurrent Soft-Flow and Decoupled LLM Generation },
  author={ Sambaran Bandyopadhyay and Ananth Muppidi },
  journal={arXiv preprint arXiv:2607.06527},
  year={ 2026 },
  url={https://arxiv.org/abs/2607.06527}
}

Read the full paper

• arXiv:2607.06527 (abstract)
• arXiv:2607.06527 (PDF)