Pith. sign in

REVIEW 4 major objections 5 minor 37 references

TARGA: Targeted Synthetic Data Generation for Practical Reasoning over Structured Data

T0 review · 4 major / 5 minor · reviewed 2026-08-11 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read TARGA claims that a 7B model with no annotated data can beat closed-source KBQA systems by generating targeted synthetic demonstrations for each test question.

desk verdict Strong empirical method for targeted synthetic demonstrations in KBQA, but the 'zero annotation' claim is overstated because the entity linking comes from a benchmark-trained model. read the letter →

arxiv 2412.19544 v1 pith:KNF3GEFR submitted 2024-12-27 cs.CL cs.AI

Xiang Huang , Jiayu Shen , Shanshan Huang , Sitao Cheng , Xiaxia Wang , Yuzhong Qu This is my paper · ORCID
classification cs.CLcs.AI
keywords semanticparsingknowledgebasequestionansweringin-contextlearningsyntheticdatagenerationzero-shotgeneralizationquerygraphexpansiontext-to-SQLtargeteddemonstrations
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

This paper argues that the bottleneck in knowledge-base question answering is not model size or annotated data but the relevance of demonstrations: instead of retrieving examples from a static labeled corpus, TARGA builds a small set of synthetic query-question pairs tailored to the test question, in real time, and feeds them to an in-context learning model. With only a 7B-parameter open model and no manual annotation, it reports F1 scores of 69.0 on GrailQA, up from 61.3 for the best previous non-fine-tuned method, and 46.5 on KBQA-Agent, up from 34.3. If correct, this makes semantic parsing over structured data substantially cheaper and more adaptable: no annotation budget, no offline retrieval index, and less dependence on expensive closed-source APIs. It also reframes generalization as a data-generation problem rather than a data-collection problem.

What carries the argument

The load-bearing mechanism is the two-stage synthetic query constructor: layer-wise expansion grows chain-like multi-hop queries one relation at a time, and cross-layer combination merges two verified queries through a shared variable to produce multi-constraint graphs, with every query executed against the knowledge base to require a non-empty result. Around this sits a re-ranking stage using bge-reranker-v2-m3 on query textification outputs plus a hierarchical top-n per parent query, which keeps the candidate pool small while keeping relevant queries retrievable. The final in-context learning prompt pairs the top-ranked textified queries with their generated natural-language questions, so the LLM sees examples that match the target question's own entities and relations.

What would settle it

Compute TARGA's F1 separately on the questions whose synthetic pool contains no perfect (F1=1) query, using the paper's coverage split; if that F1 is close to zero, the headline results are fully explained by candidate coverage and the LLM contributes no structure beyond the pool, whereas if it is substantial, the ICL model is generalizing beyond the generated candidates and the coverage ceiling is not a binding constraint.

Watch

Extended reading notes

Core claim

TARGA's central claim is that the most effective demonstrations for in-context semantic parsing are not the most similar labeled examples from a training set but synthetic examples generated from the knowledge base itself, targeted to the entities and relations of the incoming question. Concretely, it links the question's entities via Pangu's linker and takes the top-20 relations by text-embedding similarity, then explores valid query graphs by layer-wise expansion (multi-hop chains grown one edge at a time) and cross-layer combination (multi-constraint graphs merged through a shared variable). Each candidate is executed against the knowledge base and kept only if it returns a non-empty result. Queries are re-ranked with a cross-encoder reranker after 'textification' into natural-language-like strings, and the top 10 are presented as (question, query) demonstrations to a 7B instruct model. The paper reports that this procedure, with no annotations and no static corpus, outperforms all non-fine-tuned baselines on GrailQA, GraphQ, KBQA-Agent, and WikiSQL, while using about a tenth of the tokens of ICL baselines.

Load-bearing premise

TARGA's success rests on the assumption that its candidate retrieval and expansion steps place the correct query in the synthetic pool: top-20 embedding-similar relations, at most three hops and five edges, and valid execution against the KB; the paper's own Table 9 shows this pool is complete for only 0.79 of GrailQA, 0.69 of GraphQ, and 0.78 of KBQA-Agent questions, so for the remaining 21-31% the LLM must succeed by guessing.

