Pith. sign in

REVIEW 3 major objections 4 minor 29 references

Compiler-R1: Towards Agentic Compiler Auto-tuning with Reinforcement Learning

T0 review · 3 major / 4 minor · reviewed 2026-08-07 · deepseek-v4-flash

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

Pith's one-line read Compiler-R1 shows that an LLM trained with reinforcement learning and tool access finds compiler pass sequences that reduce IR instruction counts by an average of 8.46% over the opt -Oz baseline across seven benchmark suites.

desk verdict Solid system paper, but the headline RL gain is unproven without a tool-only baseline; the FBPS confound is load-bearing. read the letter →

arxiv 2506.15701 v1 pith:EABVSKOY submitted 2025-05-30 cs.LG cs.AI

Haolin Pan , Hongyu Lin , Haoran Luo , Yang Liu , Kaichun Yao , Libo Zhang , Mingjie Xing , Yanjun Wu This is my paper
classification cs.LGcs.AI
keywords compilerauto-tuningLLMagentreinforcementlearningLLVMpassorderingIRinstructioncounttool-augmentedreasoningtwo-stagetrainingoutcome-basedreward
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

Compiler auto-tuning today is caught between slow search-based autotuners and LLMs that imitate fixed examples without checking results. This paper argues that an LLM agent trained with reinforcement learning can do better by interacting with the compiler: querying pass effects, receiving feedback, and refining its strategy. Compiler-R1 first learns a tool-use protocol from curated reasoning traces, then optimizes a reward tied to actual IR instruction-count reduction. Across seven benchmark suites, the strongest variant reports an average 8.46% reduction in IR instruction count relative to opt -Oz, while supervised-only baselines reach at most 4.66% even after 40 sampling attempts. If the attribution holds, RL-trained agents would offer a practical and much faster route to compiler optimization.

What carries the argument

The central mechanism is a closed loop between an LLM agent and the compiler environment, held together by two tools. The agent emits structured traces with <think>, <tool_call>, and <answer> markers; one tool, instrcount, returns a candidate sequence's improvement over -Oz, and the other, find_best_pass_sequence, is a guided search invoked when the candidate underperforms. On the data side, the paper builds a global graph of synergistic pass pairs (A,B), where B alone reduces instruction count and applying A before B reduces it further, then samples candidate sequences from that graph and keeps the best against -Oz as the supervised label. During RL, the reward is a weighted sum of a format reward for protocol-valid traces and an answer reward proportional to instruction-count reduction over the unoptimized program. This loop is what lets the model verify its guesses, fall back to search, and receive dense scalar feedback for policy learning.

What would settle it

Run find_best_pass_sequence alone on the same 335 test programs and compare its average OverOz with GRPO-7B's 8.46%; if the standalone tool matches or exceeds that figure, or if removing the tool from the agent's available actions during RL collapses performance toward the SFT-only baseline near 4.66%, then the paper's attribution of the gain to RL training is contradicted.

Watch

Extended reading notes

Core claim

The paper's central claim is that reinforcement learning over a tool-augmented agent loop, rather than supervised imitation alone, is what makes LLM-based compiler auto-tuning work. The headline evidence is GRPO-7B reaching 8.46% average OverOz—the percentage IR instruction-count reduction relative to opt -Oz—across seven test suites, with a 96.71% task success rate, while the best SFT-only model reaches 4.66% after 40 inference attempts and the best traditional autotuner in the comparison reaches 6.09% but takes far longer. The authors attribute the result to the two-stage design: supervised fine-tuning provides a reliable thought–tool–answer protocol, and outcome-based RL lets the agent discover better sequences through trial and error. They further claim that neither stage alone suffices and that compact statistical features represent programs almost as well as raw LLVM IR for this task.

Load-bearing premise

The load-bearing assumption is that the instruction-count reductions come from the RL-trained agent's learned policy rather than from the embedded find_best_pass_sequence search tool, whose standalone performance is never reported even though the same guided search produced the SFT training labels.

