K ae D e: Progressive Generation of Logical Forms via Knowledge-Aware Question Decomposition for Improved KBQA (2025)

Abstract: Knowledge base question answering (KBQA) refers to the task of answering natural language questions using large-scale structured knowledge bases (KBs). Existing semantic parsing-based (SP-based) methods achieve superior performance by directly converting questions into structured logical form (LF) queries using fine-tuned large language models (LLMs). However, these methods face the key challenge of difficulty in directly generating LFs for complex graph structures, which often leads to non-executable LFs that negatively impact overall KBQA performance. To address this challenge, we propose KaeDe, a novel generate-then-retrieve method for KBQA. This approach integrates knowledge-aware question decomposition and subsequent progressive LF generation within the generation phase, followed by an unsupervised retrieval phase. Specifically, the original question is decomposed into simplified, topic entity-centric sub-questions and explanations within the KB context. Path-level LFs are derived from these intermediate expressions and then combined into a comprehensive graph-level LF. Finally, the LF is refined through unsupervised entity and relation retrieval. Experimental results demonstrate that our method achieves state-of-the-art (SOTA) performance on WebQuestionSP (WebQSP) and ComplexWebQuestions (CWQ) benchmarks, particularly with fewer model parameters.

## introduction knowledge base question answering (kbqa) refers to the task of retrieving answers to natural language questions leveraging factural information from large-scale knowledge bases (kbs). in kbs such as freebase @xcite and wikidata @xcite , entities are connected through relations, forming structured knowledge graphs (kgs). building on graph structures, most kbqa methods, including both information retrieval-based (irbased) @xcite @xcite and semantic parsingbased (sp-based) @xcite @xcite approaches, emphasize graphbased retrieval to obtain answers. specifically, spbased approaches generate concise structured expressions, such as logical forms (lfs), which can be transformed into sparql queries for further execution in kbs. these lfs represent the retrieval subgraphs, which are composed of reasoning paths originating from each topic entity mentioned in the question. as a result, errors in the subgraph description lead to non-execution, which signifies the failure to derive any answer after execution, posing a significant challenge for sp-based methods. most existing sp-based methods adopt retrievethen-generate strategies, where relevant information is first retrieved from kbs and then used to construct the lfs @xcite @xcite @xcite . however, the retrieval complexity introduces additional computational overhead and distracting noise, with the performance of subsequent generation being heavily dependent on this prior process. apart from these traditional methods, novel generate-then-retrieve strategies @xcite for direct lf generation have been proposed and demonstrated to be effective, leveraging the remarkable reasoning capabilities of large language models (llms) @xcite . in this context, high-quality lfs are directly generated using instruction-tuned @xcite llms, which are equipped with knowledge from specific domains, and refined with minimal retrieval, primarily for entity linking or additional relation alignment. yet, (1) these llms often fail to focus on all the details in complex questions. to statistically illustrate the problem, we reproduce experiments on direct lf generation followed by retrieval with a beam size of 8, using llama 2 @xcite 7b and 13b models on the complexwe-bquestions (cwq) dataset @xcite , as shown in to alleviate the performance decline in complex questions, prior research in question answering (qa) suggests simplifying the process by decomposing the questions into more manageable sub-questions and addressing each one separately @xcite . specifically, the original questions are initially decomposed using tree-based @xcite , rule-based @xcite and other strategies @xcite , followed by irbased or sp-based processes applied individually to each sub-question. however, (2) these decomposition processes often prioritize the original question itself, with less emphasis on grounding in the knowledge from kbs, which may introduce potential inaccuracies in the subsequent procedures due to the semantic gap between the original question and the specific knowledge. under the condition of following sp-based processes, errors in the sub-questions may lead to schema errors during the generation of intermediate lfs and, further, result in the non-executability of the final lf. therefore, we propose kaede, a novel generatethen-retrieve approach for kbqa. the method integrates knowledge-aware question decomposition and subsequent progressive lf generation within the generation phase, followed by an unsupervised retrieval phase. specifically, to address issue (1), we break down the complex lf generation into sim-pler tasks through question decomposition. in this approach, sub-questions and explanations, starting from each potential topic entity, are generated by a fine-tuned llm within the kb context to tackle issue (2). guided by these intermediate expressions, path-level lfs are generated and assembled into a complete graph-level lf using the same llm. finally, the graph-level lf is refined during the retrieval phase and executed within the kbs to obtain answers. our contributions can be summarized as follows: ## conclusion in this paper, we propose kaede, a novel llmbased generate-then-retrieve approach for kbqa that optimizes complex lf generation through knowledge-aware question decomposition and the subsequent progressive lf generation. specifically, by using a fine-tuned llm, the original question is decomposed into simpler entity-centric sub-questions or explanations grounded in kb. path-level lfs are then mapped from these intermediate expressions and assembled into the final graph-level lf using the same llm. in conclusion, kaede reduces the complexity of lf generation by breaking it down into simpler decomposed tasks, achieving sota performance on webqsp and cwq datasets, particularly with fewer model parameters. limitations additional computational overhead. we utilize beam search during question decomposition, path-level lf generation, and graph-level assembly. in contrast to the single process in direct lf generation, kaede employs three sequential processes, where each subsequent process is generated based on the beam search results of the previous one. this intermediate beam search introduces additional computational overhead. in future work, we plan to address this issue by implementing pruning strategies during intermediate steps to reduce the complexity. noise from beam search and retrieval phase. another issue stemming from beam search is the introduction of noise. during the retrieval phase, nonexecutable lfs are transformed into executable ones based on the skeleton by replacing the semantically similar entities and relations within the generated lfs. however, some irrelevant lfs produced during beam search may also be calibrated into executable forms, leading to inaccurate results. in future work, we aim to mitigate this issue