Pith. sign in

REVIEW 4 major objections 6 minor 31 references

CRPE: Expanding The Reasoning Capability of Large Language Model for Code Generation

T0 review · 4 major / 6 minor · reviewed 2026-08-15 · deepseek-v4-flash

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

Pith's one-line read A three-stage data-and-training pipeline claims to turn base code models into benchmark-leading code reasoners, with one 7B model beating instruction-tuned models of comparable size and one 32B model beating GPT-4O on LiveCodeBench.

desk verdict A plausible three-stage recipe for code reasoning that would be worth believing once the label-quality and artifact issues are addressed. read the letter →

arxiv 2505.10594 v1 pith:6J6TA7CY submitted 2025-05-15 cs.SE cs.AI

Ningxin Gui , Qianghuai Jia , Feijun Jiang , Yuling Jiao , dechun wang , Jerry Zhijian Yang This is my paper · ORCID
classification cs.SEcs.AI
keywords codegenerationchain-of-thoughtStep-DPOtreesearchsyntheticdatamulti-agentframeworkLiveBenchself-improvement
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

The paper claims that the missing ingredient in code generation is not more solve data but the reasoning process itself. It introduces CRPE, a three-stage pipeline that starts from a base code model with no instruction tuning: first it synthesizes and filters hard programming problems, then a multi-agent setup driven by a strong direct-answer model produces step-by-step chain-of-thought reasoning traces with final code, and finally the fine-tuned model explores alternate reasoning paths by tree search and is refined with step-level preference optimization. The authors report pass@1 scores of 21.88 for the 7B model and 35.08 for the 32B model on the LiveCodeBench 2024-07-01 to 2024-09-01 window, with the 32B model surpassing GPT-4O's reported score. If true, the practical point is that explicit reasoning traces and step-wise self-preference data can be synthesized and reused, so smaller open models move closer to closed reasoning models without a separate reward model.

What carries the argument

The load-bearing machinery is the three-stage loop. Stage one is a code problem pipeline that extracts code snippets from a large open corpus, prompts an LLM to write new problems inspired by them, applies Evol-Instruct-style rewriting to make them harder, filters for clarity, difficulty, and self-containedness, and decontaminates against the test benchmark. Stage two is the Code-COT Maker, a multi-agent workflow in which a strong direct-answer model plays a Thinking Agent that emits step-by-step reasoning, a Reflection Agent that judges whether the reasoning is on track and analyzes execution errors, and an Execution Agent that compiles and runs the code; when no tests exist, an LLM Test Generator writes test cases and an LLM Result Checker decides yes/no on the output. Stage three is the self-improvement loop: the SFT model samples complete reasoning paths from each node of a tree, nodes whose sampled paths all fail are marked rejected and nodes that lead to a correct answer are accepted, and accepted/rejected child-node pairs become preference data for Step-DPO, a preference objective that increases the probability of the next correct reasoning step and decreases the next wrong one. The chain-of-thought traces are delimited with <thinking>, <reflection>, and <ChainOfThought> tags, which give the model a concrete output structure to imitate.

What would settle it

Take a random sample of the code problems used in training, replace the LLM-written test cases and the LLM result checker with independent, human-written unit tests, and re-score every 'accepted' reasoning path and every Step-DPO preference pair; if a substantial fraction of accepted paths fail the independent tests, or if retraining on only independently verified pairs wipes out the reported LiveCodeBench gains, the central claim is false.

Watch

Extended reading notes

Core claim

On its own terms, CRPE establishes that a code model can be upgraded by treating reasoning as a trainable intermediate product. Starting from Qwen2.5-Coder-7B/32B-Base, the pipeline produces COT-Coder-StepDPO models whose LiveCodeBench pass@1 scores (21.88 for 7B, 35.08 in the abstract and 35.09 in Table I for 32B) exceed the instruction-tuned Qwen2.5-Coder baselines (15.94 and 29.71) and, for 32B, the GPT-4O score of 33.6. The reasoning data is the carrier: supervised fine-tuning on 2,810 high-quality reasoning traces beats fine-tuning on direct answers in the paper's controlled comparison (19.15 vs 16.60 on partial data), and step-DPO on tree-search preference pairs adds further gains. The conclusion the paper draws is that synthesizing the process, not just the final code, is what improves code generation ability.

Load-bearing premise