Editorial extensions

If this is right

  • Zero-annotation semantic parsing becomes practical: TARGA needs no human-labeled training set, no retrieval index over annotations, and no closed-source API, yet improves the best non-fine-tuned F1 on GrailQA from 61.3 to 69.0 and on KBQA-Agent from 34.3 to 46.5.
  • Small open models can compete with large closed models on structured reasoning: at 7B, TARGA matches or exceeds GPT-3.5-turbo on GrailQA and beats all non-fine-tuned methods on GraphQ and KBQA-Agent, while a 1.5B variant already surpasses the previous best non-fine-tuned method.
  • Generalization to non-I.I.D. settings stops being a retrieval failure: on GrailQA's zero-shot split, TARGA scores 71.7 versus 41.8-43.2 for KB-Binder and KB-Coder, because every test question receives fresh targeted demonstrations instead of similar-but-mismatched corpus examples.
  • The same recipe transfers to other logic-form tasks: on WikiSQL, 10 synthetic demonstrations outperform methods using 32 annotated examples and approach the accuracy of a fine-tuned 3B model.
  • Robustness to bad demonstrations improves markedly: corrupting every synthetic demonstration drops TARGA's F1 by only about 25%, while similarity-retrieval and random ICL baselines fall by roughly 40% and 75%, suggesting the model leans on the per-question target rather than exact demonstration content.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • The paper's own coverage statistics imply an upper bound it does not discuss: on GrailQA, GraphQ, and KBQA-Agent, only 79%, 69%, and 78% of questions have at least one F1=1 synthetic query, so the remaining 21-31% must depend on the LLM generalizing beyond the candidate pool; improving coverage, not just ranking, is the natural next lever.
  • Because TARGA's relation candidates come from text-embedding similarity, the framework inherits the embedding model's lexical and multilingual blind spots; in domains with heavy paraphrase or low-resource languages, coverage may be lower than the paper's English Freebase results, which the paper did not test.
  • If the ranking step is doing most of the work, TARGA could be combined with any generator of candidate logical forms, not just graph expansion: for example, an LLM's own drafts could be executed, filtered, and re-ranked with the same textification-plus-reranker loop, a testable extension the paper does not explore.
  • The 3-hop and 5-edge limits, chosen because most benchmark questions fit within them, mean TARGA is calibrated to current dataset complexity; questions requiring deeper chains or more constraints would need those thresholds raised, with a likely quadratic cost in candidate queries.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

4 major / 5 minor

Summary. TARGA is a framework for KBQA and Text2SQL that, for each test question, dynamically constructs a small set of candidate SPARQL/PyQL queries by expanding from retrieved entities and relations, re-ranks them, and feeds the top ones as (query, pseudo-question) demonstrations to a 7B LLM in a few-shot manner. The paper reports state-of-the-art results among non-fine-tuned methods on GrailQA, GraphQ, and KBQA-Agent, competitive results on MetaQA and WikiSQL, and provides ablations, robustness, efficiency, and model-size analyses. The central claim is that this online synthetic-data generation achieves these results without any manual annotation.

Significance. If the results hold, TARGA offers a practical recipe for reasoning over structured data with a small open-source LLM and no task-specific fine-tuning of the reasoning model. The paper's strengths include the clear pipeline description, the extensive ablations in Table 5, the robustness experiments in Figures 4-5, the efficiency analysis in Table 3, the model-size study in Table 4, and a public code repository. The main empirical contribution—strong KBQA results from a 7B model without fine-tuning—is interesting and potentially useful. However, the 'zero annotation' claim is currently not clean because the entity linker is a fine-tuned model trained on the same benchmark, and the coverage analysis reveals that a substantial fraction of test questions have no correct synthetic query, a fact the paper does not analyze further. The paper is transparent about its components, which is a credit, but the claims need to be realigned with the actual dependencies.

