Pith. sign in

REVIEW 4 major objections 6 minor 30 references

Learning to Solve Domain-Specific Calculation Problems with Knowledge-Intensive Programs Generator

T0 review · 4 major / 6 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 Domain-specific calculation problems are best solved by generating knowledge-intensive programs that encode each document's full rule logic, and a code generator trained by execution-based preference optimization can write those programs…

desk verdict Solid method paper with a real empirical claim; the main risk is that DPO program selection may overfit to training-query branches, and the missing artifacts need to be addressed. read the letter →

arxiv 2412.09280 v1 pith:CLHJKJA6 submitted 2024-12-12 cs.CL

Chengyuan Liu , Shihang Wang , Lizhi Qing , Jun Lin , Ji Zhang , Fei Wu , Kun Kuang This is my paper · ORCID
classification cs.CL
keywords knowledge-intensiveprogramsdomain-specificcalculationcodegenerationdirectpreferenceoptimizationlegalQAnumericalreasoningprogram-of-thoughtcross-domaingeneralization
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

Domain-specific calculation problems — for example, computing litigation fees or lost wages from a law article — are hard for LLMs because the governing knowledge is a set of conditional rules rather than a simple formula. This paper claims that the right unit of computation is a knowledge-intensive program: executable code written once per document that encodes all of the document's conditions and returns every outcome the document allows. On top of that, the paper trains a code generator with iterative direct preference optimization, ranking candidate programs by how often they compute the correct answers on training queries for the same article. With a 7B conclusion model, the resulting pipeline reaches 69.86% average accuracy on legal oracle-document cases, about 8.8% relatively above the best prompting baseline, and the same generator transfers to unseen case types and to the medical domain.

What carries the argument

The load-bearing object is the knowledge-intensive program: a Python function generated for each article or document, with a header comment naming the knowledge source, typed input/output parameter descriptions, and inline citations of the original rule before each branch. Unlike query-oriented programs that solve one question or terminology-oriented programs that return one concept's value, it returns all outcomes permitted by the document, so the same program serves every query about that article and query phrasing cannot bias the calculation. The training machinery is iterative DPO: candidate programs are sampled with diverse beam search, executed on training queries for their article, scored by matching the gold numeric answers, and ranked; the resulting preference pairs update the generator, and the loop repeats.

What would settle it

To test the proxy, hold out every query that exercises one clause of an article, train KIPG only on queries that avoid that clause, then measure accuracy on held-out clause queries; if accuracy on those queries is no better than a generator trained without the correctness scores, the assumption fails.

Watch

Extended reading notes

Core claim

The central claim is that replacing query-specific or terminology-level code with article-level knowledge-intensive programs, and teaching a generator to write those programs by execution-based preference alignment, makes LLMs reliably follow complex domain rules in numeric QA. A knowledge-intensive program is generated once for each domain document; it contains hierarchical if/else conditions, comments citing the source sentences, and returns a dictionary of all potential outcomes rather than one answer. At inference, KIPG extracts variables from the query, executes the program, and prompts a conclusion model to derive the final answer. The paper reports that this decomposition yields the highest accuracy in both oracle-context and retrieval settings, that correctness of programs on training queries tracks correctness on a larger held-out set closely enough to serve as a training signal, and that a generator trained only on three legal case types still improves accuracy on unseen legal case types and on medical documents.

Load-bearing premise

The ranking signal in DPO training is a program's correctness on the training queries for its article, and that score must be a reliable proxy for correctness on unseen queries of the same article; a program that fits training cases while misencoding a rarely tested rule would survive training and fail at test time.

Editorial extensions