The entire result depends on the AI-written tests and the AI yes/no checker being reliable judges of whether a solution is correct, because those labels decide which reasoning traces are kept in the SFT data and which reasoning steps are preferred during Step-DPO.

Editorial extensions

If this is right

  • If CRPE works as reported, a base code model can gain several points of LiveCodeBench pass@1 without hand-labeling reasoning traces or training a separate reward model.
  • The controlled comparison of reasoning-annotated answers versus direct answers implies that the marginal value in code SFT data is the reasoning trace, so dataset builders should spend budget on process annotation rather than only on more solutions.
  • Tree-search sampling makes preference pairs a byproduct of exploration, which means the improvement loop can be run iteratively: the better the model becomes, the more reliable accepted nodes become for the next Step-DPO round.
  • Because the reported numbers are on a decontaminated benchmark window, the framework's real test is whether the same models hold their advantage on later coding benchmark windows without further training.

Reading between the lines

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

  • Editorial inference: the correctness signal in both the expert-data stage and the self-improvement stage is produced by LLMs that also write the tests; an important extension is to audit how often LLM-written tests accept wrong code and whether removing such cases changes the ranking.
  • Editorial inference: the paper does not isolate whether the gains come from genuinely better reasoning or from learning a well-structured chain-of-thought format; a control that trains on the same reasoning traces with randomly shuffled steps would separate format learning from reasoning learning.
  • Editorial inference: the Step-DPO preference pairs are sampled from the model being trained, so the loop may reinforce the model's own error patterns; a test using preference pairs generated by a different model would show how much of the gain is self-contained.
  • Editorial inference: since decontamination is done against the specific LiveCodeBench window, a natural next experiment is to run the identical pipeline on a later benchmark window and compare the score gap to the original result.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

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 paper proposes CRPE, a three-stage pipeline for synthesizing code reasoning data and training code LLMs: (i) generation and filtering of large-scale code problem instructions, (ii) multi-agent synthesis of chain-of-thought reasoning data for supervised fine-tuning (SFT), and (iii) tree-search self-exploration with Step-DPO for iterative self-improvement. The authors report pass@1 results on LiveCodeBench (20240701-20240901), claiming that COT-Coder-7B-StepDPO reaches 21.88 and COT-Coder-32B-StepDPO reaches 35.08, outperforming GPT-4O. The central claim is that explicitly training on reasoning processes, rather than only on final answers, improves code generation capability.

Significance. If the reported gains are real, CRPE offers a practical, open recipe for improving code reasoning in LLMs without training a separate reward model. The controlled CoT-versus-direct comparison in Section IV.C.1 is a reasonable way to isolate the value of reasoning-process data, and the decontamination step against LiveCodeBench is a genuine safeguard. The manuscript also provides full prompt templates and training hyperparameters, which supports reproducibility. However, the absence of validation of the correctness labels used to construct SFT and Step-DPO data, combined with small unquantified performance gaps and overreaching summary claims, means the headline contributions are not yet fully established.

major comments (4)
  1. [Abstract and Section IV.B, Table I] The abstract claims that COT-Coder-7B-StepDPO 'exceeds all models with similar or even larger sizes,' but Table I reports Llama3.3-70B-Instruct at 26.88 and Qwen2.5-Coder-32B-Instruct at 29.71, both higher than the 7B model's 21.88. Additionally, Section IV.B states that 'CRPE-32B model achieved a score of 34.22,' while Table I lists COT-Coder-32B-StepDPO at 35.09 and the abstract gives 35.08. These numerical contradictions must be resolved because the headline comparison is a central claim.
  2. [Section III.C.3 and Section IV.A] The correctness labels that select SFT data and Step-DPO preference pairs are produced by the pipeline's own LLM-based Test Generator and Result Checker, with no reported audit against human-written or hidden tests. Because Step-DPO's chosen/rejected child nodes are defined directly by these accept/reject labels, systematic noise in the labels could produce the observed benchmark gains without genuine improvement in reasoning ability. The authors should report a manual audit (e.g., false-positive and false-negative rates on a sample with known correct answers) or compare LLM-generated tests against independent held-out tests, and quantify how label noise affects the Step-DPO training signal.
  3. [Section IV.A and Table I] The main evaluation reports a single pass@1 estimate per model with no error bars, confidence intervals, or multiple seeds. The SFT-to-StepDPO deltas (20.18 vs 21.88 for the 7B model; 33.49 vs 35.09 for the 32B model) are small enough that sampling noise could change the conclusions. Please provide variance estimates, for example via multiple evaluation seeds or bootstrap confidence intervals on pass@1.
  4. [Section II and Table I] The comparison set lacks reasoning-oriented baselines that are most relevant to the paper's claim of expanding reasoning capability, such as OpenAI o1, QwQ, or other Step-DPO/process-supervised code reasoning models. Without these baselines, the improvement over generic instruction-tuned models does not establish the specific contribution of the proposed reasoning-enhancement method.