major comments (4)
  1. [Section 3.2, Appendix E.2, Table 1] The abstract and introduction state that TARGA works 'without any data annotation,' but for GrailQA and GraphQ the candidate entities come from the entity linking output of Pangu (Gu et al., 2023), which Table 1 lists as a sequence-to-sequence model fine-tuned on the full training set of the same benchmark. Appendix E.2 confirms that TARGA uses this Pangu linking result on GrailQA and GraphQ. The method therefore relies on a supervised component trained with human-annotated data, so the 'zero annotation' framing is misleading and the comparison with KB-Binder and KB-Coder, which use FACC1+BM25/SimCSE linking, is not an annotation-free comparison. In addition, on KBQA-Agent and MetaQA-3Hop, TARGA uses golden entity linking (Table 8). The paper should either add an ablation with an annotation-free linker (e.g., FACC1 or a pure string-match linker) and report the performance difference, or explicitly qualify the 'zero annotation' claim to refer only to the reasoning component.
  2. [Table 9] Table 9 reports coverage, the proportion of questions with at least one F1=1 synthetic query, as only 0.79 on GrailQA, 0.69 on GraphQ, 0.78 on KBQA-Agent, and 0.75 on WikiSQL. For the remaining 21-31% of test questions, the synthetic pool contains no correct query, yet the paper does not report performance separately for covered versus uncovered questions. This is essential for interpreting the headline results: if the F1 gains are concentrated on covered questions, the method is largely copying or lightly editing a correct query from the demonstrations; if the model also solves many uncovered questions, that would support the generalization claim. Please report the covered/uncovered F1 breakdown on the main KBQA datasets and discuss the model's behavior on uncovered questions.
  3. [Section 3.3, Eqs. (1)-(3)] The query construction stops at three hops and five edges based on informal statements that coherent questions 'typically' fall within these bounds. The paper provides no empirical distribution of the number of hops or edges required by the test sets, nor an analysis of how many correct queries are missed because of these limits beyond the aggregate coverage in Table 9. Since the coverage values already show that a substantial fraction of questions have no correct query in the pool, the hop and edge limits are a likely contributor. Please provide the distribution of required query complexity in the datasets and show that the 3-hop/5-edge thresholds do not systematically exclude a meaningful class of correct queries.
  4. [Section 4.2, Tables 1-6] All reported F1 and accuracy numbers are single-run values with no confidence intervals, standard deviations, or significance tests. Given that the pipeline involves stochastic elements (embedding, reranking, and LLM decoding), it would be useful to report multiple runs or seed variance for at least the main comparisons, so that the reader can assess whether the reported gaps (e.g., +7.7 on GrailQA and +12.2 on KBQA-Agent) are robust to this variability.
minor comments (5)
  1. [Abstract and Section 4.2] 'close-sourced model' should be 'closed-source model' in both occurrences.
  2. [Section 3.4, Eq. (4)] The phrase 'top tanked candidates' should be 'top-ranked candidates'.
  3. [Table 1] The category label 'zero annotation (ICL)' is misleading because TARGA uses the fine-tuned Pangu entity linker for GrailQA and GraphQ and golden linking for KBQA-Agent and MetaQA-3Hop; please rename or footnote this category to reflect the actual entity-linking dependencies.
  4. [Section 3.4] The hierarchical ranking strategy retains 'top n candidates' per parent query, but the value of n is not reported in the main text or appendices; please state the hyperparameter value used in the experiments.
  5. [Appendix E.2] The phrase 'make a fair comparison' is used to justify following the Pangu entity linking setup; please clarify whether this is a claim about no-annotation conditions or simply a statement about matching the baselines' preprocessing.

Circularity Check

0 steps flagged · score 0.0 of 10

No circularity: TARGA's query construction, reranking, and ICL prediction are not defined in terms of the reported test targets, and no fitted parameter is renamed as a prediction.

full rationale

