Pith. sign in

REVIEW 4 major objections 5 minor 20 references

Natural Language Fine-Tuning

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

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

Pith's one-line read Natural-language prompts can serve as token-level supervision, letting 50 examples outperform full-scale SFT and skip the reinforcement warm-up.

desk verdict The central loss in Eq. (5) has both signs inverted, so the described algorithm would suppress correct tokens and reinforce incorrect ones; the headline gains are also reported as 219%, 27%, and 1.19x, which are mutually inconsistent. read the letter →

arxiv 2412.20382 v1 pith:4AY2SK4V submitted 2024-12-29 cs.CL cs.AI

Jia Liu , Yue Wang , Zhiqi Lin , Min Chen , Yixue Hao , Long Hu This is my paper · ORCID
classification cs.CLcs.AI
keywords naturallanguagefine-tuningtoken-levelsupervisionsaliencytokensconditionalprobabilitysmall-sampleGSM8Kchain-of-thoughtreasoningreinforcement
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

Natural Language Fine-Tuning (NLFT) asks whether a large language model can be specialized from very few labeled examples when the supervision itself is written in natural language rather than reduced to scalar rewards. The method takes a reasoning output, compares the conditional probabilities of each token under different prompts (question alone; question plus standard answer; for wrong outputs, question plus a judgment), and treats the tokens whose probabilities shift as the saliency tokens. The training loss is then reweighted by how salient each token is, so the model concentrates on the deciding steps of the reasoning. On GSM8K, the paper reports roughly 64% accuracy from only 50 training instances and accuracy above 70% on larger subsets, with training cost close to SFT and far below reinforcement fine-tuning. The larger claim is that this token-level natural-language supervision can replace the SFT warm-up stage that reinforcement fine-tuning requires, opening lightweight fine-tuning to resource-limited settings.

What carries the argument

The mechanism that carries the argument is the token-level scale $S(y_t)$, a weight assigned to each token from the probability comparisons and used to reweight the next-token loss. For correct outputs, $S(y_t)$ is a piecewise function of $P(y_t\mid X_{\mathrm{standard}}, y_{<t})$ with three tiers: saliency tokens get a scale above 1, sub-saliency tokens get a scale between the saliency and irrelevant scales, and irrelevant tokens get the smallest weight. For incorrect outputs, $S(y_t)=2/(1+e^{-(r_1-r_0)})$, a logistic function of the ratio $r_1=P(y_t\mid X_{\mathrm{judge}}, y_{<t})/P(y_t\mid X_{\mathrm{base}}, y_{<t})$, and tokens whose companion ratio $r_2$ is not also above $r_0$ are treated as irrelevant and zeroed out. This comparison across prompts is what converts natural-language judgments into dense token-level supervision without a learned reward model, and it is what keeps the procedure in the same linear-complexity class as SFT.

What would settle it

Run NLFT on the same 50 GSM8K instances with the saliency scales replaced by uniform weights (i.e., standard SFT on those instances) while keeping every other hyperparameter identical; if the large accuracy gap disappears, the saliency weighting is the carrier, and if it does not, the reported gains originate elsewhere in the training setup.

Watch

Extended reading notes

Core claim

The paper's central claim is that conditional-probability shifts at the token level expose which tokens carry a solution's reasoning, and that reweighting the loss accordingly is what lets a model learn from very little data. For a correct chain-of-thought output, a token is salient if its probability under the prompt containing the standard answer exceeds a threshold ($p_0^{correct}=0.95$); for an incorrect output, saliency is decided by two ratios comparing the judgment-prompt probability to the base and standard probabilities, with both ratios above $r_0=1.5$. The training objective is a token-level loss in which the next-token log-probability is weighted by the scale: for correct tokens the term is $S(y_t)\log P(y_t\mid X_{\mathrm{base}}, y_{<t})$, and for incorrect tokens it is $S(y_t)\,(1-\log P(y_t\mid X_{\mathrm{base}}, y_{<t}))$, with irrelevant incorrect tokens zeroed out. With this mechanism, the paper reports NLFT outperforming SFT on GSM8K with far fewer examples and outperforming reinforcement fine-tuning in accuracy, time, and memory while staying at linear complexity and requiring no warm-up phase.

Load-bearing premise