Editorial extensions

If this is right

  • GRPO-7B achieves an average 8.46% IR instruction-count reduction over opt -Oz across the seven evaluated suites in about 26 seconds per program.
  • RL-trained interactive agents outperform supervised-only direct predictors (best 4.66% at 40 attempts) with a single environment-driven trajectory, indicating that feedback matters more than brute-force sampling.
  • Compiler-R1 matches or beats traditional autotuners in optimization quality while using a fraction of their wall-clock time, making it a candidate for practical deployment.
  • The two-stage SFT-then-RL design is necessary: ablations show neither SFT alone nor RL alone yields reliable interaction or competitive performance.
  • Compact statistical program features perform about as well as raw LLVM IR as model input, so the approach can run under tight context limits.

Reading between the lines

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

  • The paper does not measure how good find_best_pass_sequence is on its own; since the same guided search produced the SFT labels and stays available during RL and evaluation, a direct head-to-head would settle whether the RL policy adds optimization skill or simply learns when to call a strong oracle.
  • The reward is based on IR instruction count rather than wall-clock runtime, so the reported reductions may not translate one-to-one into faster executable code; an end-to-end hardware benchmark would test that translation.
  • All candidate sequences originate from the synergy-graph random walks, so the agent's discoveries are bounded by that search landscape; comparing RL-found sequences against graph-generated candidates would show whether genuinely new pass interactions are being learned.
  • The same tool-augmented RL recipe could carry over to other compiler objectives such as code size, compile time, or energy, and to any optimization domain with a cheap verifier; that would be a natural next test of generality.
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

3 major / 4 minor

Summary. Compiler-R1 proposes a two-stage supervised fine-tuning (SFT) plus reinforcement learning (RL) framework for LLM-based compiler auto-tuning. The authors construct a reasoning dataset by using a graph-guided search to select optimal pass sequences, then train Qwen2.5 models to interact with two tools: instrcount and find_best_pass_sequence (FBPS). On seven benchmark suites, the GRPO-7B variant is reported to achieve an average 8.46% IR instruction count reduction over opt -Oz, outperforming SFT-only models and several traditional autotuners. The paper argues that RL enables the agent to learn pass interactions and generalize to unseen programs; however, the agent is allowed to invoke FBPS, the same search tool used to generate the SFT labels, and no standalone tool baseline is reported.

Significance. If the attribution were established, this would be a useful contribution: it combines LLM reasoning with compiler-environment tools and demonstrates an end-to-end RL pipeline with public code and datasets, deterministic evaluation protocols, and several ablations. The two-stage SFT+RL design and the outcome-based reward are sensible. The significance is currently contingent, however, because the experiments do not separate what the learned policy contributes from what the FBPS search tool contributes; the headline 8.46% figure may be largely a property of the tool rather than of RL-trained LLM reasoning.

major comments (3)
  1. [§3.2.1, §4.3, Appendix D] The agent is instructed to call find_best_pass_sequence whenever the initial candidate sequence gives OverOz ≤ 0, and this tool is the same graph-guided search used in §3.1 to generate PassSeqopt(P). The paper never reports what find_best_pass_sequence alone achieves on the 335 test programs. Section 4.3 explicitly states that GRPO-3B obtains 5.12% OverOz by directly invoking find_best_pass_sequence and bypassing instrcount, which shows that the tool alone can produce strong results. Without a tool-only baseline and a per-answer provenance breakdown, the 8.46% improvement in Table 1 cannot be attributed to RL-trained LLM reasoning.
  2. [§3.1, §3.2.2, §4.2] The SFT labels are the output of the same graph-guided search that the agent may invoke during RL and evaluation, so the model can succeed by reproducing the tool's output verbatim without learning any pass interaction. The paper does not report the fraction of final answers that are tool-returned sequences, nor does it ablate tool availability. I request an experiment that disables find_best_pass_sequence during RL/evaluation, or alternatively a separate measurement of the policy's self-generated sequences, to show that RL improves the policy beyond imitating the search tool.
  3. [Table 1, Table 2] Table 2 reports success rates for two repetition penalties, and GRPO-7B's success rate changes from 51.92% at penalty 1.05 to 96.71% at penalty 1.10. The paper does not state which repetition penalty and other hyperparameters are used for the headline GRPO-7B result in Table 1, making the main result non-reproducible as written. This configuration must be specified.