minor comments (6)
  1. [Section IV.B] The phrases 'Our CRPE-7B model scored 21' and 'CRPE-32B model achieved a score of 34.22' should be updated to match the exact numbers in Table I (21.88 and 35.09).
  2. [Section IV.C.2] The post-hoc correction of function names (HumanEval improvement to 74.4/68.9 and MBPP to 78.6/66.1) is not an official benchmark result and should be clearly labeled as an analysis of failure modes rather than as a score.
  3. [Throughout] The paper uses 'COT' and 'CoT' interchangeably, and 'step-DPO' appears alongside 'Step-DPO' in several places; please standardize the terminology.
  4. [References] Reference [13] appears twice with inconsistent capitalization, and the bibliography contains many missing line breaks; the authors should run a standard citation formatting pass.
  5. [Section III.B.1 vs Section IV.A] The paper says 'we ultimately gather several thousand code instructions' in Section III.B.1, but Section IV.A reports 4,749 open-source code problems; please harmonize these numbers.
  6. [Appendix] The prompt templates in Figures 7-12 are not explicitly referenced in the experimental setup; adding pointers to the relevant sections would improve reproducibility.

Circularity Check

0 steps flagged · score 0.0 of 10

No circularity: CRPE's claimed benchmark gains are measured on external LiveCodeBench, and the training labels are not fitted to that benchmark.

full rationale

CRPE is an empirical data-synthesis and training pipeline rather than a formal derivation whose output reduces to its inputs. The headline claims are pass@1 scores on LiveCodeBench, an external held-out benchmark, and Section III.B.3 explicitly decontaminates the training problems against LiveCodeBench by removing any data with a 10-gram overlap. The SFT data are produced by a multi-agent Code-COT Maker, and the Step-DPO preference pairs are derived from tree-search accept/reject labels; for problems without provided unit tests, those labels come from LLM-generated tests and an LLM-based result checker (Sections III.C.3, III.D, IV.A). This is a self-training loop with a potentially noisy correctness signal, but it is not circular: the final evaluation is separate from the training labels, and no fitted parameter is renamed as a prediction. The CoT-versus-direct ablation compares answer formats drawn from the same problem set, so it tests the effect of reasoning format rather than reducing the central claim to its inputs. The Limitations section (Section VI) acknowledges reliance on high-quality code problems and the lack of a method for evaluating data effectiveness for the target model; this is a data-quality concern, not a circularity. There are no load-bearing self-citations, no imported uniqueness theorems, and no ansatz smuggled in via citation. Therefore the paper is self-contained against an external benchmark and receives a circularity score of 0.

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

CRPE is an empirical ML pipeline with no mathematical derivation and no invented physical entities. It depends on hand-set tree search and training hyperparameters, on the reliability of LLM-generated test cases, on the validity of Step-DPO preference labels, and on LiveCodeBench as an evaluation proxy. Nothing is fitted to the target benchmark in the sense of tuning constants after seeing test answers, but the design choices are not derived from first principles either.

free parameters (5)
  • max path num = 5
    Tree search width cap for sampling reasoning paths in self-exploration; chosen by hand in Section IV.A and affects which nodes are labeled accepted or rejected.
  • max depth num = 64
    Tree search depth cap from Section IV.A; paths exceeding this depth cannot be considered, changing preference pair construction.
  • max token limit per path = 25,000
    Paths longer than 25,000 tokens are truncated and treated as incorrect in Section IV.A, directly altering accepted or rejected labels.
  • Step-DPO beta = 0.1
    Preference optimization strength chosen by hand in Section IV.A; not fitted to LiveCodeBench.
  • NLL loss coefficient = 0.2
    Additional chosen-sequence NLL term coefficient from Section IV.A, selected by hand following Llama3-style training.