If this is right

  • Given the gold document, KIPG reaches 69.86% average accuracy with a 7B conclusion model, which is 8.77% relatively above the best prompting baseline and at least matches a much larger 200B API model on several case types.
  • Outputting all possible outcomes instead of a query-specific scalar removes query-induced calculation bias, so one program per article can be reused across an arbitrary number of questions.
  • The code generator's skill transfers to legal case types never seen in training, and to medical-domain documents, without retraining on the new knowledge.
  • Supplying the calculated variables from the smaller generator to a 72B conclusion model raises accuracy from 69.86% to 74.84%, so the benefit of knowledge-intensive programs is not limited to small models.
  • Iterating DPO generally raises accuracy over rounds, and the correctness of programs on a small training set closely tracks correctness on a larger test set, so automatic filtering can keep inference cheap.

Reading between the lines

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

  • Beyond this paper, the same loop — generate executable artifacts, score them by execution on checkable queries, rank with DPO — could apply wherever outputs are verifiable, such as spreadsheet formulas, data-cleaning pipelines, or rule-based policy engines.
  • Because the paper reports a more than 10% average accuracy drop when the gold document is not given, the program generator's full value is currently gated by retrieval quality; coupling KIPG with a retriever trained on rule-condition logic rather than surface embeddings is a testable next step.
  • The authors' observation that adding documents without calculation examples still improves correctness suggests the generator first learns a general 'rules as code' syntax; an experiment measuring program accuracy on those syntax-only articles would separate that effect from answer-matching.
  • The English Llama3 results show baseline rankings shift across languages, with Program of Thought far stronger there, so the transfer benefits of knowledge-intensive programs may depend on the base model's language distribution rather than on the method alone.
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 / 6 minor

Summary. The manuscript introduces KIPG, a pipeline for domain-specific calculation QA in which a generator LLM writes \u201cknowledge-intensive programs\u201d from domain documents, an extraction model maps each query to program inputs, an executor computes the outputs, and a conclusion LLM turns the extracted variables and program outputs into a final answer. The generator is trained with iterative Direct Preference Optimization (DPO), where the preference signal is an execution-based correctness score s_i computed by running each candidate program on a small set of queries. The authors construct a Chinese legal dataset spanning five case types plus a medical cross-domain test set, and they report experiments with oracle and retrieved documents, cross-domain generalization, an English/Llama-3 setting, and ablations. The central claim is that KIPG outperforms the baselines, with an average accuracy of 69.86% on the legal oracle-context benchmark using a 7B conclusion model, quoted as 8.77% relatively above the best baseline EEDP.

Significance. If the claims hold, KIPG is a useful contribution: it proposes a program-generation paradigm that captures the conditional, branch-structured logic of domain documents rather than query-specific or terminology-only programs, and it uses execution against gold answers as an external correctness signal for DPO. The paper is also strong in the breadth of its evaluation: oracle and no-oracle settings, unseen case types, cross-domain transfer to medical data, cross-language transfer, multiple base LLMs, and ablations. The Limitations section honestly acknowledges that retrieval is not optimized and that accuracy drops by more than 10% without the label document. However, the headline results rest on two load-bearing assumptions that are not yet demonstrated: that the s_i score used to select programs generalizes across the branches of piecewise rules, and that the evaluation is conducted on a clearly disjoint held-out set. These issues must be resolved before the empirical claims can be considered robust.