The method depends on the assumption that a token whose conditional probability shifts sharply when the standard answer or a judgment is added is the token that carries the solution's meaning, so that reweighting the loss toward those tokens is what produces the reported accuracy gains.

Editorial extensions

If this is right

  • NLFT removes the SFT warm-up that reinforcement fine-tuning requires, allowing a base model to be specialized directly on a small labeled dataset.
  • With tens to a few thousand labeled examples, a reasoning model can reach accuracy comparable to or better than SFT trained on far more data, which matters for domains where labels are scarce.
  • Training cost stays in SFT's class: linear time and memory, with roughly three times SFT's forward passes but GPU memory far below reinforcement fine-tuning.
  • Because the weights are attached to individual tokens, the training signal is interpretable: the user can see which tokens the model treats as scoring points and which as losing points, as the paper's comparison with CUT illustrates.
  • The method is expected to transfer to any task where outputs can be produced by chain-of-thought and labels are available, including coding, diagnosis, and complex question answering.

Reading between the lines

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

  • Editorial inference: the same probability-shift comparison could be reused as a data-curation signal, e.g., preferring examples whose saliency tokens are not yet stable under prompt perturbation.
  • Editorial inference: the paper's own discussion shows incorrect samples are harder to learn from; a natural stress test is to train NLFT on incorrect outputs only and check whether the loss still yields accuracy gains, which would separate the contribution of the correct-output path from the incorrect-output path.
  • Editorial inference: treating chosen and rejected completions in preference data as the two prompt conditions in a probability comparison could yield a token-level saliency weighting for alignment, extending the mechanism beyond math word problems.
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. The manuscript proposes Natural Language Fine-Tuning (NLFT), a token-level fine-tuning method that uses natural language prompt conditions (question, standard answer, and/or judgment) to identify 'saliency tokens' via conditional probability differences, assigns scale values to those tokens, and then fine-tunes the model with a weighted token-level loss. The authors claim that, on GSM8K, NLFT outperforms both SFT and ReFT in accuracy, time, and memory, needs no SFT warm-up, and achieves its gains with as few as 50 training examples. The paper reports headline improvements in multiple forms (219%, 27%, 1.19 times, 25%) and states that NLFT maintains O(n) time and space complexity. A code repository link is provided.

Significance. The direction of using natural-language feedback for token-level supervision in low-resource fine-tuning is potentially interesting, and the manuscript makes a good-faith effort to provide a concrete algorithm, experimental setup, prompts, and a public code link. The token-level visualizations in Fig. 10 and the direct comparison with SFT and ReFT are also useful starting points. However, the central loss function in Eq. (5) has reversed signs for both correct and incorrect tokens, so the algorithm as written suppresses correct tokens and amplifies incorrect ones; the reported accuracy gains therefore cannot be produced by the described mechanism. The headline accuracy numbers are also mutually inconsistent across the abstract, introduction, and body. These are load-bearing defects, not presentation issues, and they currently prevent the paper from being published in any form that preserves its central claims.