minor comments (4)
  1. [§4.5] The text says 'average OverOrig gain of 8.46%,' but Table 1 and Eq. (2) define the 8.46% figure as OverOz; OverOrig is defined in Eq. (4) relative to the original unoptimized program, not to -Oz. Please correct the terminology.
  2. [§3.1] Equation (1) uses Apply(P, B) and Apply(P, A, B) without defining the order of application for the pair; the surrounding text explains that A is applied before B, but the notation should be made explicit in the equation or its caption.
  3. [§4.3] The observation that GRPO-3B 'circumvents protocol checks' by directly invoking find_best_pass_sequence is important and should be quantified: report how often each model's final answer comes from FBPS rather than from a self-generated sequence.
  4. [§4.4, Table 3] The table label 'Avg. Max OverOrig' is not defined; the text describes 'reporting the best OverOrig among them,' so please clarify whether the table reports the mean over test programs of the maximum over N samples.

Circularity Check

2 steps flagged · score 6.0 of 10

Tool confound: FBPS can supply the final answer verbatim, and FBPS is the same graph-guided search that generated the SFT labels; no tool-only baseline or provenance split is reported.

  1. fitted input called prediction [Sec. 3.1 (Graph-Guided Optimal Sequence Selection) and Sec. 3.2.1 (Training Prompt)]
    "The sequence maximizing OverOz is selected as the optimal pass sequence PassSeqopt(P ). ... The derived PassSeqopt(P ) for each program then serves as the target solution used to construct the Simulated LLM Thought and Action Trajectory for the SFT stage ... If the initial sequence does not provide a positive improvement (improvement_over_oz <= 0 ), use the find_best_pass_sequence tool to search for a better sequence. If the search finds a sequence with positive improvement (improvement_percentage > 0 ), recommend that sequence."

    The SFT 'gold' sequence PassSeq_opt(P) is selected by graph-guided search; that same search is exposed to the agent as find_best_pass_sequence, and the evaluation prompt instructs the agent to recommend the tool's output verbatim whenever it reports positive improvement. Therefore a final answer—and hence the measured OverOz—can equal the output of the very procedure that generated the SFT labels. Because no tool-only baseline or provenance breakdown is reported, the reported 8.46% 'RL' improvement may be a re-reporting of the search tool's own result rather than an independent LLM prediction.

  2. other [Sec. 4.3 (Experiment 2: Task Success Rate and Interaction Efficiency)]
    "GRPO-3B occasionally circumvents protocol checks (e.g., instrcount validation) by directly invoking find_best_pass_sequence. While this results in protocol violations and lower success scores, it can still yield high OverOz if effective sequences are discovered."

    This passage is the paper's own evidence that a policy can obtain high OverOz by a single direct call to FBPS, bypassing instrcount validation. Since FBPS is the same graph-guided search used to construct PassSeq_opt for the SFT labels, the evaluation score for such trajectories is the tool's output, not a learned pass-selection policy. The headline number therefore conflates tool search with RL-learned reasoning; the central attribution is not supported without separating tool-returned answers.

full rationale