assumptions (5)
  • domain assumption LLM-generated test cases and LLM-as-Critic result checking determine code correctness when official tests are absent.
    The Execution Agent relies on generated tests to validate code; if these are wrong, validated reasoning traces and preference labels are unreliable. Entered in Sections III.C.3 and IV.A.
  • domain assumption Step-DPO on accepted and rejected node pairs produced by the tree search improves the model's code reasoning ability.
    Borrowed from Step-DPO [26], but the authors do not independently verify that node labels reflect true step-level correctness; this assumption enters in Section III.D and IV.A.
  • domain assumption LiveCodeBench pass@1 estimated from 10 sampled solutions with temperature 0.2 is a reliable comparison signal.
    No error bars or repeated seeds are provided; on 106 problems a 1 to 2 point difference may be noise. Section IV.A.
  • domain assumption The 10-gram overlap decontamination procedure removes training problems that would leak LiveCodeBench answers.
    Lexical overlap following Qwen2.5-Coder may miss paraphrased or semantic leakage; Section III.B.3.
  • domain assumption Claude-3.5-sonnet's step-by-step reasoning traces represent expert reasoning suitable for SFT.
    The Code-COT Maker uses Claude-3.5-sonnet as the System-1 model, and trace quality is only checked indirectly through final code execution; Section III.C and IV.A.

how reviews work

0 comments
Cite this review

Pith. "Pith review of CRPE: Expanding The Reasoning Capability of Large Language Model for Code Generation." pith.science (2026). https://pith.science/paper/6J6TA7CY

@misc{pith2026250510594,
  author       = {Pith},
  title        = {Pith review of: CRPE: Expanding The Reasoning Capability of Large Language Model for Code Generation},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/6J6TA7CY}},
  note         = {Machine review of arXiv:2505.10594}
}
read the original abstract

We introduce CRPE (Code Reasoning Process Enhancer), an innovative three-stage framework for data synthesis and model training that advances the development of sophisticated code reasoning capabilities in large language models (LLMs). Building upon existing system-1 models, CRPE addresses the fundamental challenge of enhancing LLMs' analytical and logical processing in code generation tasks. Our framework presents a methodologically rigorous yet implementable approach to cultivating advanced code reasoning abilities in language models. Through the implementation of CRPE, we successfully develop an enhanced COT-Coder that demonstrates marked improvements in code generation tasks. Evaluation results on LiveCodeBench (20240701-20240901) demonstrate that our COT-Coder-7B-StepDPO, derived from Qwen2.5-Coder-7B-Base, with a pass@1 accuracy of 21.88, exceeds all models with similar or even larger sizes. Furthermore, our COT-Coder-32B-StepDPO, based on Qwen2.5-Coder-32B-Base, exhibits superior performance with a pass@1 accuracy of 35.08, outperforming GPT4O on the benchmark. Overall, CRPE represents a comprehensive, open-source method that encompasses the complete pipeline from instruction data acquisition through expert code reasoning data synthesis, culminating in an autonomous reasoning enhancement mechanism.

Figures

Figures reproduced from arXiv: 2505.10594 by the authors.