major comments (4)
  1. [Section 3.4, Eq. (5)] The loss in Eq. (5) is sign-inverted relative to the intended optimization. For correct tokens, the term is S(yt) * log P(yt | Xbase, yt-), and since log P <= 0, minimizing this term drives the probability of the correct token toward zero rather than increasing it. For incorrect tokens, the term is S(yt) * (1 - log P(yt | Xbase, yt-)) with S(yt) in (0,1); since 1 - log P decreases as log P increases, minimizing this term drives log P toward 0, i.e., it increases the probability of the erroneous tokens. The method as written therefore does the opposite of the contrastive learning described in Section 3.4. If the released code implements the same loss, the reported GSM8K accuracies cannot be produced by the described algorithm; if it implements a corrected loss, then the manuscript does not report the algorithm that was evaluated. This issue must be resolved before any assessment of the method's effectiveness is possible.
  2. [Abstract, Section 1, Fig. 1] The headline improvement is reported as 219% over SFT in the abstract, 27% in the Fig. 1 caption, 1.19 times in the introduction, and 25% in Sections 4.4 and 5.1. These numbers are mutually inconsistent: for example, if SFT accuracy is about 34.4% (Fig. 6), a 219% relative increase would be about 109.7% accuracy, while 1.19 times would be about 40.9%. The 50-sample experiments also report 62.93% (Fig. 5) and 64.29% (Section 1), while Fig. 9 reports 71.65% for 800 samples. The manuscript needs a single, unambiguous evaluation protocol and a clear statement of whether each claim is relative or absolute, and for which training set size.
  3. [Sections 3.1 and 3.3] The two hypotheses about conditional probability shifts are the entire basis for saliency-token allocation, but they are stated as assumptions and are never independently validated. Because the saliency weights are computed from the same model's conditional probabilities under different prompts and then used to re-weight that model's own loss, the optimization is self-referential. The paper does not provide an ablation that holds data, prompts, and the number of forward passes fixed while turning the saliency weighting on and off. Without such a control, the reported gains cannot be attributed to the proposed saliency mechanism rather than to the altered prompts, the extra forward passes, or the standard-answer information injected through the weights.
  4. [Sections 4.3 and 4.4] The comparison with ReFT is not sufficient to support the claim of 'comprehensively outperforming reinforcement fine-tuning algorithms.' Section 4.3 explicitly omits ReFT's CoT-P component because it 'shows better performance on the GSM8K dataset,' but that component is part of the original ReFT method. In addition, the reproduction in Section 4.4 shows ReFT collapsing to zero accuracy under 800 samples, a behavior not reported in the original ReFT paper, and the time comparison uses an 8-GPU configuration for ReFT and NLFT while other experiments use 2 GPUs (Fig. 7). The authors should either restrict their claims to the specific compared configurations or provide a systematic hyperparameter sweep for ReFT under small data before making broad superiority claims.
minor comments (5)
  1. [Algorithm 1] The loss expression in line 14 omits the summation over tokens; as written, L = 1/N P S(yt) * logP(...) is not a well-defined average over the sequence. Please state L = (1/N) * sum_t S(yt) * log P(yt | Xbase, y_t-) for the correct-output case, and similarly for the incorrect-output case in Eq. (5).
  2. [Section 4.2 vs. Section 4.4] The paper says experiments run on two A800 GPUs, which is 'four times lower' than ReFT's requirement, but Section 4.4 reports ReFT time under an eight-GPU configuration. Clarify the hardware configuration for every reported time and memory number, and state whether memory figures are peak or average.
  3. [Abstract vs. Section 4.4] The abstract reports 44.46 GB of GPU memory usage for NLFT, while Section 4.4 reports an average of 46.87 GB for the two-GPU setup. These numbers should be reconciled.
  4. [Section 4.4, Fig. 6] The text says 'reaching the accuracy of SFT by epoch 5' and then 'reaching 60.1% by epoch 4'; the epoch numbers and the ordering of the narrative are confusing and should be corrected.
  5. [Throughout] There are several typographical and grammatical errors, such as 'regraded' in Section 4.4, 'Finanlly' in Section 3.3, and inconsistent use of 'p_correct_0' vs. 'p_correct0' and 'p_incorrect_0' vs. 'p_incorrect0'. A careful proofreading pass is needed.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity found; the method is an empirically tested heuristic. The main issues are unvalidated assumptions, an apparent sign error in Eq. (5), and inconsistent accuracy claims, but none of these is a circular reduction.

full rationale

The paper proposes NLFT, a token-level weighted-MLE fine-tuning method, and evaluates it on the held-out GSM8K test set. There is no derivation chain that reduces a prediction to a fitted input: the saliency weights S(yt) in Eqs. (3)-(4) are computed from the model's own conditional probabilities, and the loss in Eq. (5) weights that model's log-probabilities, but this is an algorithm design rather than a claimed theoretical derivation. The reported accuracy is measured on test data, not on the training subset used to compute the weights, so the central empirical claim is not circular. Section 3.1 states two hypotheses that operationally define saliency tokens; these are unproven assumptions, and the paper explicitly labels them as assumptions ('we assume that...'), which is a missing-support issue rather than a circular step. The paper contains no self-citations, so no self-citation chain is load-bearing. The inconsistent improvement figures (219%, 27%, 1.19x, and 25% in different places) and the apparent sign error in Eq. (5), where minimizing S(yt) log P for correct tokens would decrease P and minimizing S(yt)(1 - log P) for incorrect tokens would increase P, are serious correctness and reproducibility concerns, but they are not instances of a conclusion being equivalent to its premises by construction. The paper is therefore not significantly circular, although its central mechanism is not established from first principles.

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