Compiler-R1 is not wholly circular: the agent must still decide when to call find_best_pass_sequence, format tool calls, and some trajectories may produce self-generated sequences; the comparisons against SFT-only models and traditional autotuners are external. However, the evaluation protocol explicitly allows the final answer to be a verbatim FBPS output, and FBPS is the same graph-guided search that produced the SFT gold sequences. The paper never reports a tool-only baseline and does not separate tool-returned from self-generated answers. Its own Section 4.3 shows a policy can score 5.12% OverOz by directly invoking FBPS, bypassing instrcount validation. Thus the headline 8.46% figure is not an independent test of RL-learned pass reasoning; it can reduce, by construction, to re-emitting the search tool's result. The CFSAT self-citation [24] supplies the guided-search workflow, but the determinative issue here is the tool's availability at evaluation, not the citation itself. Score 6 reflects partial circularity: the central attribution to 'RL-trained LLMs' is compromised, though the framework retains some independent content in protocol learning and formatting.

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

The framework's central claim rests on the tool's search capability not being the actual source of improvement, and on the sufficiency of AutoPhase features and instruction count as optimization signals. The reward design and dataset generation rely on heuristics whose quality is not independently validated.

free parameters (4)
  • reward weights wf and wa = unspecified
    Composite reward R_final = wf*R_format + wa*R_answer; values not reported in text, but they control the RL training.
  • scaling factor alpha = unspecified
    In R_answer = alpha * OverOrig, alpha scales the reward; value not given.
  • repetition penalty = 1.05, 1.10
    Table 2 shows success rate depends strongly on repetition penalty; GRPO-7B jumps from 51.92% at 1.05 to 96.71% at 1.10. The main result likely uses a favorable setting.
  • number of candidate sequences per program = 100
    In Section 3.1, 100 candidate sequences are generated via random walks; the best is selected as optimal. This choice affects the quality of SFT labels.
assumptions (4)
  • domain assumption AutoPhase 56 statistical features are a sufficient representation of LLVM IR for pass sequence prediction.
    Section 3.1 and Experiment 3 test this, but the RL framework uses these features as the sole input to the agent.
  • domain assumption IR instruction count reduction is a valid proxy for compiler optimization quality.
    The objective and evaluation use instruction count, not runtime or code size. This is stated in Section 1 as the typical objective.
  • domain assumption The synergy graph built from training programs generalizes to test programs.
    Global Synergy Graph is constructed from training data and used to generate candidate sequences. The paper assumes these interactions transfer, but doesn't validate on test set.
  • domain assumption The find_best_pass_sequence tool returns high-quality sequences via guided search.
    The tool is used both in SFT simulation and in RL. Its implementation is not detailed; its performance is not benchmarked alone.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Compiler-R1: Towards Agentic Compiler Auto-tuning with Reinforcement Learning." pith.science (2026). https://pith.science/paper/EABVSKOY

@misc{pith2026250615701,
  author       = {Pith},
  title        = {Pith review of: Compiler-R1: Towards Agentic Compiler Auto-tuning with Reinforcement Learning},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/EABVSKOY}},
  note         = {Machine review of arXiv:2506.15701}
}
read the original abstract

Compiler auto-tuning optimizes pass sequences to improve performance metrics such as Intermediate Representation (IR) instruction count. Although recent advances leveraging Large Language Models (LLMs) have shown promise in automating compiler tuning, two significant challenges still remain: the absence of high-quality reasoning datasets for agents training, and limited effective interactions with the compilation environment. In this work, we introduce Compiler-R1, the first reinforcement learning (RL)-driven framework specifically augmenting LLM capabilities for compiler auto-tuning. Compiler-R1 features a curated, high-quality reasoning dataset and a novel two-stage end-to-end RL training pipeline, enabling efficient environment exploration and learning through an outcome-based reward. Extensive experiments across seven datasets demonstrate Compiler-R1 achieving an average 8.46% IR instruction count reduction compared to opt -Oz, showcasing the strong potential of RL-trained LLMs for compiler optimization. Our code and datasets are publicly available at https://github.com/Panhaolin2001/Compiler-R1.

Figures

Figures reproduced from arXiv: 2506.15701 by the authors.