major comments (4)
  1. [Sec. 4.3, Appendix C, Table 7] The correctness score s_i that ranks programs for DPO and for final program selection is computed on a small \u201ctraining set\u201d of 330 queries (Appendix C). Figure 7 only compares aggregate program accuracy on that set with the 2050-query set; it does not test branch-level generalization. Because many legal articles are piecewise (income brackets, fixed vs. non-fixed income, maximum vs. minimum cases), a program that hard-codes the branches represented in the 330 queries can receive a high s_i and still fail on unseen branches. This concern is load-bearing because Table 7 shows that removing DPO training lowers the average accuracy by 6.73 points and by 11.94 points on Other Fees, so most of the headline gain is produced by the s_i-based selection. Please add a per-article analysis of whether the selected program generalizes to queries that exercise branches absent from the selection set, or select programs on a held-out set and report accuracy on those held-out branches.
  2. [Appendix C, Table 1, Sec. 5.1] The paper never specifies whether the 330-query program-filtering set overlaps with the 2050-query evaluation set. The total number of legal instances in Table 1 is exactly 2050, so the \u201ctesting set\u201d in Figure 7 appears to be the entire dataset. If the 330 queries used to compute s_i are part of the evaluation set, the reported accuracies are not fully held out. Similarly, for the unseen types Penalties and Traffic Violations, Section 5.1 says their calculation instances are never seen during training, but computing s_i on queries for those types would make those queries seen during program selection. Please state the exact query-level split, ensure disjointness between the selection set and the evaluation set, and re-report any affected numbers.
  3. [Tables 2\u20137] All results are single runs without standard deviations, confidence intervals, or significance tests. Several comparisons are close: for example, in Table 2 the Qwen2-72B Compensation result for PoT is 57.27 versus 56.82 for KIPG, and in Table 4 the Indicator column shows EEDP at 48.53 versus KIPG at 52.94. Without repeated runs or a paired test, these margins may not be reliable. Please provide at least three seeds per condition, or bootstrap confidence intervals, and a paired significance test where the comparison is between methods on the same queries.
  4. [Data availability] The dataset and code are not released, and the appendix provides no link, no detailed annotation protocol beyond a summary, and no public access to the generated programs. Since the central evidence is empirical and the dataset is newly constructed, the inability to reproduce or inspect the data blocks independent verification of the branch-coverage and split concerns above. Please release the dataset, the code, and the sampled programs, or provide a clear statement of why they cannot be released.
minor comments (6)
  1. [Sec. 5.4, Table 5] The text says CodeQwen\u2019s average accuracy is 60.43%, but Table 5 reports 60.45%; please harmonize the number.
  2. [Sec. 5.1, Table 2] The sentence \u201cthe knowledge-intensive programs significantly improve the overall performance under all types of cases\u201d should be qualified for the 72B setting, where Table 2 shows PoT is higher on Compensation (57.27 vs. 56.82).
  3. [Eq. (3)] The conditioning variable d is used in the DPO loss but is not defined in the main text; from context it is the domain document or article, but please define it explicitly.
  4. [Figure 2] The two dialogue panels are difficult to parse in the current rendering; the caption should state what each panel contains and how the two responses differ in their calculation logic.
  5. [Sec. 5.6, Table 7] The ablation in Table 7 is reported for the second iteration, but Table 2 does not state which iteration the main results use; please clarify whether the main tables correspond to the final iteration or a specific iteration.
  6. [Appendix C] The sentence \u201cIt can be seen that there is a high consistency between the two accuracy\u201d is purely visual; please quantify the agreement or correlation between the small-set and large-set program accuracies.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: KIPG's reported gains rest on held-out queries and an external execution-based correctness signal; DPO selection is supervised model selection, not prediction of its own training signal.

full rationale

This paper is self-contained and does not derive its predictions from its training inputs by construction. The central reported accuracies (Tables 2, 3, 4, and 6) are computed on held-out queries: the legal training split covers only Compensation, Tax, and Other Fees, while Penalties and Traffic Violations are evaluation-only types, and the medical domain is a cross-domain test set. In Section 4.3, the program correctness score si is computed by executing sampled programs on training queries and comparing the executed outputs with gold answers; this is an external, execution-based signal used to rank DPO preferences. The final evaluation then runs the selected program on new queries and measures whether the program's computed (I,O) lets the conclusion model produce the gold numeric answer. The relationship between si and test accuracy is empirical, and the paper provides a consistency check in Appendix C (Figure 7); it is not definitional. There is no load-bearing self-citation: the method invokes standard baselines and DPO as external algorithms, and the 'wisdominterrogatory' citation in the introduction is not used to justify any formal result. No equation reduces a claimed prediction to its own input, no fitted parameter is relabeled as a prediction, and no uniqueness theorem is imported from the authors' prior work. The closest concern, selection overfitting of programs to training queries, is a generalization risk rather than a circularity, and the paper's held-out evaluations and ablation study address it empirically.