The method introduces no new physical entities. The 'saliency token' is a conceptual construct, not an invented entity in the sense of a new object or force. The free parameters listed are hand-chosen and affect the central results.

free parameters (6)
  • p_correct0 = 0.95
    Threshold for saliency in correct outputs; set in Section 4.2 without derivation.
  • p_incorrect0 = 0.01
    Threshold for saliency in incorrect outputs; set in Section 4.2.
  • r0 = 1.5
    Ratio threshold for incorrect outputs; set in Section 4.2.
  • c1 = 5
    Exponent for saliency token scale in correct outputs; set in Section 4.2.
  • c2 = 0.3
    Exponent for sub-saliency token scale; set in Section 4.2.
  • c3 = 0.6
    Exponent for irrelevant token scale in correct outputs; set in Section 4.2.
assumptions (3)
  • domain assumption Hypothesis 1: for correct outputs, saliency tokens have significantly higher conditional probability under X_standard than under X_base.
    Stated in Section 3.1 as an assumption, not proven.
  • domain assumption Hypothesis 2: for incorrect outputs, saliency tokens show substantial probability variations across X_base, X_judge, and X_standard.
    Stated in Section 3.1 as an assumption, not proven.
  • domain assumption Semantic clustering around saliency tokens identifies associated phrases that are meaningful for learning.
    Used in Section 3.3 but the clustering method is not specified.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Natural Language Fine-Tuning." pith.science (2026). https://pith.science/paper/4AY2SK4V

@misc{pith2026241220382,
  author       = {Pith},
  title        = {Pith review of: Natural Language Fine-Tuning},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/4AY2SK4V}},
  note         = {Machine review of arXiv:2412.20382}
}
read the original abstract

Large language model fine-tuning techniques typically depend on extensive labeled data, external guidance, and feedback, such as human alignment, scalar rewards, and demonstration. However, in practical application, the scarcity of specific knowledge poses unprecedented challenges to existing fine-tuning techniques. In this paper, focusing on fine-tuning tasks in specific domains with limited data, we introduce Natural Language Fine-Tuning (NLFT), which utilizes natural language for fine-tuning for the first time. By leveraging the strong language comprehension capability of the target LM, NLFT attaches the guidance of natural language to the token-level outputs. Then, saliency tokens are identified with calculated probabilities. Since linguistic information is effectively utilized in NLFT, our proposed method significantly reduces training costs. It markedly enhances training efficiency, comprehensively outperforming reinforcement fine-tuning algorithms in accuracy, time-saving, and resource conservation. Additionally, on the macro level, NLFT can be viewed as a token-level fine-grained optimization of SFT, thereby efficiently replacing the SFT process without the need for warm-up (as opposed to ReFT requiring multiple rounds of warm-up with SFT). Compared to SFT, NLFT does not increase the algorithmic complexity, maintaining O(n). Extensive experiments on the GSM8K dataset demonstrate that NLFT, with only 50 data instances, achieves an accuracy increase that exceeds SFT by 219%. Compared to ReFT, the time complexity and space complexity of NLFT are reduced by 78.27% and 92.24%, respectively. The superior technique of NLFT is paving the way for the deployment of various innovative LLM fine-tuning applications when resources are limited at network edges. Our code has been released at https://github.com/Julia-LiuJ/NLFT.

Figures

Figures reproduced from arXiv: 2412.20382 by the authors.