Figure 1
Figure 1. Overview of compiler auto-tuning task. Compiler auto-tuning [2, 5, 6] focus on automat￾ically select and order compilation passes, modu￾lar optimization or analysis steps in modern com￾pilers like LLVM [20], to improve program per￾formance. A typical tuning objective is reducing the Intermediate Representation (IR) instruction count while preserving program correctness, as depicted in [PITH_FULL_IMAGE:figures/full_… view at source ↗
Figure 2
Figure 2. Compiler-R1: A two-stage LLM training framework for compiler auto-tuning. [PITH_FULL_IMAGE:figures/full_fig_p003_2.png] view at source ↗
Figure 3
Figure 3. Average OverOz% of SFT-only models vs. N attempts. Dashed: GRPO Ref. 4.4 Experiment 3: Input Representation - AutoPhase vs. Raw LLVM IR This experiment evaluates the impact of input representation on the effectiveness of compiler pass sequence prediction. Specifically, we compare AutoPhase features against raw LLVM IR as inputs to SFT models based on Qwen-1.5B, using OverOrig as the evaluation metric. Two Qwen-1.5B … view at source ↗

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

29 extracted references · 22 canonical work pages

  1. [1]

    Opentuner: An extensible framework for program autotuning

    Jason Ansel, Shoaib Kamil, Kalyan Veeramachaneni, Jonathan Ragan-Kelley, Jeffrey Bosboom, Una-May O’Reilly, and Saman Amarasinghe. Opentuner: An extensible framework for program autotuning. In Proceedings of the 23rd international conference on Parallel architectures and compilation, pages 303–316, 2014

    work page 2014

  2. [2]

    A survey on compiler autotuning using machine learning

    Amir H Ashouri, William Killian, John Cavazos, Gianluca Palermo, and Cristina Silvano. A survey on compiler autotuning using machine learning. ACM Computing Surveys (CSUR) , 51(5):1–42, 2018

    work page 2018

  3. [3]

    The nas parallel benchmarks

    David H Bailey, Eric Barszcz, John T Barton, David S Browning, Robert L Carter, Leonardo Dagum, Rod A Fatoohi, Paul O Frederickson, Thomas A Lasinski, Rob S Schreiber, et al. The nas parallel benchmarks. The International Journal of Supercomputing Applications , 5(3):63–73, 1991

    work page 1991

  4. [4]

    Algorithms for hyper- parameter optimization

    James Bergstra, Rémi Bardenet, Yoshua Bengio, and Balázs Kégl. Algorithms for hyper- parameter optimization. Advances in neural information processing systems, 24, 2011

    work page 2011

  5. [5]

    Iterative compilation in a non-linear optimisation space

    François Bodin, Toru Kisuki, Peter Knijnenburg, Mike O’Boyle, and Erven Rohou. Iterative compilation in a non-linear optimisation space. In Workshop on profile and feedback-directed compilation, 1998

    work page 1998

  6. [6]

    Efficient compiler autotuning via bayesian optimization

    Junjie Chen, Ningxin Xu, Peiqi Chen, and Hongyu Zhang. Efficient compiler autotuning via bayesian optimization. In 2021 IEEE/ACM 43rd International Conference on Software Engineering (ICSE), pages 1198–1209. IEEE, 2021

    work page 2021

  7. [7]

    Deconstructing iterative optimization

    Yang Chen, Shuangde Fang, Yuanjie Huang, Lieven Eeckhout, Grigori Fursin, Olivier Temam, and Chengyong Wu. Deconstructing iterative optimization. ACM Transactions on Architecture and Code Optimization (TACO), 9(3):1–30, 2012

    work page 2012

  8. [8]

    Large language models for compiler optimization

    Chris Cummins, V olker Seeker, Dejan Grubisic, Mostafa Elhoushi, Youwei Liang, Baptiste Roziere, Jonas Gehring, Fabian Gloeckle, Kim Hazelwood, Gabriel Synnaeve, et al. Large language models for compiler optimization. arXiv preprint arXiv:2309.07062, 2023

    arXiv 2023

Show all 29 references
  1. [9]

    Meta large language model compiler: Foundation models of compiler optimization

    Chris Cummins, V olker Seeker, Dejan Grubisic, Baptiste Roziere, Jonas Gehring, Gabriel Synnaeve, and Hugh Leather. Meta large language model compiler: Foundation models of compiler optimization. arXiv preprint arXiv:2407.02524, 2024

    2024 arXiv

  2. [10]

    Compilergym: Robust, performant compiler optimization environments for ai research

    Chris Cummins, Bram Wasti, Jiadong Guo, Brandon Cui, Jason Ansel, Sahir Gomez, Somya Jain, Jia Liu, Olivier Teytaud, Benoit Steiner, et al. Compilergym: Robust, performant compiler optimization environments for ai research. In 2022 IEEE/ACM International Symposium on Code Gene...

    2022

  3. [11]

    DeepSeek-AI DeepSeek-AI, Daya Guo, Dejian Yang, Haowei Zhang, Junxiao Song, Ruoyu Zhang, Runxin Xu, Qihao Zhu, Shirong Ma, Peiyi Wang, Xiao Bi, Xiaokang Zhang, Xingkai Yu, Yu Wu, Z.F. Wu, Zhibin Gou, Zhihong Shao, Zhuoshu Li, Ziyi Gao, Aixin Liu, Bing Xue, Bingxuan Wang, Bocha...

    2025

  4. [12]

    Collective tuning initiative: automating and accelerating development and optimization of computing systems

    Grigori Fursin. Collective tuning initiative: automating and accelerating development and optimization of computing systems. In GCC Developers’ Summit, 2009

    2009

  5. [13]

    Evolutionary optimization of compiler flag selection by learning and exploiting flags interactions

    Unai Garciarena and Roberto Santana. Evolutionary optimization of compiler flag selection by learning and exploiting flags interactions. In Proceedings of the 2016 on Genetic and Evolutionary Computation Conference Companion, pages 1159–1166, 2016

    2016

  6. [14]

    Mibench: A free, commercially representative embedded benchmark suite

    Matthew R Guthaus, Jeffrey S Ringenberg, Dan Ernst, Todd M Austin, Trevor Mudge, and Richard B Brown. Mibench: A free, commercially representative embedded benchmark suite. In Proceedings of the fourth annual IEEE international workshop on workload characterization. WWC-4 (Cat...

    2001

  7. [15]

    Autophase: Juggling hls phase orderings in random forests with deep reinforcement learning

    Ameer Haj-Ali, Qijing Jenny Huang, John Xiang, William Moses, Krste Asanovic, John Wawrzynek, and Ion Stoica. Autophase: Juggling hls phase orderings in random forests with deep reinforcement learning. Proceedings of Machine Learning and Systems, 2:70–81, 2020

    2020

  8. [16]

    Chstone: A benchmark program suite for practical c-based high-level synthesis

    Yuko Hara, Hiroyuki Tomiyama, Shinya Honda, Hiroaki Takada, and Katsuya Ishii. Chstone: A benchmark program suite for practical c-based high-level synthesis. In 2008 IEEE International Symposium on Circuits and Systems (ISCAS), pages 1192–1195. IEEE, 2008

    2008

  9. [17]

    Finding missed code size optimizations in compilers using llms

    Davide Italiano and Chris Cummins. Finding missed code size optimizations in compilers using llms. arXiv preprint arXiv:2501.00655, 2024

    2024 arXiv

  10. [18]

    Openai o1 system card

    Aaron Jaech, Adam Kalai, Adam Lerer, Adam Richardson, Ahmed El-Kishky, Aiden Low, Alec Helyar, Aleksander Madry, Alex Beutel, Alex Carney, et al. Openai o1 system card. arXiv preprint arXiv:2412.16720, 2024

    2024 arXiv

  11. [19]

    Search-r1: Training llms to reason and leverage search engines with reinforcement learning, 2025

    Bowen Jin, Hansi Zeng, Zhenrui Yue, Jinsung Yoon, Sercan Arik, Dong Wang, Hamed Za- mani, and Jiawei Han. Search-r1: Training llms to reason and leverage search engines with reinforcement learning, 2025

    2025

  12. [20]

    Llvm: A compilation framework for lifelong program analysis & transformation

    Chris Lattner and Vikram Adve. Llvm: A compilation framework for lifelong program analysis & transformation. In International symposium on code generation and optimization, 2004. CGO 2004., pages 75–86. IEEE, 2004

    2004

  13. [21]

    Learning compiler pass orders using coreset and normalized value prediction

    Youwei Liang, Kevin Stone, Ali Shameli, Chris Cummins, Mostafa Elhoushi, Jiadong Guo, Benoit Steiner, Xiaomeng Yang, Pengtao Xie, Hugh James Leather, et al. Learning compiler pass orders using coreset and normalized value prediction. In International Conference on Machine Lear...

    2023

  14. [22]

    Code-r1: Reproducing r1 for code with reliable rewards

    Jiawei Liu and Lingming Zhang. Code-r1: Reproducing r1 for code with reliable rewards. 2025

    2025

  15. [23]

    Ui-r1: Enhancing action prediction of gui agents by reinforcement learning, 2025

    Zhengxi Lu, Yuxiang Chai, Yaxuan Guo, Xi Yin, Liang Liu, Hao Wang, Han Xiao, Shuai Ren, Guanjing Xiong, and Hongsheng Li. Ui-r1: Enhancing action prediction of gui agents by reinforcement learning, 2025. 11

    2025

  16. [24]

    Towards efficient compiler auto-tuning: Leveraging synergistic search spaces

    Haolin Pan, Yuanyu Wei, Mingjie Xing, Yanjun Wu, and Chen Zhao. Towards efficient compiler auto-tuning: Leveraging synergistic search spaces. In Proceedings of the 23rd ACM/IEEE International Symposium on Code Generation and Optimization, pages 614–627, 2025

    2025

  17. [25]

    Proximal policy optimization algorithms

    John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. arXiv preprint arXiv:1707.06347, 2017

    2017 arXiv

  18. [26]

    Deepseekmath: Pushing the limits of mathematical reasoning in open language models

    Zhihong Shao, Peiyi Wang, Qihao Zhu, Runxin Xu, Junxiao Song, Mingchuan Zhang, YK Li, Y Wu, and Daya Guo. Deepseekmath: Pushing the limits of mathematical reasoning in open language models

  19. [27]

    Logic-rl: Unleashing llm reasoning with rule-based reinforcement learning, 2025

    Tian Xie, Zitian Gao, Qingnan Ren, Haoming Luo, Yuqian Hong, Bryan Dai, Joey Zhou, Kai Qiu, Zhirong Wu, and Chong Luo. Logic-rl: Unleashing llm reasoning with rule-based reinforcement learning, 2025

    2025

  20. [28]

    Sample efficient reinforce- ment learning with reinforce

    Junzi Zhang, Jongho Kim, Brendan O’Donoghue, and Stephen Boyd. Sample efficient reinforce- ment learning with reinforce. In Proceedings of the AAAI conference on artificial intelligence, volume 35, pages 10887–10895, 2021

    2021

  21. [29]

    - - dse

    Mingxuan Zhu, Dan Hao, and Junjie Chen. Compiler autotuning through multiple-phase learning. ACM Transactions on Software Engineering and Methodology, 33(4):1–38, 2024. 12 Appendix A AutoPhase Feature Set As referenced in Feature Extraction and Representation, our framework ut...

    2024

Pith tools

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