Assumptions & free parameters 3 free parameters · 4 assumptions · 0 invented entities

The central empirical claim rests on the quality of the constructed datasets and on the assumption that execution-based scoring on training queries is a valid proxy for program correctness. No parameters are fitted to the test set; training hyperparameters (DPO beta 0.1, LoRA rank 8, 8 sampled programs) are standard choices reported in Appendix B.

free parameters (3)
  • DPO beta = 0.1
    Chosen by hand (Appendix B). Controls the strength of the preference optimization; not fitted to the test set.
  • LoRA rank = 8
    Chosen by hand for all training (Appendix B).
  • Number of sampled programs per document (diverse beam size) = 8
    Chosen by hand (Section 4.3 and Appendix B). Larger beam sizes improve results, so the specific value is a design choice.
assumptions (4)
  • domain assumption Python execution is deterministic and correctly implements the generated program
    The pipeline relies on executing generated Python code with a system executor (Section 4.2, Eq. 1). If execution is non-deterministic or the executor misinterprets code, the computed outcomes O would be wrong.
  • domain assumption The gold article is sufficient to answer each query
    Dataset construction (Appendix E) instructs annotators to write queries answerable from the selected document; if a query requires knowledge outside the document, the oracle-context evaluation would be misleading.
  • ad hoc to paper The program correctness score computed on training queries is a valid proxy for performance on unseen queries
    Section 4.3 ranks programs by the proportion of training queries they solve correctly (si). This assumes a program that handles the training set correctly will also handle new queries, which is tested only via the aggregate consistency plot in Appendix C (Figure 7).
  • domain assumption Manual review of GPT-4 extended instances ensures dataset correctness
    Section 3 'Extension by LLM' uses GPT-4 to generate additional instances with manual review; any systematic errors in this review could bias the comparison.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Learning to Solve Domain-Specific Calculation Problems with Knowledge-Intensive Programs Generator." pith.science (2026). https://pith.science/paper/CLHJKJA6

@misc{pith2026241209280,
  author       = {Pith},
  title        = {Pith review of: Learning to Solve Domain-Specific Calculation Problems with Knowledge-Intensive Programs Generator},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/CLHJKJA6}},
  note         = {Machine review of arXiv:2412.09280}
}
read the original abstract

Domain Large Language Models (LLMs) are developed for domain-specific tasks based on general LLMs. But it still requires professional knowledge to facilitate the expertise for some domain-specific tasks. In this paper, we investigate into knowledge-intensive calculation problems. We find that the math problems to be challenging for LLMs, when involving complex domain-specific rules and knowledge documents, rather than simple formulations of terminologies. Therefore, we propose a pipeline to solve the domain-specific calculation problems with Knowledge-Intensive Programs Generator more effectively, named as KIPG. It generates knowledge-intensive programs according to the domain-specific documents. For each query, key variables are extracted, then outcomes which are dependent on domain knowledge are calculated with the programs. By iterative preference alignment, the code generator learns to improve the logic consistency with the domain knowledge. Taking legal domain as an example, we have conducted experiments to prove the effectiveness of our pipeline, and extensive analysis on the modules. We also find that the code generator is also adaptable to other domains, without training on the new knowledge.

Figures

Figures reproduced from arXiv: 2412.09280 by the authors.