The derivation chain is not circular by construction. The synthetic queries are generated by executing candidate structures against Freebase (Eqs. 1-3) from entity and relation candidates, and the final logic form is produced by in-context learning, not by selecting from a fitted objective on the test labels. No quantity in TARGA is fitted to the GrailQA, GraphQ, or KBQA-Agent test sets, and the reported F1 scores are not an optimization target of the method. The 'zero annotation' claim does depend on an externally trained entity linker (Pangu, Gu et al. 2023, Section 3.2 and Appendix E.2), which is a legitimate annotation-accounting and fairness concern: Pangu is listed as a full-training-set fine-tuned method in Table 1, so the paper's 'zero annotation (ICL)' row should be read with that dependency in mind. However, this is not circularity: Pangu's linking outputs are fixed external inputs, not predictions derived from TARGA's own outputs, and no equation or definition makes TARGA's result equivalent to those linking outputs by construction. The reimplementation of AgentBench via QueryAgent (Huang et al., 2024) involves overlapping authorship but is a baseline reporting choice, not load-bearing evidence for TARGA's derivation. The paper is otherwise self-contained against external benchmarks, so the circularity score is 0.

Assumptions & free parameters 5 free parameters · 6 assumptions · 0 invented entities

The framework's behavior is governed by hand-set thresholds and structural limits on query graphs. These are not fitted to the test labels, but they directly determine whether the correct query can appear in the synthetic pool, and the paper's own coverage numbers show they fail on a substantial minority of questions.

free parameters (5)
  • Relation candidate pool size (top-k) = 20
    Section 3.2 retains the top 20 relations by embedding similarity; recall of the correct relation depends on this threshold.
  • Maximum query depth (hop limit) = 3
    Section 3.3 stops expansion at 3 hops, justified as typical; any question needing more hops is not synthesized.
  • Maximum query width (edge limit) = 5
    Section 3.3 stops combination at 5 edges, assumed sufficient for most dataset questions.
  • Hierarchical ranking top-n per parent = not stated
    Equation 4 keeps the top n candidates per parent query, but the numeric value is not given in the paper, so pool size and ranking behavior are not exactly reproducible.
  • Number of demonstrations = 10
    Section 4.1 uses 10 demonstrations for all datasets; the sample efficiency curve shows gains flatten after 7 shots, so this choice affects cost and performance.
assumptions (6)
  • domain assumption Freebase is a static, executable knowledge graph available to the system.
    Query construction executes candidate queries against the KB in Section 3.3, which assumes the full Freebase graph and a SPARQL engine.
  • ad hoc to paper Distance from a question's entity to the final answer never exceeds three hops for coherent questions.
    Section 3.3 states 'the distance between a specific entity and the final answer typically does not exceed three hops.' This bounds the search and can exclude valid questions.
  • ad hoc to paper Five-edge query graphs suffice to model most questions in current datasets.
    Section 3.3 terminates combination at five edges, stated as sufficient without dataset-specific evidence.
  • ad hoc to paper The top 20 embedding-similar relations plus Pangu entity linking contain the correct KB items.
    Section 3.2 sets these retrieval thresholds; Table 9 coverage on Freebase datasets is 0.69 to 0.79, so the premise fails on a non-trivial fraction of questions.
  • domain assumption Pseudo-questions produced by rule-based textification are adequate natural language demonstrations.
    Section 3.5 uses textification output as the NLQ; Appendix E.6 reports that LLM-generated questions change F1 by less than 0.5, supporting this.
  • domain assumption In-context learning from synthetic (question, query) pairs transfers to the test question.
    The whole framework in Section 4 relies on the LLM's ICL ability rather than fine-tuning on the synthetic data.

how reviews work

0 comments
Cite this review

Pith. "Pith review of TARGA: Targeted Synthetic Data Generation for Practical Reasoning over Structured Data." pith.science (2026). https://pith.science/paper/KNF3GEFR

@misc{pith2026241219544,
  author       = {Pith},
  title        = {Pith review of: TARGA: Targeted Synthetic Data Generation for Practical Reasoning over Structured Data},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/KNF3GEFR}},
  note         = {Machine review of arXiv:2412.19544}
}
read the original abstract