Figure 1
Figure 1. Accuracy Comparison of SFT and NLFT on GSM8K [PITH_FULL_IMAGE:figures/full_fig_p001_1.png] view at source ↗
Figure 2
Figure 2. Training process of SFT, ReFT, and NLFT. (a) The training process of SFT, which can be analogous to a student directly learning [PITH_FULL_IMAGE:figures/full_fig_p002_2.png] view at source ↗
Figure 3
Figure 3. An example of the training process of NLFT, which takes [PITH_FULL_IMAGE:figures/full_fig_p004_3.png] view at source ↗
Figures from the paper (6 more)
Figure 4
Figure 4. Figure 4: Comparison of accuracy of SFT and NLFT using 25%, [PITH_FULL_IMAGE:figures/full_fig_p006_4.png]
Figure 5
Figure 5. Figure 5: Comparison of accuracy of NLFT using minimal dataset [PITH_FULL_IMAGE:figures/full_fig_p006_5.png]
Figure 6
Figure 6. Figure 6: Accuracy comparison between SFT and NLFT trained in [PITH_FULL_IMAGE:figures/full_fig_p007_6.png]
Figure 7
Figure 7. Figure 7: Comparison of GPU memory utilization between SFT, [PITH_FULL_IMAGE:figures/full_fig_p007_7.png]
Figure 9
Figure 9. Figure 9: Comparison of accuracy of NLFT, SFT, ReFT with data size of 800. Both experiments of ReFT are pre-warmed using SFT, and the [PITH_FULL_IMAGE:figures/full_fig_p008_9.png]
Figure 10
Figure 10. Figure 10: Token-level selection comparison between CUT and [PITH_FULL_IMAGE:figures/full_fig_p009_10.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

20 extracted references · 10 canonical work pages

  1. [1]

    A survey of chain of thought reasoning: Advances, frontiers and future

    [Chu et al., 2023] Zheng Chu, Jingchang Chen, Qianglong Chen, Weijiang Yu, Tao He, Haotian Wang, Weihua Peng, Ming Liu, Bing Qin, and Ting Liu. A survey of chain of thought reasoning: Advances, frontiers and future. arXiv preprint arXiv:2309.15402,

    arXiv 2023

  2. [6]

    Reft: Reasoning with reinforced fine-tuning

    [Luong et al., 2024] Trung Quoc Luong, Xinbo Zhang, Zhanming Jie, Peng Sun, Xiaoran Jin, and Hang Li. Reft: Reasoning with reinforced fine-tuning. arXiv preprint arXiv:2401.08967,

    arXiv 2024

  3. [7]

    Gpt-4 technical report

    [OpenAI, 2023] R OpenAI. Gpt-4 technical report. arxiv 2303.08774. View in Article, 2(5),

    arXiv 2023

  4. [8]

    Reinforcement learning from hu- man feedback research program,

    [OpenAI, 2024] OpenAI. Reinforcement learning from hu- man feedback research program,

    work page 2024

  5. [9]

    [Ouyang et al., 2022] Long Ouyang, Jeffrey Wu, Xu Jiang, Diogo Almeida, Carroll Wainwright, Pamela Mishkin, Chong Zhang, Sandhini Agarwal, Katarina Slama, Alex Ray, et al

    Accessed: 2024- 12-23. [Ouyang et al., 2022] Long Ouyang, Jeffrey Wu, Xu Jiang, Diogo Almeida, Carroll Wainwright, Pamela Mishkin, Chong Zhang, Sandhini Agarwal, Katarina Slama, Alex Ray, et al. Training language models to follow instruc- tions with human feedback. Advances in neural informa- tion processing systems, 35:27730–27744,

    work page 2024

  6. [11]

    Code llama: Open foundation models for code

    [Roziere et al., 2023] Baptiste Roziere, Jonas Gehring, Fabian Gloeckle, Sten Sootla, Itai Gat, Xiaoqing Ellen Tan, Yossi Adi, Jingyu Liu, Romain Sauvestre, Tal Remez, et al. Code llama: Open foundation models for code. arXiv preprint arXiv:2308.12950,

    arXiv 2023

  7. [12]

    Prox- imal policy optimization algorithms

    [Schulman et al., 2017] John Schulman, Filip Wolski, Pra- fulla Dhariwal, Alec Radford, and Oleg Klimov. Prox- imal policy optimization algorithms. arXiv preprint arXiv:1707.06347,

    arXiv 2017

  8. [15]

    Chain-of-thought prompting elicits reasoning in large language models

    [Wei et al., 2022] Jason Wei, Xuezhi Wang, Dale Schuur- mans, Maarten Bosma, Fei Xia, Ed Chi, Quoc V Le, Denny Zhou, et al. Chain-of-thought prompting elicits reasoning in large language models. Advances in neural information processing systems, 35:24824–24837,

    2022

Show all 20 references
  1. [16]

    Reasons to reject? align- ing language models with judgments

    [Xu et al., 2023] Weiwen Xu, Deng Cai, Zhisong Zhang, Wai Lam, and Shuming Shi. Reasons to reject? align- ing language models with judgments. arXiv preprint arXiv:2312.14591,

    2023 arXiv

  2. [17]

    Deep stable learning for out-of-distribution generalization

    [Zhang et al., 2021] Xingxuan Zhang, Peng Cui, Renzhe Xu, Linjun Zhou, Yue He, and Zheyan Shen. Deep stable learning for out-of-distribution generalization. InProceed- ings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 5372–5382,

    2021

  3. [18]

    Dpo meets ppo: Reinforced token optimization for rlhf

    [Zhong et al., 2024] Han Zhong, Guhao Feng, Wei Xiong, Li Zhao, Di He, Jiang Bian, and Liwei Wang. Dpo meets ppo: Reinforced token optimization for rlhf. arXiv preprint arXiv:2404.18922,

    2024 arXiv

  4. [19]

    Instruction Suppose you are a math expert and you are presented with a math problem, a student’s response, and the correct answer

    A Prompt Strategies A.1 Prompt Strategy of Judgment on the GSM8K Dataset In this section, we present a prompt engineering strategy for generating the judgment of incorrect samples. Instruction Suppose you are a math expert and you are presented with a math problem, a student’s...

    2021

  5. [30]

    , 2020 ]

    SFT: Our SFT implementation employs SFTTrainer in trl [von Werra et al. , 2020 ]. To ensure that the SFT code configuration is largely consistent with NLFT configuration, we have essentially adopted most of the parameter settings of NLFT. ReFT: Following [Luong et al., 2024], ...

    2020

  6. [2017]

    Trl: Transformer reinforcement learning

    [von Werra et al., 2020] Leandro von Werra, Younes Belkada, Lewis Tunstall, Edward Beeching, Tristan Thrush, Nathan Lambert, Shengyi Huang, Kashif Rasul, and Quentin Gallou ´edec. Trl: Transformer reinforcement learning. https://github.com/huggingface/trl,

    2020

  7. [2019]

    Decoupled Weight Decay Regularization, January

    [Loshchilov and Hutter, 2019] Ilya Loshchilov and Frank Hutter. Decoupled Weight Decay Regularization, January

    2019

  8. [2020]

    Self-consistency improves chain of thought reasoning in language models

    [Wang et al., 2022] Xuezhi Wang, Jason Wei, Dale Schu- urmans, Quoc Le, Ed Chi, Sharan Narang, Aakanksha Chowdhery, and Denny Zhou. Self-consistency improves chain of thought reasoning in language models. arXiv preprint arXiv:2203.11171,

    2022 arXiv

  9. [2021]

    Re- search on overfitting of deep learning

    [Li et al., 2019] Haidong Li, Jiongcheng Li, Xiaoming Guan, Binghao Liang, Yuting Lai, and Xinglong Luo. Re- search on overfitting of deep learning. In 2019 15th In- ternational Conference on Computational Intelligence and Security (CIS), pages 78–81,

    2019

  10. [2022]

    From r to q∗: Your lan- guage model is secretly a q-function

    [Rafailov et al., 2024a] Rafael Rafailov, Joey Hejna, Ryan Park, and Chelsea Finn. From r to q∗: Your lan- guage model is secretly a q-function. arXiv preprint arXiv:2404.12358,

    arXiv

  11. [2023]

    Training Verifiers to Solve Math Word Problems, November

    [Cobbe et al., 2021] Karl Cobbe, Vineet Kosaraju, Moham- mad Bavarian, Mark Chen, Heewoo Jun, Lukasz Kaiser, Matthias Plappert, Jerry Tworek, Jacob Hilton, Reiichiro Nakano, Christopher Hesse, and John Schulman. Training Verifiers to Solve Math Word Problems, November

    2021

  12. [2024]

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

    [Hu et al., 2021] Edward J. Hu, Yelong Shen, Phillip Wallis, Zeyuan Allen-Zhu, Yuanzhi Li, Shean Wang, Lu Wang, and Weizhu Chen. Lora: Low-rank adaptation of large language models,

    2021

Pith tools

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