Figure 1
Figure 1. Comparison between program generation paradigms from different sources. (a) Query-oriented programs are generated to solve a specific query. (b) Terminology-oriented programs describe domain￾specific concepts with several formulations, source from definitions of terminologies. (c) Knowledge￾intensive programs follow more complex instructions with domain-specific conditions and rules. Although the LLMs are enhanced b… view at source ↗
Figure 2
Figure 2. For the same article, the response may follow [PITH_FULL_IMAGE:figures/full_fig_p002_2.png] view at source ↗
Figure 3
Figure 3. Framework of KIPG. The generator LLM writes programs for each domain-specific document. Given [PITH_FULL_IMAGE:figures/full_fig_p003_3.png] view at source ↗
Figures from the paper (4 more)
Figure 4
Figure 4. Figure 4: Ranking guideline of DPO data generation. [PITH_FULL_IMAGE:figures/full_fig_p004_4.png]
Figure 5
Figure 5. Figure 5: Accuracy over different training iterations [PITH_FULL_IMAGE:figures/full_fig_p007_5.png]
Figure 6
Figure 6. Figure 6: Number of lines in the programs versus the [PITH_FULL_IMAGE:figures/full_fig_p008_6.png]
Figure 7
Figure 7. Figure 7: Accuracy of programs within the training set [PITH_FULL_IMAGE:figures/full_fig_p012_7.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

30 extracted references · 1 canonical work pages

  1. [1]

    AI@Meta. 2024. https://github.com/meta-llama/llama3/blob/main/MODEL_CARD.md Llama 3 model card

    2024

  2. [2]

    Dai, Orhan Firat, Melvin Johnson, Dmitry Lepikhin, Alexandre Passos, Siamak Shakeri, Emanuel Taropa, Paige Bailey, Zhifeng Chen, Eric Chu, Jonathan H

    Rohan Anil, Andrew M. Dai, Orhan Firat, Melvin Johnson, Dmitry Lepikhin, Alexandre Passos, Siamak Shakeri, Emanuel Taropa, Paige Bailey, Zhifeng Chen, Eric Chu, Jonathan H. Clark, Laurent El Shafey, Yanping Huang, Kathy Meier-Hellstern, Gaurav Mishra, Erica Moreira, Mark Omernick, Kevin Robinson, Sebastian Ruder, Yi Tay, Kefan Xiao, Yuanzhong Xu, Yujing Z...

    arXiv 2023

  3. [3]

    Tom B. Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared 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 M. Ziegler, Jeffrey Wu, Clemens Winter, Christopher Hesse, Mark Chen, Eric Sigler, Mateusz Litwin...

    arXiv 2020

  4. [4]

    Wenhu Chen, Xueguang Ma, Xinyi Wang, and William W. Cohen. 2023. https://arxiv.org/abs/2211.12588 Program of thoughts prompting: Disentangling computation from reasoning for numerical reasoning tasks . Preprint, arXiv:2211.12588

    arXiv 2023

  5. [5]

    Karl Cobbe, Vineet Kosaraju, Mohammad Bavarian, Mark Chen, Heewoo Jun, Lukasz Kaiser, Matthias Plappert, Jerry Tworek, Jacob Hilton, Reiichiro Nakano, Christopher Hesse, and John Schulman. 2021. https://arxiv.org/abs/2110.14168 Training verifiers to solve math word problems . Preprint, arXiv:2110.14168

    arXiv 2021

  6. [6]

    Yihe Deng, Weitong Zhang, Zixiang Chen, and Quanquan Gu. 2024. https://arxiv.org/abs/2311.04205 Rephrase and respond: Let large language models ask better questions for themselves . Preprint, arXiv:2311.04205

    arXiv 2024

  7. [7]

    Qingxiu Dong, Lei Li, Damai Dai, Ce Zheng, Jingyuan Ma, Rui Li, Heming Xia, Jingjing Xu, Zhiyong Wu, Baobao Chang, Xu Sun, Lei Li, and Zhifang Sui. 2024. https://arxiv.org/abs/2301.00234 A survey on in-context learning . Preprint, arXiv:2301.00234

    arXiv 2024

  8. [8]

    Duanyu Feng, Bowen Qin, Chen Huang, Zheng Zhang, and Wenqiang Lei. 2024. https://arxiv.org/abs/2404.04626 Towards analyzing and understanding the limitations of dpo: A theoretical perspective . Preprint, arXiv:2404.04626

    arXiv 2024

Show all 30 references
  1. [9]

    Hu, Yelong Shen, Phillip Wallis, Zeyuan Allen-Zhu, Yuanzhi Li, Shean Wang, Lu Wang, and Weizhu Chen

    Edward J. Hu, Yelong Shen, Phillip Wallis, Zeyuan Allen-Zhu, Yuanzhi Li, Shean Wang, Lu Wang, and Weizhu Chen. 2021. https://arxiv.org/abs/2106.09685 Lora: Low-rank adaptation of large language models . Preprint, arXiv:2106.09685

    2021 arXiv

  2. [10]

    Shima Imani, Liang Du, and Harsh Shrivastava. 2023. https://doi.org/10.18653/v1/2023.acl-industry.4 M ath P rompter: Mathematical reasoning using large language models . In Proceedings of the 61st Annual Meeting of the Association for Computational Linguistics (Volume 5: Indus...

    2023 doi

  3. [11]

    Zixuan Ke, Yijia Shao, Haowei Lin, Tatsuya Konishi, Gyuhak Kim, and Bing Liu. 2023. https://arxiv.org/abs/2302.03241 Continual pre-training of language models . Preprint, arXiv:2302.03241

    2023 arXiv

  4. [12]

    Geunwoo Kim, Pierre Baldi, and Stephen McAleer. 2023. https://arxiv.org/abs/2303.17491 Language models can solve computer tasks . Preprint, arXiv:2303.17491

    2023 arXiv

  5. [13]

    Yubo Ma, Zhibin Gou, Junheng Hao, Ruochen Xu, Shuohang Wang, Liangming Pan, Yujiu Yang, Yixin Cao, Aixin Sun, Hany Awadalla, and Weizhu Chen. 2024. https://arxiv.org/abs/2402.11451 Sciagent: Tool-augmented language models for scientific reasoning . Preprint, arXiv:2402.11451

    2024 arXiv

  6. [14]

    Nay, David Karamardian, Sarah B

    John J. Nay, David Karamardian, Sarah B. Lawsky, Wenting Tao, Meghana Bhat, Raghav Jain, Aaron Travis Lee, Jonathan H. Choi, and Jungo Kasai. 2023. https://arxiv.org/abs/2306.07075 Large language models as tax attorneys: A case study in legal capabilities emergence . Preprint,...

    2023 arXiv

  7. [15]

    Arka Pal, Deep Karkhanis, Samuel Dooley, Manley Roberts, Siddartha Naidu, and Colin White. 2024. https://arxiv.org/abs/2402.13228 Smaug: Fixing failure modes of preference optimisation with dpo-positive . Preprint, arXiv:2402.13228

    2024 arXiv

  8. [16]

    Manning, and Chelsea Finn

    Rafael Rafailov, Archit Sharma, Eric Mitchell, Stefano Ermon, Christopher D. Manning, and Chelsea Finn. 2024. https://arxiv.org/abs/2305.18290 Direct preference optimization: Your language model is secretly a reward model . Preprint, arXiv:2305.18290

    2024 arXiv

  9. [17]

    Pragya Srivastava, Manuj Malik, Vivek Gupta, Tanuja Ganu, and Dan Roth. 2024. https://arxiv.org/abs/2402.11194 Evaluating llms' mathematical reasoning in financial document question answering . Preprint, arXiv:2402.11194

    2024

  10. [18]

    Hugo Touvron, Louis Martin, Kevin Stone, Peter Albert, Amjad Almahairi, Yasmine Babaei, Nikolay Bashlykov, Soumya Batra, Prajjwal Bhargava, Shruti Bhosale, Dan Bikel, Lukas Blecher, Cristian Canton Ferrer, Moya Chen, Guillem Cucurull, David Esiobu, Jude Fernandes, Jeremy Fu, W...

    2023 arXiv

  11. [19]

    Selvaraju, Qing Sun, Stefan Lee, David Crandall, and Dhruv Batra

    Ashwin K Vijayakumar, Michael Cogswell, Ramprasath R. Selvaraju, Qing Sun, Stefan Lee, David Crandall, and Dhruv Batra. 2018. https://arxiv.org/abs/1610.02424 Diverse beam search: Decoding diverse solutions from neural sequence models . Preprint, arXiv:1610.02424

    2018 arXiv

  12. [20]

    Jason Wei, Xuezhi Wang, Dale Schuurmans, Maarten Bosma, Brian Ichter, Fei Xia, Ed Chi, Quoc Le, and Denny Zhou. 2023. https://arxiv.org/abs/2201.11903 Chain-of-thought prompting elicits reasoning in large language models . Preprint, arXiv:2201.11903

    2023 arXiv

  13. [21]

    Aiyuan Yang, Bin Xiao, Bingning Wang, Borong Zhang, Ce Bian, Chao Yin, Chenxu Lv, Da Pan, Dian Wang, Dong Yan, Fan Yang, Fei Deng, Feng Wang, Feng Liu, Guangwei Ai, Guosheng Dong, Haizhou Zhao, Hang Xu, Haoze Sun, Hongda Zhang, Hui Liu, Jiaming Ji, Jian Xie, JunTao Dai, Kun Fa...

    2023 arXiv

  14. [22]

    An Yang, Baosong Yang, Binyuan Hui, Bo Zheng, Bowen Yu, Chang Zhou, Chengpeng Li, Chengyuan Li, Dayiheng Liu, Fei Huang, Guanting Dong, Haoran Wei, Huan Lin, Jialong Tang, Jialin Wang, Jian Yang, Jianhong Tu, Jianwei Zhang, Jianxin Ma, Jianxin Yang, Jin Xu, Jingren Zhou, Jinze...

    2024 arXiv

  15. [23]

    Hongyang Yang, Xiao-Yang Liu, and Christina Dan Wang. 2023 b . https://arxiv.org/abs/2306.06031 Fingpt: Open-source financial large language models . Preprint, arXiv:2306.06031

    2023

  16. [24]

    https://github.com/zhihaiLLM/wisdomInterrogatory wisdominterrogatory

    Wu Yiquan, Liu Yuhang, Liu Yifei, Li Ang, Zhou Siying, and Kuang Kun. https://github.com/zhihaiLLM/wisdomInterrogatory wisdominterrogatory . Available at GitHub

  17. [25]

    Hongbo Zhang, Junying Chen, Feng Jiang, Fei Yu, Zhihong Chen, Jianquan Li, Guiming Chen, Xiangbo Wu, Zhiyi Zhang, Qingying Xiao, Xiang Wan, Benyou Wang, and Haizhou Li. 2023. https://arxiv.org/abs/2305.15075 Huatuogpt, towards taming language model to be a doctor . Preprint, a...

    2023 arXiv

  18. [26]

    Yilun Zhao, Hongjun Liu, Yitao Long, Rui Zhang, Chen Zhao, and Arman Cohan. 2024. https://arxiv.org/abs/2311.09797 Financemath: Knowledge-intensive math reasoning in finance domains . Preprint, arXiv:2311.09797

    2024 arXiv

  19. [27]

    Zhi Zhou, Jiang-Xin Shi, Peng-Xiao Song, Xiao-Wen Yang, Yi-Xuan Jin, Lan-Zhe Guo, and Yu-Feng Li. 2024. https://arxiv.org/abs/2406.04614 Lawgpt: A chinese legal knowledge-enhanced large language model . Preprint, arXiv:2406.04614

    2024 arXiv

  20. [28]

    Çağatay Yıldız, Nishaanth Kanna Ravichandran, Prishruit Punia, Matthias Bethge, and Beyza Ermis. 2024. https://arxiv.org/abs/2402.17400 Investigating continual pretraining in large language models: Insights and implications . Preprint, arXiv:2402.17400

    2024 arXiv

  21. [29]

    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...

  22. [30]

    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.