Semantic parsing, which converts natural language questions into logic forms, plays a crucial role in reasoning within structured environments. However, existing methods encounter two significant challenges: reliance on extensive manually annotated datasets and limited generalization capability to unseen examples. To tackle these issues, we propose Targeted Synthetic Data Generation (TARGA), a practical framework that dynamically generates high-relevance synthetic data without manual annotation. Starting from the pertinent entities and relations of a given question, we probe for the potential relevant queries through layer-wise expansion and cross-layer combination. Then we generate corresponding natural language questions for these constructed queries to jointly serve as the synthetic demonstrations for in-context learning. Experiments on multiple knowledge base question answering (KBQA) datasets demonstrate that TARGA, using only a 7B-parameter model, substantially outperforms existing non-fine-tuned methods that utilize close-sourced model, achieving notable improvements in F1 scores on GrailQA(+7.7) and KBQA-Agent(+12.2). Furthermore, TARGA also exhibits superior sample efficiency, robustness, and generalization capabilities under non-I.I.D. settings.

Figures

Figures reproduced from arXiv: 2412.19544 by the authors.

Figure 1
Figure 1. Compared with previous methods, TARGA aims to mitigate the reliance on large amounts of manu￾ally labeled data and enhance generalization capabilities in non-i.i.d. scenarios. However, current semantic paring methods typi￾cally face two significant challenges: 1) Dependence on annotation. Previous meth￾ods usually rely on extensive amounts of manu￾ally annotated data. By training (Ye et al., 2022; Shu et al., 2022) … view at source ↗
Figure 2
Figure 2. Overview of TARGA. Cross-layer Combination models multi￾constraint structures (the width of the query graph) by merging two queries, thereby applying multiple constraints to the same variable. Given two queries q and q ′ , we choose one of the variables from each query (oi for q and oj for q ′ ) as the common variable of them, then combine these two queries into a more complex query through this shared variable. We … view at source ↗
Figure 4
Figure 4. Performance under attack setting on 1,000 [PITH_FULL_IMAGE:figures/full_fig_p006_4.png] view at source ↗
Figures from the paper (1 more)
Figure 5
Figure 5. Figure 5: Performance under attack setting(entity) on [PITH_FULL_IMAGE:figures/full_fig_p015_5.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

37 extracted references · 12 canonical work pages

  1. [1]

    Dhruv Agarwal, Rajarshi Das, Sopan Khosla, and Rashmi Gangadharaiah. 2024. https://doi.org/10.18653/v1/2024.findings-naacl.57 Bring your own KG : Self-supervised program synthesis for zero-shot KGQA . In Findings of the Association for Computational Linguistics: NAACL 2024, pages 896--919

    work page doi:10.18653/v1/2024.findings-naacl.57 2024

  2. [2]

    Kurt Bollacker, Colin Evans, Praveen Paritosh, Tim Sturge, and Jamie Taylor. 2008. https://doi.org/10.1145/1376616.1376746 Freebase: a collaboratively created graph database for structuring human knowledge . In Proceedings of the 2008 ACM SIGMOD International Conference on Management of Data, SIGMOD '08, page 1247–1250, New York, NY, USA. Association for ...

    arXiv 2008

  3. [3]

    Tom Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared D Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, Sandhini Agarwal, Ariel Herbert-Voss, Gretchen Krueger, Tom Henighan, Rewon Child, Aditya Ramesh, Daniel Ziegler, Jeffrey Wu, Clemens Winter, Chris Hesse, Mark Chen, Eric Sigler, Mateusz Litwin, Scott Gr...

    work page 2020

  4. [4]

    Shulin Cao, Jiaxin Shi, Liangming Pan, Lunyiu Nie, Yutong Xiang, Lei Hou, Juanzi Li, Bin He, and Hanwang Zhang. 2022. https://doi.org/10.18653/v1/2022.acl-long.422 KQA pro: A dataset with explicit compositional programs for complex question answering over knowledge base . In Proceedings of the 60th Annual Meeting of the Association for Computational Lingu...

    doi:10.18653/v1/2022.acl-long.422 2022

  5. [5]

    Jianlv Chen, Shitao Xiao, Peitian Zhang, Kun Luo, Defu Lian, and Zheng Liu. 2024. https://arxiv.org/abs/2402.03216 Bge m3-embedding: Multi-lingual, multi-functionality, multi-granularity text embeddings through self-knowledge distillation . Preprint, arXiv:2402.03216

    arXiv 2024

  6. [6]

    Sitao Cheng, Ziyuan Zhuang, Yong Xu, Fangkai Yang, Chaoyun Zhang, Xiaoting Qin, Xiang Huang, Ling Chen, Qingwei Lin, Dongmei Zhang, Saravan Rajmohan, and Qi Zhang. 2024. https://arxiv.org/abs/2403.08593 Call me when necessary: Llms can efficiently and faithfully reason over structured environments . Preprint, arXiv:2403.08593

    work page Pith review arXiv 2024

  7. [7]

    Gonzalez, Ion Stoica, and Eric P

    Wei-Lin Chiang, Zhuohan Li, Zi Lin, Ying Sheng, Zhanghao Wu, Hao Zhang, Lianmin Zheng, Siyuan Zhuang, Yonghao Zhuang, Joseph E. Gonzalez, Ion Stoica, and Eric P. Xing. 2023. https://lmsys.org/blog/2023-03-30-vicuna/ Vicuna: An open-source chatbot impressing gpt-4 with 90\

    2023

  8. [8]

    Haishuo Fang, Xiaodan Zhu, and Iryna Gurevych. 2024. https://doi.org/10.18653/v1/2024.findings-acl.203 DARA : Decomposition-alignment-reasoning autonomous language agent for question answering over knowledge graphs . In Findings of the Association for Computational Linguistics: ACL 2024, pages 3406--3432, Bangkok, Thailand. Association for Computational L...

    doi:10.18653/v1/2024.findings-acl.203 2024

Show all 37 references
  1. [9]

    Williams Gregory. 2013. Sparql 1.1 service description. w3c recommendation. World Wide Web Consortium

    2013

  2. [10]

    Yu Gu, Xiang Deng, and Yu Su. 2023. https://aclanthology.org/2023.acl-long.270 Don ' t generate, discriminate: A proposal for grounding language models to real-world environments . In Proceedings of the 61st Annual Meeting of the Association for Computational Linguistics (Volu...

    2023

  3. [11]

    Yu Gu, Sue Kase, Michelle Vanni, Brian Sadler, Percy Liang, Xifeng Yan, and Yu Su. 2021. https://doi.org/10.1145/3442381.3449992 Beyond I.I.D.: Three levels of generalization for question answering on knowledge bases . The Web Conference 2021 - Proceedings of the World Wide We...

    2021

  4. [12]

    Yu Gu, Yiheng Shu, Hao Yu, Xiao Liu, Yuxiao Dong, Jie Tang, Jayanth Srinivasa, Hugo Latapie, and Yu Su. 2024. https://arxiv.org/abs/2402.14672 Middleware for llms: Tools are instrumental for language agents in complex environments . Preprint, arXiv:2402.14672

    2024 arXiv

  5. [13]

    Yu Gu and Yu Su. 2022. https://aclanthology.org/2022.coling-1.148 A rcane QA : Dynamic program induction and contextualized encoding for knowledge base question answering . In Proceedings of the 29th International Conference on Computational Linguistics, pages 1718--1731

    2022

  6. [14]

    Xixin Hu, Xuan Wu, Yiheng Shu, and Yuzhong Qu. 2022. https://aclanthology.org/2022.coling-1.145 Logical form generation via multi-task learning for complex question answering over knowledge bases . In Proceedings of the 29th International Conference on Computational Linguistic...

    2022

  7. [15]

    Xiang Huang, Sitao Cheng, Yuheng Bao, Shanshan Huang, and Yuzhong Qu. 2023. https://doi.org/10.18653/v1/2023.emnlp-main.633 M ark QA : A large scale KBQA dataset with numerical reasoning . In Proceedings of the 2023 Conference on Empirical Methods in Natural Language Processin...

    2023 doi

  8. [16]

    Xiang Huang, Sitao Cheng, Shanshan Huang, Jiayu Shen, Yong Xu, Chaoyun Zhang, and Yuzhong Qu. 2024. https://arxiv.org/abs/2403.11886 Queryagent: A reliable and efficient reasoning framework with environmental feedback-based self-correction . Preprint, arXiv:2403.11886

    2024 arXiv

  9. [17]

    Jinhao Jiang, Kun Zhou, Zican Dong, Keming Ye, Xin Zhao, and Ji-Rong Wen. 2023. https://doi.org/10.18653/v1/2023.emnlp-main.574 S truct GPT : A general framework for large language model to reason over structured data . In Proceedings of the 2023 Conference on Empirical Method...

    2023 doi

  10. [18]

    Jinhao Jiang, Kun Zhou, Wayne Xin Zhao, Yang Song, Chen Zhu, Hengshu Zhu, and Ji-Rong Wen. 2024. https://arxiv.org/abs/2402.11163 Kg-agent: An efficient autonomous agent framework for complex reasoning over knowledge graph . Preprint, arXiv:2402.11163

    2024 arXiv

  11. [19]

    Jeff Johnson, Matthijs Douze, and Herv \'e J \'e gou. 2019. Billion-scale similarity search with GPUs . IEEE Transactions on Big Data, 7(3):535--547

    2019

  12. [20]

    Gonzalez, Hao Zhang, and Ion Stoica

    Woosuk Kwon, Zhuohan Li, Siyuan Zhuang, Ying Sheng, Lianmin Zheng, Cody Hao Yu, Joseph E. Gonzalez, Hao Zhang, and Ion Stoica. 2023. https://arxiv.org/abs/2309.06180 Efficient memory management for large language model serving with pagedattention . Preprint, arXiv:2309.06180

    2023 arXiv

  13. [21]

    Haoyang Li, Jing Zhang, Cuiping Li, and Hong Chen. 2023 a . Resdsql: Decoupling schema linking and skeleton parsing for text-to-sql. In AAAI

    2023

  14. [22]

    Tianle Li, Xueguang Ma, Alex Zhuang, Yu Gu, Yu Su, and Wenhu Chen. 2023 b . https://doi.org/10.18653/v1/2023.acl-long.385 Few-shot in-context learning on knowledge base question answering . In Proceedings of the 61st Annual Meeting of the Association for Computational Linguist...

    2023 doi

  15. [23]

    Zhenyu Li, Sunqi Fan, Yu Gu, Xiuxing Li, Zhichao Duan, Bowen Dong, Ning Liu, and Jianyong Wang. 2023 c . https://arxiv.org/abs/2308.12060 Flexkbqa: A flexible llm-powered framework for few-shot knowledge base question answering . Preprint, arXiv:2308.12060

    2023 arXiv

  16. [24]

    Xiao Liu, Hao Yu, Hanchen Zhang, Yifan Xu, Xuanyu Lei, Hanyu Lai, Yu Gu, Hangliang Ding, Kaiwen Men, Kejuan Yang, Shudan Zhang, Xiang Deng, Aohan Zeng, Zhengxiao Du, Chenhui Zhang, Sheng Shen, Tianjun Zhang, Yu Su, Huan Sun, Minlie Huang, Yuxiao Dong, and Jie Tang. 2024. https...

    2024 arXiv

  17. [25]

    Zhijie Nie, Richong Zhang, Zhongyuan Wang, and Xudong Liu. 2023. https://arxiv.org/abs/2309.04695 Code-style in-context learning for knowledge-based question answering . Preprint, arXiv:2309.04695

    2023 arXiv

  18. [26]

    Torsten Scholak, Nathan Schucher, and Dzmitry Bahdanau. 2021. https://doi.org/10.18653/v1/2021.emnlp-main.779 PICARD : Parsing incrementally for constrained auto-regressive decoding from language models . In Proceedings of the 2021 Conference on Empirical Methods in Natural La...

    2021 doi

  19. [27]

    Yiheng Shu, Zhiwei Yu, Yuhan Li, B \"o rje Karlsson, Tingting Ma, Yuzhong Qu, and Chin-Yew Lin. 2022. https://doi.org/10.18653/v1/2022.emnlp-main.555 TIARA : Multi-grained retrieval for robust question answering over large knowledge base . In Proceedings of the 2022 Conference...

    2022 doi

  20. [28]

    Yu Su, Huan Sun, Brian Sadler, Mudhakar Srivatsa, Izzeddin G \" u r, Zenghui Yan, and Xifeng Yan. 2016. https://aclanthology.org/D16-1054 On generating characteristic-rich question sets for QA evaluation . In Empirical Methods in Natural Language Processing (EMNLP), Austin, Texas, USA

    2016

  21. [29]

    Alon Talmor and Jonathan Berant. 2018. https://doi.org/10.18653/v1/N18-1059 The web as a knowledge-base for answering complex questions . In Proceedings of the 2018 Conference of the North A merican Chapter of the Association for Computational Linguistics: Human Language Techn...

    2018 doi

  22. [30]

    Hashimoto

    Rohan Taori, Ishaan Gulrajani, Tianyi Zhang, Yann Dubois, Xuechen Li, Carlos Guestrin, Percy Liang, and Tatsunori B. Hashimoto. 2023. Stanford alpaca: An instruction-following llama model. https://github.com/tatsu-lab/stanford_alpaca

    2023

  23. [31]

    Smith, Daniel Khashabi, and Hannaneh Hajishirzi

    Yizhong Wang, Yeganeh Kordi, Swaroop Mishra, Alisa Liu, Noah A. Smith, Daniel Khashabi, and Hannaneh Hajishirzi. 2023. https://doi.org/10.18653/v1/2023.acl-long.754 Self-instruct: Aligning language models with self-generated instructions . In Proceedings of the 61st Annual Mee...

    2023 doi

  24. [32]

    Xi Ye, Semih Yavuz, Kazuma Hashimoto, Yingbo Zhou, Caiming Xiong, and Computer Science. 2022. https://doi.org/10.18653/V1/2022.ACL-LONG.417 RNG-KBQA: Generation Augmented Iterative Ranking for Knowledge Base Question Answering . In Proceedings of the 60th Annual Meeting of the...

    2022 doi

  25. [33]

    Wen-tau Yih, Matthew Richardson, Chris Meek, Ming-Wei Chang, and Jina Suh. 2016. https://doi.org/10.18653/v1/P16-2033 The value of semantic parse labeling for knowledge base question answering . In Proceedings of the 54th Annual Meeting of the Association for Computational Lin...

    2016 doi

  26. [34]

    Yuyu Zhang, Hanjun Dai, Zornitsa Kozareva, Alexander Smola, and Le Song. 2018. https://ojs.aaai.org/index.php/AAAI/article/view/12057 Variational reasoning for question answering with knowledge graph . In Proceedings of the AAAI conference on artificial intelligence

    2018

  27. [35]

    Victor Zhong, Caiming Xiong, and Richard Socher. 2017. https://arxiv.org/abs/1709.00103 Seq2sql: Generating structured queries from natural language using reinforcement learning . CoRR, abs/1709.00103

    2017 arXiv

  28. [36]

    online" 'onlinestring :=

    ENTRY address archivePrefix author booktitle chapter edition editor eid eprint eprinttype howpublished institution journal key month note number organization pages publisher school series title type volume year doi pubmed url lastchecked label extra.label sort.label short.list...

  29. [37]

    write newline

    " write newline "" before.all 'output.state := FUNCTION n.dashify 't := "" t empty not t #1 #1 substring "-" = t #1 #2 substring "--" = not "--" * t #2 global.max substring 't := t #1 #1 substring "-" = "-" * t #2 global.max substring 't := while if t #1 #1 substring * t #2 gl...

Pith tools

Reviewed August 11, 2026 · model on record in the stance chip above.