Figure 1
Figure 1. The overview of CRPE, which comprises three steps: (i) synthesizing large-scale code problems and (ii) synthesizing high-quality code reasoning [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 2
Figure 2. Code Problem Pipeline. Considering that the majority of open-source code data may have already been used during the pre-training of LLMs, the associated problems may not require complex reasoning for the models to arrive at correct answers. As such, further training on these problems does not effectively enhance the models’ code reasoning capabilities. Therefore, in addition to collecting open-source code instructio… view at source ↗
Figure 3
Figure 3. The Thinking Agent Illustration [PITH_FULL_IMAGE:figures/full_fig_p004_3.png] view at source ↗
Figures from the paper (9 more)
Figure 4
Figure 4. Figure 4: The Reflection Agent Illustration. 2) Reflection Agent: The Reflection Agent is also powered by LLMs. It needs to analyze the reasoning content of each step provided by the Thinking Agent and determine whether it is correct, thereby deciding whether to allow the Thinki…
Figure 5
Figure 5. Figure 5: The Execution Agent Illustration. coding problem includes executable test cases, the Execution Agent will directly execute the code along with the test cases and provide a signal indicating whether the outcome is correct or incorrect. If the execution result is incorre…
Figure 6
Figure 6. Figure 6: self-explore&self-improve. Although training the model using Code reasoning data synthesized with powerful system-1 model can enhance the model’s code reasoning capabilities, generating such synthetic data is very costly and will ultimately be limited by the capabiliti…
Figure 7
Figure 7. Figure 7: Prompt for generating code problem [PITH_FULL_IMAGE:figures/full_fig_p011_7.png]
Figure 8
Figure 8. Figure 8: Prompt for difficulty analysis [PITH_FULL_IMAGE:figures/full_fig_p012_8.png]
Figure 9
Figure 9. Figure 9: Prompt for Thinking Agent [PITH_FULL_IMAGE:figures/full_fig_p013_9.png]
Figure 10
Figure 10. Figure 10: Prompt for Reflection Agent [PITH_FULL_IMAGE:figures/full_fig_p014_10.png]
Figure 11
Figure 11. Figure 11: Prompt for Execution Agent to generate test code [PITH_FULL_IMAGE:figures/full_fig_p015_11.png]
Figure 12
Figure 12. Figure 12: Prompt for Execution Agent to check correctness of execution result [PITH_FULL_IMAGE:figures/full_fig_p016_12.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

31 extracted references · 5 canonical work pages

  1. [2]

    DeepSeek-Coder-V2: Breaking the Barrier of Closed- Source Models in Code Intelligence,

    DeepSeek-AI, Q. Zhu, D. Guo, Z. Shao, D. Yang, P. Wang, R. Xu, Y . Wu, Y . Li, H. Gao, S. Ma, W. Zeng, X. Bi, Z. Gu, H. Xu, D. Dai, K. Dong, L. Zhang, Y . Piao, Z. Gou, Z. Xie, Z. Hao, B. Wang, J. Song, D. Chen, X. Xie, K. Guan, Y . You, A. Liu, Q. Du, W. Gao, X. Lu, Q. Chen, Y . Wang, C. Deng, J. Li, C. Zhao, C. Ruan, F. Luo, and W. Liang, “DeepSeek-Code...

    arXiv 2024

  2. [3]

    Chain of thought prompting elicits reasoning in large language models,

    J. Wei, X. Wang, D. Schuurmans, M. Bosma, E. H. Chi, Q. Le, and D. Zhou, “Chain of thought prompting elicits reasoning in large language models,” CoRR, vol. abs/2201.11903, 2022. [Online]. Available: https://arxiv.org/abs/2201.11903

    arXiv 2022

  3. [4]

    Tree of thoughts: Deliberate problem solving with large language models,

    S. Yao, D. Yu, J. Zhao, I. Shafran, T. L. Griffiths, Y . Cao, and K. Narasimhan, “Tree of thoughts: Deliberate problem solving with large language models,” 2023. [Online]. Available: https: //arxiv.org/abs/2305.10601

    arXiv 2023

  4. [5]

    Alphamath almost zero: Process supervision without process,

    G. Chen, M. Liao, C. Li, and K. Fan, “Alphamath almost zero: Process supervision without process,” 2024. [Online]. Available: https://arxiv.org/abs/2405.03553

    arXiv 2024

  5. [6]

    Llama-berry: Pairwise optimization for o1-like olympiad-level mathematical reasoning,

    D. Zhang, J. Wu, J. Lei, T. Che, J. Li, T. Xie, X. Huang, S. Zhang, M. Pavone, Y . Li, W. Ouyang, and D. Zhou, “Llama-berry: Pairwise optimization for o1-like olympiad-level mathematical reasoning,” 2024. [Online]. Available: https://arxiv.org/abs/2410.02884

    arXiv 2024

  6. [7]

    Wizardcoder: Empowering code large language models with evol-instruct,

    Z. Luo, C. Xu, P. Zhao, Q. Sun, X. Geng, W. Hu, C. Tao, J. Ma, Q. Lin, and D. Jiang, “Wizardcoder: Empowering code large language models with evol-instruct,” 2023. [Online]. Available: https://arxiv.org/abs/2306.08568

    arXiv 2023

  7. [8]

    Wavecoder: Widespread and versatile enhancement for code large language models by instruction tuning,

    Z. Yu, X. Zhang, N. Shang, Y . Huang, C. Xu, Y . Zhao, W. Hu, and Q. Yin, “Wavecoder: Widespread and versatile enhancement for code large language models by instruction tuning,” 2024. [Online]. Available: https://arxiv.org/abs/2312.14187

    arXiv 2024

  8. [9]

    Magicoder: Empowering code generation with oss-instruct,

    Y . Wei, Z. Wang, J. Liu, Y . Ding, and L. Zhang, “Magicoder: Empowering code generation with oss-instruct,” 2024. [Online]. Available: https://arxiv.org/abs/2312.02120

    arXiv 2024

Show all 31 references
  1. [10]

    Stepcoder: Improve code generation with reinforcement learning from compiler feedback,

    S. Dou, Y . Liu, H. Jia, L. Xiong, E. Zhou, W. Shen, J. Shan, C. Huang, X. Wang, X. Fan, Z. Xi, Y . Zhou, T. Ji, R. Zheng, Q. Zhang, X. Huang, and T. Gui, “Stepcoder: Improve code generation with reinforcement learning from compiler feedback,” 2024. [Online]. Available: https:...

    2024 arXiv

  2. [11]

    Execution-based code generation using deep reinforcement learning,

    P. Shojaee, A. Jain, S. Tipirneni, and C. K. Reddy, “Execution-based code generation using deep reinforcement learning,” 2023. [Online]. Available: https://arxiv.org/abs/2301.13816

    2023 arXiv

  3. [12]

    Rltf: Reinforcement learning from unit test feedback,

    J. Liu, Y . Zhu, K. Xiao, Q. Fu, X. Han, W. Yang, and D. Ye, “Rltf: Reinforcement learning from unit test feedback,” 2023. [Online]. Available: https://arxiv.org/abs/2307.04349

    2023 arXiv

  4. [13]

    Qwen2.5-coder technical report,

    B. Hui, J. Yang, Z. Cui, J. Yang, D. Liu, L. Zhang, T. Liu, J. Zhang, B. Yu, K. Lu, K. Dang, Y . Fan, Y . Zhang, A. Yang, R. Men, F. Huang, B. Zheng, Y . Miao, S. Quan, Y . Feng, X. Ren, X. Ren, J. Zhou, and J. Lin, “Qwen2.5-coder technical report,” 2024. [Online]. Available: ...

    2024 arXiv

  5. [14]

    Deepseek-coder: When the large language model meets programming – the rise of code intelligence,

    D. Guo, Q. Zhu, D. Yang, Z. Xie, K. Dong, W. Zhang, G. Chen, X. Bi, Y . Wu, Y . K. Li, F. Luo, Y . Xiong, and W. Liang, “Deepseek-coder: When the large language model meets programming – the rise of code intelligence,” 2024. [Online]. Available: https://arxiv.org/abs/2401.14196

    2024 arXiv

  6. [15]

    Code llama: Open foundation models for code,

    B. Rozi `ere, J. Gehring, F. Gloeckle, S. Sootla, I. Gat, X. E. Tan, Y . Adi, J. Liu, R. Sauvestre, T. Remez, J. Rapin, A. Kozhevnikov, I. Evtimov, J. Bitton, M. Bhatt, C. C. Ferrer, A. Grattafiori, W. Xiong, A. D ´efossez, J. Copet, F. Azhar, H. Touvron, L. Martin, N. Usunier...

    2024 arXiv

  7. [16]

    The llama 3 herd of models,

    A. Grattafiori, A. Dubey, A. Jauhri, A. Pandey, A. Kadian, A. Al- Dahle, A. Letman, A. Mathur, A. Schelten, A. Vaughan, A. Yang, A. Fan, A. Goyal, A. Hartshorn, A. Yang, A. Mitra, A. Sravankumar, A. Korenev, A. Hinsvark, A. Rao, A. Zhang, A. Rodriguez, A. Gregerson, A. Spataru...

  8. [17]

    Starcoder 2 and the stack v2: The next generation,

    A. Lozhkov, R. Li, L. B. Allal, F. Cassano, J. Lamy-Poirier, N. Tazi, A. Tang, D. Pykhtar, J. Liu, Y . Wei, T. Liu, M. Tian, D. Kocetkov, A. Zucker, Y . Belkada, Z. Wang, Q. Liu, D. Abulkhanov, I. Paul, Z. Li, W.-D. Li, M. Risdal, J. Li, J. Zhu, T. Y . Zhuo, E. Zheltonozhskii,...

    2024 arXiv

  9. [18]

    Compilable neural code generation with compiler feedback,

    X. Wang, Y . Wang, Y . Wan, F. Mi, Y . Li, P. Zhou, J. Liu, H. Wu, X. Jiang, and Q. Liu, “Compilable neural code generation with compiler feedback,” 2022. [Online]. Available: https://arxiv.org/abs/2203.05132

    2022 arXiv

  10. [19]

    Coderl: Mastering code generation through pretrained models and deep reinforcement learning,

    H. Le, Y . Wang, A. D. Gotmare, S. Savarese, and S. C. H. Hoi, “Coderl: Mastering code generation through pretrained models and deep reinforcement learning,” 2022. [Online]. Available: https: //arxiv.org/abs/2207.01780

    2022 arXiv

  11. [20]

    Codedpo: Aligning code models with self generated and verified source code,

    K. Zhang, G. Li, Y . Dong, J. Xu, J. Zhang, J. Su, Y . Liu, and Z. Jin, “Codedpo: Aligning code models with self generated and verified source code,” 2024. [Online]. Available: https://arxiv.org/abs/2410.05605

    2024 arXiv

  12. [21]

    Learning to reason with large language models

    OpenAI, “Learning to reason with large language models.” 2024. [On- line]. Available: https://openai.com/index/learning-to-reason-with-llms/

    2024

  13. [22]

    Qwq-32b-preview

    Q. Team, “Qwq-32b-preview.” 2024. [Online]. Available: https: //qwenlm.github.io/zh/blog/qwq-32b-preview/

    2024

  14. [23]

    Process supervision-guided policy optimization for code generation,

    N. Dai, Z. Wu, R. Zheng, Z. Wei, W. Shi, X. Jin, G. Liu, C. Dun, L. Huang, and L. Yan, “Process supervision-guided policy optimization for code generation,” 2024. [Online]. Available: https://arxiv.org/abs/2410.17621

    2024 arXiv

  15. [24]

    o1-coder: an o1 replication for coding,

    Y . Zhang, S. Wu, Y . Yang, J. Shu, J. Xiao, C. Kong, and J. Sang, “o1-coder: an o1 replication for coding,” 2024. [Online]. Available: https://arxiv.org/abs/2412.00154

    2024 arXiv

  16. [25]

    Direct preference optimization: Your language model is secretly a reward model,

    R. Rafailov, A. Sharma, E. Mitchell, S. Ermon, C. D. Manning, and C. Finn, “Direct preference optimization: Your language model is secretly a reward model,” 2024. [Online]. Available: https: //arxiv.org/abs/2305.18290

    2024 arXiv

  17. [26]

    Step-dpo: Step-wise preference optimization for long-chain reasoning of llms,

    X. Lai, Z. Tian, Y . Chen, S. Yang, X. Peng, and J. Jia, “Step-dpo: Step-wise preference optimization for long-chain reasoning of llms,”

  18. [27]

    Deepseek-prover-v1.5: Harnessing proof assistant feedback for reinforcement learning and monte-carlo tree search,

    H. Xin, Z. Z. Ren, J. Song, Z. Shao, W. Zhao, H. Wang, B. Liu, L. Zhang, X. Lu, Q. Du, W. Gao, Q. Zhu, D. Yang, Z. Gou, Z. F. Wu, F. Luo, and C. Ruan, “Deepseek-prover-v1.5: Harnessing proof assistant feedback for reinforcement learning and monte-carlo tree search,” 2024. [Onl...

    2024 arXiv

  19. [28]

    Available: https://arxiv.org/abs/2406.18629

    [Online]. Available: https://arxiv.org/abs/2406.18629

    arXiv

  20. [30]

    Is your code generated by chatgpt really correct? rigorous evaluation of large language models for code generation,

    J. Liu, C. S. Xia, Y . Wang, and L. Zhang, “Is your code generated by chatgpt really correct? rigorous evaluation of large language models for code generation,” 2023. [Online]. Available: https://arxiv.org/abs/2305.01210 APPENDIX Please gain inspiration from the following rand...

    2023 arXiv

  21. [31]

    [Problem Description]: This should be **completely self-contained**, providingall the contextual information one needs to understand and solve the problem.Assume common programming knowledge, but ensure that any specific context,variables, or code snippets pertinent to this pr...

  22. [32]

    intent":

    [Solution]: Offer a comprehensive, **correct** solution that accurately addressesthe [Problem Description] you provided. Fig. 7. Prompt for generating code problem # InstructionYou first need to identify the given user intent and then label the difficulty level of the userquer...

  23. [2024]

    Available: https://arxiv.org/abs/2407.21783

    [Online]. Available: https://arxiv.org/abs/2407.21783

    arXiv

Pith tools

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