# On Designing Effective RL Reward at Training Time for LLM Reasoning
footnotetext: Equal Contribution footnotetext: Corresponding Author
Abstract
Reward models have been increasingly critical for improving the reasoning capability of LLMs. Existing research has shown that a well-trained reward model can substantially improve model performances at inference time via search or best-of-N votes. However, the potential of reward models during RL training time still remains largely under-explored. It is currently unclear whether these reward models can provide additional training signals to RL training that uses sparse success rewards, which verify the correctness of solutions. In this work, we evaluate popular reward models for RL training, including the Outcome-supervised Reward Model (ORM) and the Process-supervised Reward Model (PRM), and train a collection of LLMs for math problems using RL by combining these learned rewards with success rewards. Surprisingly, even though these learned reward models have strong inference-time performances, they may NOT help or even hurt RL training, producing worse performances than LLMs trained with the success reward only. Our analysis reveals that an LLM can receive high rewards from some of these reward models by repeating correct but unnecessary reasoning steps, leading to a severe reward hacking issue for RL training. Therefore, we introduce two novel reward refinement techniques, including Clipping and Delta. The key idea is to ensure the accumulative reward of any reasoning trajectory is upper-bounded to keep a learned reward model effective without being exploited. We evaluate our techniques with multiple reward models over a set of 1.5B and 7B LLMs on MATH and GSM8K benchmarks, where both Clipping and Delta consistently stabilize RL training. Finally, we also demonstrate that with a carefully designed reward function, pure RL training without any additional supervised tuning can further improve all the evaluated LLMs, including the state-of-the-art 7B LLM Qwen2.5-Math-7B-Instruct on MATH and GSM8K benchmarks.
1 Introduction
There is a recent trend to improve the reasoning ability of LLMs with learned reward models (Lightman et al., 2024; Wang et al., 2024b; Yu et al., 2024a; Zhang et al., 2024; Lee et al., 2024; Yang et al., 2024b; Luo et al., 2024; Chen et al., 2024c; Havrilla et al., 2024; Shao et al., 2024; Uesato et al., 2022). Recent research has been focusing on guiding search processes during inference (Lightman et al., 2024; Snell et al., 2024; Wang et al., 2024b), with two main categories of reward models: Outcome-supervised Reward Model (ORM) (Cobbe et al., 2021b; Yu et al., 2024a) and Process-supervised Reward Model (PRM) (Lightman et al., 2024; Wang et al., 2024b; Luo et al., 2024). ORM generates outcome rewards that estimate the success rewards, which evaluate the correctness of generated answers, enabling the selection of the most reliable answer from a pool of generated candidates. By contrast, PRM is trained to distinguish correct reasoning steps from incorrect ones and can provide step-level process rewards for search algorithms like Monte-Carlo Tree Search (Chen et al., 2024a) and beam search (Snell et al., 2024).
However, the potential of reward models in RL training for LLM reasoning is not yet fully explored. The most straightforward method for RL training in reasoning tasks is to optimize the success rewards. Some prior works further try the integration of a reward model into RL training (Havrilla et al., 2024; Wang et al., 2024b; Shao et al., 2024). Havrilla et al. (2024) finds that PPO training with a reward model only results in performance degeneration. In addition, some powerful LLMs that exhibit strong reasoning abilities such as the Qwen2.5-Math family (Yang et al., 2024b) and DeepseekMath-7B-RL (Shao et al., 2024) adopt RL training with reward models as a part of their overall training process for mathematical reasoning. However, due to a lack of detailed analysis on the reward models, it remains unclear whether the reward models can provide additional training signals beyond what the success rewards offer for LLM reasoning.
In this work, we evaluate popular reward models, including ORM and PRM, as RL rewards on the challenging mathematical reasoning benchmark MATH (Hendrycks et al., 2021) and GSM8K (Cobbe et al., 2021a) by using PPO as the RL algorithm (Schulman et al., 2017). Surprisingly, we find that these reward models may not enhance RL training or even lead to performance degradation, yielding even worse results than LLMs trained with a sparse success reward only. We observe that outcome rewards consistently achieve similar training results as success rewards. We hypothesize that outcome rewards may not be beneficial at training time since a more accurate success reward is accessible. For PRM, we perform an in-depth analysis of the RL training process and identify a severe reward hacking issue (Casper et al., 2023; Rame et al., 2024; Singhal et al., 2023). Reward hacking manifests in the form of generating numerous correct but unnecessary reasoning steps. Through RL training, an LLM could exploit the PRM to achieve an excessively high by repeated generating simple reasoning steps that may not contribute to solving the problem, leading to a completely undesirable LLM behavior with poor reasoning accuracy.
To tackle these challenges, we propose two novel techniques, i.e., Clip and Delta, which refines the process rewards for effective RL training. In particular, the Clip mechanism bounds rewards to an upper threshold so that RL training can focus on reducing erroneous reasoning steps. The Delta mechanism maintains a bounded objective by subtracting the rewards between two adjacent steps, discouraging trivial repetition patterns to achieve a high return and improving training stability. Evaluation of these two techniques on synthetic reasoning trajectories demonstrates that they can mitigate the reward hacking issue consistently. Finally, we conduct full RL training on a set of advanced 1.5B and 7B LLMs from the Qwen2 and Qwen2.5 families (Yang et al., 2024a; b) with different reward models. Our experiment results show that our proposed techniques effectively stabilize RL training. Moreover, with a carefully crafted reward, RL training can improve all the evaluated LLMs, including the state-of-the-art 7B LLM Qwen2.5-Math-7B-Instruct on the challenging MATH and GSM8K (Hendrycks et al., 2021; Cobbe et al., 2021a) benchmarks.
2 Related Work
Reinforcement Learning for LLMs. In RLHF, Reinforcement learning algorithms can effectively fine-tune LLMs to align with the preference of humans (Dong et al., 2023; Rafailov et al., 2024; Ouyang et al., 2022; Xu et al., 2024; Schulman et al., 2017), to improve the reasoning ability (Shao et al., 2024; Yang et al., 2024b) and coding skills (Wang et al., 2024a; Guo et al., 2024). PPO is the most widely used among the popular RL algorithms due to its robust performance across various domains (Ouyang et al., 2022; Xu et al., 2024). Xu et al. (2024) investigates the implementation details of PPO for dialogue tasks and coding tasks, revealing batch size as a critical factor for improving PPO performance in reinforcement learning from human feedback (RLHF). Our work addresses the challenge of designing RL rewards for LLM reasoning.
Reward Learning for LLMs. Learned reward models are widely adopted in RLHF to align LLMs with human preferences (Dong et al., 2023; Rafailov et al., 2024; Ouyang et al., 2022). In RLHF, reward models are trained on binary preference datasets collected from human annotators, following the Bradley-Terry model (Bradley & Terry, 1952). In reasoning tasks involving reliable solution checkers, two main approaches are the Outcome-supervised Reward Model (ORM) (Cobbe et al., 2021b; Yu et al., 2024a) and the Process-supervised Reward Model (PRM) (Lightman et al., 2024; Wang et al., 2024b; Luo et al., 2024). An ORM predicts the likelihood that the final answer of a solution prefix would be correct. A PRM estimates whether the steps so far are correct for each reasoning step. Through training over extensive corpora, reward models are able to evaluate solution quality. Despite the successful applications of reward models, reward hacking is a broadly observed issue in learned reward models (Skalse et al., 2022; Singhal et al., 2023; Casper et al., 2023). Through RL training, the LLM may learn to generate high-reward outputs that could not fulfill the intended objectives. Several approaches have been proposed to tackle the reward hacking issue, including disentangling the length aspect of reward modeling (Chen et al., 2024b; Shen et al., 2023), reward ensemble (Eisenstein et al., 2024; Rame et al., 2024), length penalty (Singhal et al., 2023), length normalization (Meng et al., 2024), and various PPO implementation tricks (Singhal et al., 2023; Zheng et al., 2023). In this work, we investigate the reward hacking issue for reasoning tasks when combining learned rewards and success rewards in RL training.
Improving Reasoning Ability of LLMs. To improve the reasoning ability of LLMs, prior works have focused on several different aspects, including pre-training (Yang et al., 2024b; Achiam et al., 2023; Anil et al., 2023), prompting (Han et al., 2024; Yuan et al., 2024; Wu et al., 2024), search during inference-time (Lightman et al., 2024; Wang et al., 2024b; Yu et al., 2024a; Zhang et al., 2024; Yang et al., 2024b; Luo et al., 2024; Chen et al., 2024c), and fine-tuning (Wang et al., 2024b; Shao et al., 2024; Yang et al., 2024b; Shah et al., 2024; Tang et al., 2024; Yu et al., 2024b). Pre-training methods focus on enriching the data distribution to cover a large amount of rationals and pre-training the LLM over the dataset. The prompting methods elicit the reasoning ability of LLMs through dedicated prompting strategies and automatic agent frameworks. Inference-time search utilizes learned reward models to guide the selection of promising solutions. PRM and ORM could be combined with different search strategies such as Best-of-N, Monte-Carlo Tree Search (Chen et al., 2024a), and Beam Search (Snell et al., 2024). Finally, fine-tuning methods include training the LLM on high-quality question-answer data (Yu et al., 2024b; Shah et al., 2024; Yue et al., 2024) and optimizing the reasoning ability with reinforcement learning (Yang et al., 2024b; Shao et al., 2024; Wang et al., 2024b). In this work, we study how to effectively combine dense and sparse rewards in RL training for reasoning tasks.
3 Preliminary
Language Model. An LLM is represented as a policy $\pi_{\theta}(s|q)$ parameterized by $\theta$ . In reasoning tasks, $\pi_{\theta}$ generates a solution $s$ given a question $q$ . In addition to the question, $q$ usually also contains a prompt to elicit chain-of-thought reasoning. The solution $s$ is structured with a list of reasoning steps and thus can be viewed from two perspectives, including tokens and steps. From the perspective of tokens, $s$ consists of $T$ tokens, $s=(s_{1},s_{2},·s,s_{T})$ . From the perspective of steps, $s$ consists of $K$ reasoning steps, $s=(s^{(1)},s^{(2)},·s,s^{(K)})$ where $s^{(k)}$ denotes the $k$ -th reasoning step. For convenience, we use $p^{(k)}=(s^{(1)},s^{(2)},·s,s^{(k)})$ to denote the solution prefix up to the $k$ -th step. In practice, reasoning steps can be parsed with rule-based detectors, enforcing strict output formats, or special tokens (Chen et al., 2024a; Wang et al., 2024b; Lightman et al., 2024).
Reward Modeling. In RLHF, the reward models are usually trained with binary preferences (Bradley & Terry, 1952). In reasoning tasks where the correctness of solutions is accessible, reward models can be trained under the supervision of such ground-truth correctness. In reasoning tasks, two primary methods for reward modeling are the Process-supervised Reward Model (PRM) and the Outcome-supervised Reward Model(ORM).
Given a question $q$ and a prefix $s_{1:t}$ , an ORM estimates the likelihood the prefix would lead to a correct answer. A standard approach to train an ORM is by first sampling solutions for questions from a dataset with an LLM and then labeling the correctness of each solution. The ORM $r_{\text{outcome}}$ is then trained with the following objective,
| | $\displaystyle\mathcal{L}_{\text{ORM}}=\mathbb{E}_{q,s\sim\mathcal{D}}\left[%
\sum_{t=1}^{T}\text{Loss}(\text{Correct}(q,s),r_{\text{outcome}}(q,s_{1:t}))\right]$ | |
| --- | --- | --- |
where $\text{Correct}(q,s)$ is a binary value indicating the correctness of solution $s$ , $t$ enumerates each token of the solution $s$ , and Loss denotes the loss function. In practice, the loss function could be binary cross-entropy loss or square-error loss, and we can choose to train ORM on the full sequence or only the last token.
In contrast, Process-supervised Reward Model (PRM) estimates the correctness of individual reasoning steps. PRM is trained with the following objective,
| | $\displaystyle\mathcal{L}_{\text{PRM}}=\mathbb{E}_{q,p^{(k)},y_{k}\sim\mathcal{%
D}}\left[\text{Loss}(y_{k},r_{\text{process}}(q,p^{(k)}))\right]$ | |
| --- | --- | --- |
where $y_{k}$ is the label for the partial solution $p^{(k)}$ and Loss is the loss function. In practice, binary cross entropy loss is usually adopted. Prior works have investigated several ways to annotate the process labels, including human annotators (Lightman et al., 2024) and automatic annotation with LLMs (Wang et al., 2024b; Luo et al., 2024).
Reinforcement Learning for LLM Reasoning. We assume access to the correctness of a solution during training. We use $\text{Correct}(q,s)$ to indicate the correctness of solution $s$ to question $q$ , which is also referred to as the success reward for RL training. An LLM can be fine-tuned to optimize the success reward by using Reinforcement Learning with Kullback-Leibler divergence,
$$
\displaystyle J_{r}(\pi_{\theta})=\mathbb{E}_{q\sim\mathcal{D},s\sim\pi_{%
\theta}}\left[\text{Correct}(q,s)-\beta\log\frac{\pi_{\theta}(s|q)}{\pi_{ref}(%
s|q)}\right] \tag{1}
$$
where $\pi_{ref}$ is the reference model for regularizing $\pi_{\theta}$ . Optimizing the success reward only provides a sparse training signal because the reward is provided at the end of the sequence. Alternatively, we can also combine dense rewards with the success reward for more fine-grained training signals. The RL objective with dense rewards becomes,
$$
\displaystyle J_{r}(\pi_{\theta})=\mathbb{E}_{q\sim\mathcal{D},s\sim\pi_{%
\theta}}\left[\alpha\cdot\sum_{t=1}^{|s|}r(q,s_{1:t})+\text{Correct}(q,s)-%
\beta\log\frac{\pi_{\theta}(s|q)}{\pi_{ref}(s|q)}\right] \tag{2}
$$
where $r$ denotes the dense reward and $\alpha$ is a coefficient for the dense reward. For example, a PRM $r_{\text{process}}$ can provide dense feedback at the end of reasoning steps, formally represented as $r(q,p^{(k)})=r_{\text{process}}(q,p^{(k)})$ for any partial solution $p^{(k)}$ .
4 RL Reward for LLM Reasoning
In this section, we conduct a systematic study on reward design to aid LLM in learning better reasoning skills through RL training. We follow the RL objective with dense rewards in Eq. (2) and specifically focus on the effective design of dense rewards. As discussed in Sec. 3, the ground-truth correctness, $\text{Correct}(p,s)$ , serves to provide the sparse rewards, and the dense rewards could be provided by a reward model.
4.1 Evaluating RL Training with Learned Reward Models
We first consider two straightforward approaches to apply ORM and PRM to provide rewards in addition to success rewards for RL training. Formally, we consider the following rewards,
- Solution-Level Outcome Reward (OR): In the RL training process of Yang et al. (2024b), an ORM provides an estimation of correctness as reward shaping. Note that this is not the case for dense rewards since ORM only produces rewards at the end of the sequence. For a question $q$ and a solution $s$ ,
$$
\displaystyle r(q,s)=r_{\text{outcome}}(q,s) \tag{3}
$$
- Step-Level Process Reward (PR): A PRM can provide step-level feedback for RL training. For any solution prefix $p^{(k)}$ , dense rewards are the rewards outputted by a PRM,
$$
\displaystyle r(q,p^{(k)})=r_{\text{process}}(q,p^{(k)}) \tag{4}
$$
Experiment Setup.
We carry out our study on the challenging mathematical reasoning benchmark, MATH (Hendrycks et al., 2021). We use PPO as the RL algorithm and Qwen2-1.5B-Instruct (Yang et al., 2024a) as the base model. For ORM, we sample solutions with the base model and train ORM with binary cross-entropy loss. For PRM, we follow Wang et al. (2024b) to generate process labels with automatic annotation Implementation details can be found in Sec. 5. The ORM and PRM both use Qwen2-1.5B-Instruct as the base model.
Results.
Surprisingly, we find these reward functions may not benefit RL training, yielding even worse inference-time performances than LLMs trained with a sparse success reward only, as shown in Fig. LABEL:fig:or-pr. To further investigate the cause of performance degradation, Fig. LABEL:fig:length-of-orm-prm reports the change in the generation length and the number of reasoning steps during training. Combining an outcome reward and a success reward shows similar training statistics and evaluation accuracy to adopting a sparse success reward only. We hypothesize this is because a success reward is accessible during training time, and an outcome reward may not be able to provide additional information beyond the success reward. On the other hand, when using PRM for RL training, we observe a significant change in the generation length and the number of reasoning steps during RL training. Specifically, the generation length and the step count of PR both significantly increase.
<details>
<summary>extracted/6028969/Figures/case-study-pr.png Details</summary>
### Visual Description
## Text Analysis: Math Problem and Step Probabilities
### Overview
The image presents a math question and a list of steps, each associated with a probability value. It also includes information about the PPO algorithm used and the return value.
### Components/Axes
* **Question:** "What is the 10-th term in 1,3,9,15,25,35, ... ?"
* **Steps:** A list of steps involved in solving the problem, each with an associated probability.
* **Probabilities:** Numerical values (between 0.12 and 0.98) indicating the likelihood or confidence associated with each step.
* **Algorithm:** PPO w. Success Reward + PR
* **Return:** 146.42
### Detailed Analysis or ### Content Details
The image is divided into three sections:
1. **Question Section (Top):**
* Contains the title "Question" and the math problem itself.
2. **Step Section (Middle):**
* Lists the steps to solve the problem, each followed by a probability value in a green box.
* Step 1: Understand pattern. 0.98
* Step 2: Find known numbers. 0.97
* Step 3: Establish formula. 0.96
* Step 4: Plug numbers into formula. 0.94
* Step 5: Solve. 0.93
* ...
* Step 🧐. 0.20 (The emoji is a thinking face)
* Step ready. 0.12
* Step nothing. 0.13
* <EOS> (End of Sequence)
3. **Algorithm and Return Section (Bottom):**
* Specifies the algorithm used (PPO w. Success Reward + PR) and the return value (146.42).
### Key Observations
* The probabilities associated with the initial steps (1-5) are significantly higher than those of the later steps.
* The "Step 🧐" has a relatively low probability of 0.20.
* The "Step ready" and "Step nothing" have the lowest probabilities, 0.12 and 0.13 respectively.
* The return value is 146.42.
### Interpretation
The image likely represents the output of a reinforcement learning model (PPO) trained to solve math problems. The probabilities associated with each step could indicate the model's confidence in taking that step towards solving the problem. The high probabilities for the initial steps suggest that the model is good at understanding the problem and setting up the solution. The lower probabilities for the later steps might indicate difficulties in the final stages of solving the problem. The return value (146.42) represents the reward the model received for solving the problem.
</details>
Figure 3: Case study of PR. PRM provides rewards at the end of each step. Through RL training with PR (Eq. (4)), the LLM learns to generate many reasoning steps that do not contribute to problem-solving to achieve a high return.
Case Study for PR.
For PR, a case study of the generated samples reveals the occurrence of the reward hacking issue, that is, the LLM learns to obtain high rewards with some specific patterns without faithfully optimizing the ground-truth correctness through RL training. In the generated solutions of PR, there are many short reasoning steps, but these steps only contain unnecessary or meaningless information that does not contribute to problem-solving. As the generation length increases, the model outputs only a single word or even emoji.
Analysis for PR.
The rewards of unnecessary reasoning steps are positive and could even be large, as shown in the case study (Fig. 3). The LLM learns to exploit this phenomenon by generating more reasoning steps, resulting in a higher return. We further confirm the reward hacking behavior through some synthetic reasoning trajectories (Fig. LABEL:fig:synthetic-nonsense and Fig. LABEL:fig:synthetic-mid-step), where PR demonstrates extremely larger returns. This indicates that the PRM cannot effectively classify meaningless repetition as poor, which encourages the LLM to favor these unproductive steps. We observe two key properties when combining PR and the success reward for RL training,
- The LLM learns to identify reasoning steps that yield high rewards but do not contribute to problem-solving. Specifically, reasoning steps that contain meaningless or unnecessary information can gain high rewards.
- The RL objective can be optimized with simple patterns that do not improve the overall accuracy. For PR, infinitely high returns can be achieved by generating more unnecessary reasoning steps. However, the addition of unnecessary reasoning steps can not guide the LLM to improve accuracy.
Takeaways.
Here are two key takeaways regarding the impact of applying ORM and PRM in RL training,
- For ORM, it does not improve over the sparse success reward. We hypothesize this is because, when a success reward is available during training time, ORM does not provide additional supervision signal and should not be a preferred choice at RL training time.
- PRM would lead to a severe reward hacking issue during RL training due to repetition. Although PRM provides useful training signals, it is critical to prevent reward hacking.
4.2 Techniques for Mitigating Reward Hacking
<details>
<summary>extracted/6028969/Figures/mechanisms.png Details</summary>
### Visual Description
## Reward Clipping and Delta Mechanisms
### Overview
The image illustrates two different mechanisms for adjusting rewards in a process: a "Clip Mechanism" and a "Delta Mechanism." Each mechanism is depicted through a series of plots showing the original process reward, an intermediate stage, and the final adjusted reward. The image starts with a general reward distribution across steps and then shows how each mechanism modifies these rewards.
### Components/Axes
**Top Chart:**
* **Title:** Question q
* **X-axis:** Step
* **Y-axis:** Process Reward
* **Data Series:** Four states labeled s^(1), s^(2), s^(3), and s^(4) represented by blue striped bars.
**Clip Mechanism (Left Side):**
* **Top Chart:**
* **Y-axis:** Process Reward
* **X-axis:** Step
* **Horizontal Dashed Line:** Represents a clipping threshold, labeled as η.
* **Data Series:** Blue striped bars, with portions above the threshold colored green and portions below colored red.
* **Bottom Chart:**
* **Y-axis:** Clipped Reward
* **X-axis:** Step
* **Data Series:** Red bars representing the clipped rewards.
**Delta Mechanism (Right Side):**
* **Top Chart:**
* **Y-axis:** Process Reward
* **X-axis:** Step
* **Horizontal Dashed Line:** Represents a threshold.
* **Data Series:** Blue striped bars, with green upward arrows indicating positive delta adjustments and a red downward arrow indicating a negative delta adjustment. A bar with a purple "X" through it indicates a removal or significant reduction.
* **Bottom Chart:**
* **Y-axis:** Delta Reward
* **X-axis:** Step
* **Data Series:** Green upward arrows and a red downward arrow representing the delta rewards.
### Detailed Analysis
**Top Chart (Question q):**
* The initial reward distribution across the four steps shows varying levels of reward.
* s^(1): Reward value is approximately 0.7.
* s^(2): Reward value is approximately 0.2.
* s^(3): Reward value is approximately 0.4.
* s^(4): Reward value is approximately 0.8.
**Clip Mechanism:**
* **Top Chart:** The clipping threshold η is approximately at a reward level of 0.6.
* The first bar is colored green above the threshold and blue striped below.
* The second and fourth bars are colored red below the threshold and blue striped below.
* The third bar is colored green above the threshold and blue striped below.
* **Bottom Chart:** The clipped reward shows only negative rewards (red bars).
* The first bar has a reward value of approximately -0.6.
* The second bar has a reward value of approximately -0.2.
**Delta Mechanism:**
* **Top Chart:**
* The first step has a green upward arrow, indicating a positive delta.
* The second step has a red downward arrow, indicating a negative delta.
* The fourth step's bar is crossed out with a purple "X", indicating removal.
* **Bottom Chart:** The delta reward shows both positive and negative rewards.
* The first step has a green upward arrow, indicating a positive delta.
* The second step has a red downward arrow, indicating a negative delta.
* The third step has a green upward arrow, indicating a positive delta.
### Key Observations
* The Clip Mechanism truncates rewards based on a threshold, resulting in only negative rewards in the example shown.
* The Delta Mechanism adjusts rewards by adding or subtracting values, and can also remove rewards entirely.
* The initial reward distribution (Question q) serves as the basis for both mechanisms.
### Interpretation
The image illustrates two distinct approaches to reward shaping. The Clip Mechanism appears to penalize rewards exceeding a certain threshold, effectively discouraging actions that lead to those rewards. The Delta Mechanism, on the other hand, provides more granular control by allowing for both positive and negative adjustments to the rewards, potentially encouraging or discouraging specific actions. The removal of a reward in the Delta Mechanism suggests a more drastic intervention, possibly to prevent undesirable outcomes. The choice between these mechanisms depends on the specific goals of the reward shaping process.
</details>
Figure 6: The Clip mechanism and the Delta mechanism. The Clip mechanism subtracts the rewards with a suitable threshold $\eta$ and upper-bounds all rewards with zero (Eq. (5)). The Delta mechanism drops the last-step reward and computes the difference of rewards between two adjacent steps (Eq. (6)). These mechanisms can alleviate the reward hacking issue of PRM in RL training.
Since ORM does not provide dense feedback for RL training and may lack additional information beyond the success reward during training, PRM can be a more suitable source for dense rewards. However, as analyzed in Sec. 4.1, PRM may enable an LLM to achieve an excessively high return by repeating unnecessary reasoning steps. To maintain a bounded objective while leveraging the ability of PRM to promote better reasoning skills, we introduce two novel techniques designed to utilize PRM in RL training effectively,
- Clip mechanism. To prevent the LLM from exploiting the reward model by repetition, a straightforward idea is to upper-bound high rewards. Specifically, rewards $r_{\text{process}}$ are upper-bounded by a selected threshold $\eta$ . We further ensure the return of a trajectory is bounded by subtracting all rewards by $\eta$ . Formally, with a threshold $\eta$ ,
$$
\displaystyle r(q,p^{(k)})=\min(r_{\text{process}}(q,p^{(k)})-\eta,0) \tag{5}
$$
If a suitable $\eta$ is chosen, the majority of the reasoning steps would receive a reward of 0, and only steps with low $r_{\text{process}}$ would have a negative reward.
- Delta mechanism. Alternatively, Delta mechanism can effectively upper-bound the RL objective during training by subtracting the rewards between adjacent steps. For a solution, the reward for the last reasoning step is dropped since the success reward would be sufficient to provide guidance for the last reasoning step. Formally, for a solution prefix $p^{(k)}$ ,
$$
\displaystyle r(q,p^{(k)})=\begin{cases}r_{\text{process}}(q,p^{(k)})-r_{\text%
{process}}(q,p^{(k+1)})&\text{ if }k<K-1\\
r_{\text{process}}(q,p^{(k)})&\text{ if }k=K-1\\
0&\text{ if }k=K\end{cases} \tag{6}
$$
A nice property of the Delta mechanism is that it ensures the return of a solution is $\alpha· r_{\text{process}}(q,s^{(1)})+\text{Correct}(q,s)$ , which is bounded since the maximum output value of a PRM is $1$ . Furthermore, the return starting from any intermediate solution step $p^{(k)}$ is $\alpha· r_{\text{process}}(q,p^{(k)})+\text{Correct}(q,s)$ , which is unaffected by the process rewards of future steps. Further analysis is provided in Appendix. D.1.
Both the Clip and Delta mechanisms can be used individually or in combination. In practice, we consider three approaches incorporating these mechanisms:
1. Process Reward with Clip mechanism (PR-Clip): This applies the Clip mechanism.
1. Process Reward with Delta mechanism (PR-Delta): This employs the Delta mechanism.
1. Process Reward with Clip & Delta mechanism (PR-Clip-Delta): The Clip mechanism is applied first, followed by the Delta mechanism.
We further perform evaluation on synthetic solutions that exhibit repetitive patterns in different ways. As shown in Fig. LABEL:fig:synthetic-mid-step and Fig. LABEL:fig:synthetic-nonsense, the Clip mechanism and the Delta mechanism can both successfully limit the upper bound of the returns on these synthetic solutions. Additionally, the Clip mechanism imposes increasingly smaller returns as the length of the repetitive pattern grows.
Other Practices.
We also compare with some adopted practices to avoid reward hacking in prior works (Singhal et al., 2023), including length normalization and length penalty. More details can be found in Appendix D. Length normalization normalizes the rewards for each solution. Length penalty imposes a constant penalty for each step. As illustrated in Fig. LABEL:fig:synthetic, imposing length penalty and length normalization could still favor the undesired repetition modes over correct solutions. We also investigate standard normalization for PRM as employed by Shao et al. (2024), which we find would lead to training instability. More details can be found in Sec. 5.2.
5 Experiments
In this section, we perform full RL training with different reward designs to further examine how to ensure a learned reward model can be effective at training time. We will first illustrate our experiment setup in Sec. 5.1, then conduct ablation studies in Sec. 5.2 and finally present our main results on 1.5B&7B models in Sec. 5.3.
5.1 Experiment Setup
Training Dataset.
We conduct RL training on the MathInstruct (Yue et al., 2024) dataset. In particular, we only use the questions and the golden answers in the dataset while the provided solutions are not used for training. To constitute the reward training dataset, we use Qwen2-7B-Instruct to sample 16 answers for each question in the training dataset and keep those questions that have both correct and wrong answers. To train an ORM, binary cross entropy loss is adopted. For PRM training, we follow Wang et al. (2024b) to generate automatic process annotations by using Qwen2-7B-Instruct as the completer. Specifically, for each step in the generated samples, we use the completer to sample $8$ solutions starting from the solution prefix. This step is labeled as correct if any of these 8 solutions reaches final correctness.
Benchmarks & Metrics.
We carry out our evaluation on the GSM8K (Cobbe et al., 2021a) and MATH (Hendrycks et al., 2021) datasets. We ensure there is no data contamination issue, that is, the questions in the test sets do not appear in the training set. For evaluation metrics, we report the Greedy and Sampling scores, which correspond to the accuracy when adopting greedy decoding and sampling with temperature of 1 as generation strategies, respectively. To further understand the impact of RL, we also report Pass@16, which evaluates the probability a model can generate the correct answer out of 16 trials.
Base Models.
Our experiments are taken over a series of large language models from the Qwen2 (Yang et al., 2024a) family and the state-of-the-art LLMs for mathematical reasoning, Qwen2.5 (Yang et al., 2024b) family. Specifically, we use various 1.5B and 7B LLMs, including general and math-specific models. For general models, we consider Qwen2-1.5B-Instruct and Qwen2-7B-Instruct. For math-specific models, we consider Qwen2-Math-1.5B-Instruct, Qwen2.5-Math-1.5B-Instruct, Qwen2-Math-7B-Instruct and Qwen2.5-Math-7B-Instruct. Note that these LLMs already equip sufficient instruction following ability and we do not perform any further supervised fine-tuning. Lastly, the PRM is trained with the same base model as the actor model.
RL Training
We adopt the Proximal Policy Optimization (PPO) implementation of ReaLHF (Mei et al., 2024), which supports fine-tuning LLMs with dense rewards. Following prior practices (Shao et al., 2024; Xu et al., 2024), we adopt a large batch size and sample multiple solutions for each question within a batch. For 1.5B models, there are $1024$ questions, and $8$ solutions are sampled for each question in a batch, leading to a batch size of $1024× 8$ . For 7B models, the batch size is $4096× 8$ . We also conduct an ablation study on PPO batch size in Appendix B. Each training batch is split into 4 minibatches. We apply a KL penalty coefficient of 0.1, a coefficient of 1 for dense rewards, and a coefficient of 5 for successful rewards. The learning rates of 1B and 7B actor models are 1e-6 and 1e-5, respectively, while all critic models use a learning rate of 5e-6. We use Adam optimizer weight decay of $0.05$ . The 1.5B models are trained on a cluster of 4 machines, each with 8 Nvidia H100 GPUs, for approximately 8 hours. The 7B models are trained on a cluster of 8 machines, each with 8 Nvidia H100 GPUs, for approximately 20 hours.
5.2 Ablation Study
| Method | Greedy | Sampling |
| --- | --- | --- |
| Qwen2-1.5B-Instruct | 24.90 | 16.79 |
| Success Reward | 30.58 | 27.05 |
| SR + OR | 30.57 | 27.12 |
| SR + PR (E1) | 11.16 | 14.68 |
| SR + PR-Normed (E2) | 29.66 | 27.14 |
| SR + PR-Normed (E5) | 12.36 | 12.84 |
| SR + PR-Clip | 30.30 | 28.40 |
| SR + PR-Delta | 30.68 | 27.96 |
| SR + PR-Clip-Delta | 31.44 | 28.20 |
Table 1: Ablation study of various reward functions on MATH with Qwen2-1.5B-Instruct. The results are tested on the MATH test set using greedy decoding and sampling. We train the base models for 5 epochs. For OR, PR-Clip, PR-Delta, and PR-Clip-Delta, we report the accuracy of the final model. For PR and PR-Normed, significant performance degradation happens in later epochs and thus we report the performance in early epochs. Here, E1 denotes the results of the 1-st epoch.
The Clip Mechanism & The Delta Mechanism
Our ablation study of the Clip mechanism and the Delta mechanism is presented in Table 1. We also consider a standard normalization variant of PR (Shao et al., 2024), denoted as PR-Normed. PPO training with OR can not surpass training with a sparse success reward. PR demonstrates severe performance degradation during training due to the reward hacking issue discussed in Sec. 4.1. Similarly, the performance of PR-Normed also decreases in the latter epochs. Consequently, none of OR, PR, and PR-Normed can achieve higher greedy decoding accuracy than training with a success reward. On the other hand, the Delta mechanism successfully stabilizes RL training, surpassing training with a success reward. Finally, by combining the Clip mechanism and the Delta mechanism, PR-Clip-Delta demonstrates the best greedy decoding accuracy.
Effect of PR-Clip-Delta
We compare the performance improvements of PPO training over the base LLMs when using a success reward and additionally using PR-Clip-Delta as dense rewards in Fig. LABEL:fig:perf-improve. In addition to Greedy and Sampling scores, we also consider the Pass@16 score, which we believe can roughly estimate the upper bound of the model’s capacity. Using PR-Clip-Delta as dense rewards can consistently improve RL training, across all LLMs and all evaluation metrics, except the greedy decoding accuracy on Qwen2-Math-7B-Instruct. This suggests that applying the Clip mechanism and the Delta mechanism can effectively utilize the PRM to guide the LLM in learning better reasoning skills during RL training. We report the detailed numbers in Appendix A.
5.3 Main Results
| Model | GSM8K | MATH | | |
| --- | --- | --- | --- | --- |
| Greedy | Sampling | Greedy | Sampling | |
| GPT-4o-2024-08-06 | 92.9 | - | 81.1 | - |
| DeepSeekMath-7B-RL | 88.2 | - | 52.4 | - |
| Internlm2-math-plus-7B | 84.0 | - | 54.4 | - |
| Mathstral-7B-v0.1 | 84.9 | - | 56.6 | - |
| NuminaMath-7B-CoT | 75.4 | - | 55.2 | - |
| Llama-3.1-8B-Instruct | 76.6 | - | 47.2 | - |
| 1.5B Models | | | | |
| Qwen2-1.5B-Instruct | 50.19 | 44.58 | 24.90 | 16.79 |
| + PPO w. (SR + PR-Clip-Delta) | 68.76 ↑18.57 | 66.19 ↑21.61 | 31.44 ↑6.54 | 28.20 ↑11.41 |
| Qwen2-Math-1.5B-Instruct | 83.62 | 81.50 | 69.98 | 64.51 |
| + PPO w. (SR + PR-Clip-Delta) | 85.67 ↑2.05 | 84.76 ↑3.26 | 70.94 ↑0.96 | 68.13 ↑3.62 |
| Qwen2.5-Math-1.5B-Instruct | 85.14 | 82.11 | 76.00 | 72.05 |
| + PPO w. (SR + PR-Clip-Delta) | 87.34 ↑2.20 | 85.97 ↑3.86 | 76.78 ↑0.78 | 74.63 ↑2.58 |
| 7B Models | | | | |
| Qwen2-7B-Instruct | 86.88 | 80.44 | 57.54 | 48.27 |
| + PPO w. (SR + PR-Clip-Delta) | 87.64 ↑0.76 | 87.34 ↑6.90 | 60.54 ↑3.00 | 58.17 ↑9.90 |
| Qwen2-Math-7B-Instruct | 89.61 | 89.23 | 75.30 | 72.09 |
| + PPO w. (SR + PR-Clip-Delta) | 90.90 ↑1.29 | 90.14 ↑0.91 | 76.00 ↑0.70 | 74.09 ↑2.00 |
| Qwen2.5-Math-7B-Instruct | 95.60 | 80.74 | 83.30 | 52.76 For sampling accuracy, we find that Qwen-2.5-math-Instruct is likely to generate strange characters, leading to poor sampling accuracy. |
| + PPO w. (SR + PR-Clip-Delta) | 95.60 0.00 | 95.07 ↑14.33 | 83.38 ↑0.08 | 81.22 ↑28.46 |
Table 2: Greedy and Sampling scores on GSM8K and MATH benchmarks. PPO training using sparse success rewards and PR-Clip-Delta as dense rewards consistently improve all evaluated LLMs, including the state-of-the-art 7B LLMs, Qwen2.5-Math-7B-Instruct. For sampling decoding, we adopt the temperature of 1.0.
Main Results
Our main results are summarized in Table. 2. RL training consistently improves the performance of the base model across all the models we test, even on the state-of-the-art 1.5B model, Qwen2.5-Math-1.5B-Instruct, and 7B model, Qwen2.5-Math-7B-Instruct. For 1.5B models, Qwen2-1.5B-Instruct obtains the most significant performance improvement. Through RL training with PR-Clip-Deta as reward function, the best 1.5B model, Qwen2.5-Math-1.5B-Instruct achieves 87.34% and 76.78% greedy decoding accuracy on GSM8K and MATH benchmark respectively, indicating 2.20% and 0.78% improvement of accuracy over the base model. For 7B models, building on the strongest 7B LLM, Qwen2.5-Math-7B-Instruct, RL training with dense reward further boosts the performance and achieves 95.6% and 83.38% greedy decoding accuracy on GSM8K and MATH benchmarks, respectively, surpassing several baselines. It is noteworthy that Qwen2.5-Math-7B-Instruct is already trained using RL, and our results indicate that RL with a carefully crafted dense reward can further enhance its performance, highlighting the effectiveness of PR-Clip-Delta.
Performance Improvement
The performance improvement of RL training varies across models with different amounts of parameters and different strengths. In general, weaker models gain higher performance improvements than stronger models. Comparing the improvements of Greedy and Sampling scores, the improvements of Sampling score are larger than those of Greedy score across all LLMs, resulting in a smaller gap between Sampling and Greedy scores. Interestingly, we also highlight the comparison between Qwen2.5-1.5B-Instruct and Qwen2-7B-Instruct since both models have very close performance on MATH but have different amounts of parameters. The smaller 1.5B model, Qwen2.5-1.5B-Instruct, has a more significant improvement than and can surpass the larger 7B model, Qwen2-7B-Instruct, on both MATH and GSM8K benchmarks.
6 Conclusion
In this work, we investigate designing dense rewards with a process-supervised reward model in RL training to improve the reasoning ability of LLMs. We examine some popular reward models and identify the issue of reward hacking, which manifests as the generation of nonsensical texts or unnecessary reasoning steps. The reward hacking issue can be mitigated with our proposed techniques, using the Clip mechanism to prevent the LLM from exploiting the reward model and the Delta mechanism to ensure a bounded RL objective. We show that the proposed techniques can be utilized to apply Process-supervised Reward Models for improved RL training.
Limitations.
Limited by computation resources, our experiments are conducted over 1.5B&7B LLMs, while evaluations on larger LLMs could further help verify our proposed techniques. Also, it is an interesting direction to perform various inference-time search strategies with the LLMs trained with PPO, which could help further understand whether RL training can improve search performance. Furthermore, we believe that with the support of more powerful reward models, RL training can bring greater benefits to LLM reasoning.
References
- Achiam et al. (2023) Josh Achiam, Steven Adler, Sandhini Agarwal, Lama Ahmad, Ilge Akkaya, Florencia Leoni Aleman, Diogo Almeida, Janko Altenschmidt, Sam Altman, Shyamal Anadkat, et al. Gpt-4 technical report. arXiv preprint arXiv:2303.08774, 2023.
- Anil et al. (2023) Rohan Anil, Andrew M Dai, Orhan Firat, Melvin Johnson, Dmitry Lepikhin, Alexandre Passos, Siamak Shakeri, Emanuel Taropa, Paige Bailey, Zhifeng Chen, et al. Palm 2 technical report. arXiv preprint arXiv:2305.10403, 2023.
- Bradley & Terry (1952) Ralph Allan Bradley and Milton E Terry. Rank analysis of incomplete block designs: I. the method of paired comparisons. Biometrika, 39(3/4):324–345, 1952.
- Casper et al. (2023) Stephen Casper, Xander Davies, Claudia Shi, Thomas Krendl Gilbert, Jérémy Scheurer, Javier Rando, Rachel Freedman, Tomasz Korbak, David Lindner, Pedro Freire, Tony Tong Wang, Samuel Marks, Charbel-Raphael Segerie, Micah Carroll, Andi Peng, Phillip Christoffersen, Mehul Damani, Stewart Slocum, Usman Anwar, Anand Siththaranjan, Max Nadeau, Eric J Michaud, Jacob Pfau, Dmitrii Krasheninnikov, Xin Chen, Lauro Langosco, Peter Hase, Erdem Biyik, Anca Dragan, David Krueger, Dorsa Sadigh, and Dylan Hadfield-Menell. Open problems and fundamental limitations of reinforcement learning from human feedback. Transactions on Machine Learning Research, 2023. ISSN 2835-8856. URL https://openreview.net/forum?id=bx24KpJ4Eb. Survey Certification.
- Chen et al. (2024a) Guoxin Chen, Minpeng Liao, Chengxi Li, and Kai Fan. Alphamath almost zero: process supervision without process. arXiv preprint arXiv:2405.03553, 2024a.
- Chen et al. (2024b) Lichang Chen, Chen Zhu, Jiuhai Chen, Davit Soselia, Tianyi Zhou, Tom Goldstein, Heng Huang, Mohammad Shoeybi, and Bryan Catanzaro. ODIN: Disentangled reward mitigates hacking in RLHF. In Forty-first International Conference on Machine Learning, 2024b. URL https://openreview.net/forum?id=zcIV8OQFVF.
- Chen et al. (2024c) Zhipeng Chen, Kun Zhou, Wayne Xin Zhao, Junchen Wan, Fuzheng Zhang, Di Zhang, and Ji-Rong Wen. Improving large language models via fine-grained reinforcement learning with minimum editing constraint. arXiv preprint arXiv:2401.06081, 2024c.
- Cobbe et al. (2021a) Karl Cobbe, Vineet Kosaraju, Mohammad Bavarian, Mark Chen, Heewoo Jun, Lukasz Kaiser, Matthias Plappert, Jerry Tworek, Jacob Hilton, Reiichiro Nakano, et al. Training verifiers to solve math word problems. arXiv preprint arXiv:2110.14168, 2021a.
- Cobbe et al. (2021b) Karl Cobbe, Vineet Kosaraju, Mohammad Bavarian, Mark Chen, Heewoo Jun, Lukasz Kaiser, Matthias Plappert, Jerry Tworek, Jacob Hilton, Reiichiro Nakano, et al. Training verifiers to solve math word problems. arXiv preprint arXiv:2110.14168, 2021b.
- Dong et al. (2023) Hanze Dong, Wei Xiong, Deepanshu Goyal, Yihan Zhang, Winnie Chow, Rui Pan, Shizhe Diao, Jipeng Zhang, KaShun SHUM, and Tong Zhang. RAFT: Reward ranked finetuning for generative foundation model alignment. Transactions on Machine Learning Research, 2023. ISSN 2835-8856. URL https://openreview.net/forum?id=m7p5O7zblY.
- Eisenstein et al. (2024) Jacob Eisenstein, Chirag Nagpal, Alekh Agarwal, Ahmad Beirami, Alexander Nicholas D’Amour, Krishnamurthy Dj Dvijotham, Adam Fisch, Katherine A Heller, Stephen Robert Pfohl, Deepak Ramachandran, Peter Shaw, and Jonathan Berant. Helping or herding? reward model ensembles mitigate but do not eliminate reward hacking. In First Conference on Language Modeling, 2024. URL https://openreview.net/forum?id=5u1GpUkKtG.
- Guo et al. (2024) Daya Guo, Qihao Zhu, Dejian Yang, Zhenda Xie, Kai Dong, Wentao Zhang, Guanting Chen, Xiao Bi, Yu Wu, YK Li, et al. Deepseek-coder: When the large language model meets programming–the rise of code intelligence. arXiv preprint arXiv:2401.14196, 2024.
- Han et al. (2024) Vernon Toh Yan Han, Ratish Puduppully, and Nancy F. Chen. Veritymath: Advancing mathematical reasoning by self-verification through unit consistency. In AI for Math Workshop @ ICML 2024, 2024. URL https://openreview.net/forum?id=S9utaRXaZt.
- Havrilla et al. (2024) Alexander Havrilla, Yuqing Du, Sharath Chandra Raparthy, Christoforos Nalmpantis, Jane Dwivedi-Yu, Eric Hambro, Sainbayar Sukhbaatar, and Roberta Raileanu. Teaching large language models to reason with reinforcement learning. In AI for Math Workshop @ ICML 2024, 2024. URL https://openreview.net/forum?id=mjqoceuMnI.
- Hendrycks et al. (2021) Dan Hendrycks, Collin Burns, Saurav Kadavath, Akul Arora, Steven Basart, Eric Tang, Dawn Song, and Jacob Steinhardt. Measuring mathematical problem solving with the MATH dataset. In Thirty-fifth Conference on Neural Information Processing Systems Datasets and Benchmarks Track (Round 2), 2021. URL https://openreview.net/forum?id=7Bywt2mQsCe.
- Lee et al. (2024) Jung Hyun Lee, June Yong Yang, Byeongho Heo, Dongyoon Han, and Kang Min Yoo. Token-supervised value models for enhancing mathematical reasoning capabilities of large language models. arXiv preprint arXiv:2407.12863, 2024.
- Lightman et al. (2024) Hunter Lightman, Vineet Kosaraju, Yuri Burda, Harrison Edwards, Bowen Baker, Teddy Lee, Jan Leike, John Schulman, Ilya Sutskever, and Karl Cobbe. Let’s verify step by step. In The Twelfth International Conference on Learning Representations, 2024. URL https://openreview.net/forum?id=v8L0pN6EOi.
- Luo et al. (2024) Liangchen Luo, Yinxiao Liu, Rosanne Liu, Samrat Phatale, Harsh Lara, Yunxuan Li, Lei Shu, Yun Zhu, Lei Meng, Jiao Sun, et al. Improve mathematical reasoning in language models by automated process supervision. arXiv preprint arXiv:2406.06592, 2024.
- Mei et al. (2024) Zhiyu Mei, Wei Fu, Kaiwei Li, Guangju Wang, Huanchen Zhang, and Yi Wu. Realhf: Optimized rlhf training for large language models through parameter reallocation. arXiv preprint arXiv:2406.14088, 2024.
- Meng et al. (2024) Yu Meng, Mengzhou Xia, and Danqi Chen. Simpo: Simple preference optimization with a reference-free reward. arXiv preprint arXiv:2405.14734, 2024.
- 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 instructions with human feedback. Advances in neural information processing systems, 35:27730–27744, 2022.
- Rafailov et al. (2024) Rafael Rafailov, Archit Sharma, Eric Mitchell, Christopher D Manning, Stefano Ermon, and Chelsea Finn. Direct preference optimization: Your language model is secretly a reward model. Advances in Neural Information Processing Systems, 36, 2024.
- Rame et al. (2024) Alexandre Rame, Nino Vieillard, Leonard Hussenot, Robert Dadashi, Geoffrey Cideron, Olivier Bachem, and Johan Ferret. WARM: On the benefits of weight averaged reward models. In Forty-first International Conference on Machine Learning, 2024. URL https://openreview.net/forum?id=s7RDnNUJy6.
- Schulman et al. (2017) John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. arXiv preprint arXiv:1707.06347, 2017.
- Shah et al. (2024) Vedant Shah, Dingli Yu, Kaifeng Lyu, Simon Park, Nan Rosemary Ke, Michael Mozer, Yoshua Bengio, Sanjeev Arora, and Anirudh Goyal. Ai-assisted generation of difficult math questions. arXiv preprint arXiv:2407.21009, 2024.
- Shao et al. (2024) Zhihong Shao, Peiyi Wang, Qihao Zhu, Runxin Xu, Junxiao Song, Mingchuan Zhang, YK Li, Yu Wu, and Daya Guo. Deepseekmath: Pushing the limits of mathematical reasoning in open language models. arXiv preprint arXiv:2402.03300, 2024.
- Shen et al. (2023) Wei Shen, Rui Zheng, Wenyu Zhan, Jun Zhao, Shihan Dou, Tao Gui, Qi Zhang, and Xuanjing Huang. Loose lips sink ships: Mitigating length bias in reinforcement learning from human feedback. In The 2023 Conference on Empirical Methods in Natural Language Processing, 2023. URL https://openreview.net/forum?id=qq6ctdUwCX.
- Singhal et al. (2023) Prasann Singhal, Tanya Goyal, Jiacheng Xu, and Greg Durrett. A long way to go: Investigating length correlations in rlhf. arXiv preprint arXiv:2310.03716, 2023.
- Skalse et al. (2022) Joar Skalse, Nikolaus Howe, Dmitrii Krasheninnikov, and David Krueger. Defining and characterizing reward gaming. Advances in Neural Information Processing Systems, 35:9460–9471, 2022.
- Snell et al. (2024) Charlie Snell, Jaehoon Lee, Kelvin Xu, and Aviral Kumar. Scaling llm test-time compute optimally can be more effective than scaling model parameters. arXiv preprint arXiv:2408.03314, 2024.
- Tang et al. (2024) Zhengyang Tang, Xingxing Zhang, Benyou Wang, and Furu Wei. Mathscale: Scaling instruction tuning for mathematical reasoning. In Forty-first International Conference on Machine Learning, 2024. URL https://openreview.net/forum?id=Kjww7ZN47M.
- Uesato et al. (2022) Jonathan Uesato, Nate Kushman, Ramana Kumar, Francis Song, Noah Siegel, Lisa Wang, Antonia Creswell, Geoffrey Irving, and Irina Higgins. Solving math word problems with process-and outcome-based feedback. arXiv preprint arXiv:2211.14275, 2022.
- Wang et al. (2024a) Ke Wang, Houxing Ren, Aojun Zhou, Zimu Lu, Sichun Luo, Weikang Shi, Renrui Zhang, Linqi Song, Mingjie Zhan, and Hongsheng Li. Mathcoder: Seamless code integration in LLMs for enhanced mathematical reasoning. In The Twelfth International Conference on Learning Representations, 2024a. URL https://openreview.net/forum?id=z8TW0ttBPp.
- Wang et al. (2024b) Peiyi Wang, Lei Li, Zhihong Shao, Runxin Xu, Damai Dai, Yifei Li, Deli Chen, Yu Wu, and Zhifang Sui. Math-shepherd: Verify and reinforce llms step-by-step without human annotations. In Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pp. 9426–9439, 2024b.
- Wu et al. (2024) Zhenyu Wu, Qingkai Zeng, Zhihan Zhang, Zhaoxuan Tan, Chao Shen, and Meng Jiang. Large language models can self-correct with minimal effort. In AI for Math Workshop @ ICML 2024, 2024. URL https://openreview.net/forum?id=mmZLMs4l3d.
- Xu et al. (2024) Shusheng Xu, Wei Fu, Jiaxuan Gao, Wenjie Ye, Weilin Liu, Zhiyu Mei, Guangju Wang, Chao Yu, and Yi Wu. Is DPO superior to PPO for LLM alignment? a comprehensive study. In Forty-first International Conference on Machine Learning, 2024. URL https://openreview.net/forum?id=6XH8R7YrSk.
- Yang et al. (2024a) An Yang, Baosong Yang, Binyuan Hui, Bo Zheng, Bowen Yu, Chang Zhou, Chengpeng Li, Chengyuan Li, Dayiheng Liu, Fei Huang, et al. Qwen2 technical report. arXiv preprint arXiv:2407.10671, 2024a.
- Yang et al. (2024b) An Yang, Beichen Zhang, Binyuan Hui, Bofei Gao, Bowen Yu, Chengpeng Li, Dayiheng Liu, Jianhong Tu, Jingren Zhou, Junyang Lin, et al. Qwen2. 5-math technical report: Toward mathematical expert model via self-improvement. arXiv preprint arXiv:2409.12122, 2024b.
- Yu et al. (2024a) Fei Yu, Anningzhe Gao, and Benyou Wang. Ovm, outcome-supervised value models for planning in mathematical reasoning. In Findings of the Association for Computational Linguistics: NAACL 2024, pp. 858–875, 2024a.
- Yu et al. (2024b) Longhui Yu, Weisen Jiang, Han Shi, Jincheng YU, Zhengying Liu, Yu Zhang, James Kwok, Zhenguo Li, Adrian Weller, and Weiyang Liu. Metamath: Bootstrap your own mathematical questions for large language models. In The Twelfth International Conference on Learning Representations, 2024b. URL https://openreview.net/forum?id=N8N0hgNDRt.
- Yuan et al. (2024) Lifan Yuan, Ganqu Cui, Hanbin Wang, Ning Ding, Xingyao Wang, Jia Deng, Boji Shan, Huimin Chen, Ruobing Xie, Yankai Lin, Zhenghao Liu, Bowen Zhou, Hao Peng, Zhiyuan Liu, and Maosong Sun. Advancing LLM reasoning generalists with preference trees. In AI for Math Workshop @ ICML 2024, 2024. URL https://openreview.net/forum?id=2Y1iiCqM5y.
- Yue et al. (2024) Xiang Yue, Xingwei Qu, Ge Zhang, Yao Fu, Wenhao Huang, Huan Sun, Yu Su, and Wenhu Chen. MAmmoTH: Building math generalist models through hybrid instruction tuning. In The Twelfth International Conference on Learning Representations, 2024. URL https://openreview.net/forum?id=yLClGs770I.
- Zhang et al. (2024) Lunjun Zhang, Arian Hosseini, Hritik Bansal, Mehran Kazemi, Aviral Kumar, and Rishabh Agarwal. Generative verifiers: Reward modeling as next-token prediction. arXiv preprint arXiv:2408.15240, 2024.
- Zheng et al. (2023) Rui Zheng, Shihan Dou, Songyang Gao, Yuan Hua, Wei Shen, Binghai Wang, Yan Liu, Senjie Jin, Qin Liu, Yuhao Zhou, et al. Secrets of rlhf in large language models part i: Ppo. arXiv preprint arXiv:2307.04964, 2023.
Appendix A Additional results
In Tab. 3 and Tab. 4, we report the results of RL training on different base models, including those with success rewards and after applying PR-Clip-Delta.
| Model | Method | Math | | |
| --- | --- | --- | --- | --- |
| Greedy | Sample | Pass@16 | | |
| Qwen2-1.5B-Instruct | Basemodel | 24.90 | 16.79 | 55.68 |
| Success Reward | 30.58 ↑4.68 | 27.05 ↑10.26 | 61.70 ↑6.02 | |
| + PR-Clip-Delta | 31.44 ↑6.54 | 28.20 ↑11.41 | 61.70 ↑6.02 | |
| Qwen2-Math-1.5B-Instruct | Basemodel | 69.98 | 64.51 | 88.02 |
| Success Reward | 70.26 ↑0.28 | 66.29 ↑1.78 | 88.46 ↑0.44 | |
| + PR-Clip-Delta | 70.94 ↑0.96 | 68.13 ↑3.62 | 88.58 ↑0.56 | |
| Qwen2.5-Math-1.5B-Instruct | Basemodel | 76.00 | 72.05 | 90.50 |
| Success Reward | 76.34 ↑0.34 | 74.22 ↑2.17 | 90.54 ↑0.04 | |
| + PR-Clip-Delta | 76.78 ↑0.78 | 74.63 ↑2.58 | 90.76 ↑0.26 | |
| Qwen2-7B-Instruct | Basemodel | 57.54 | 48.27 | 80.04 |
| Success Reward | 60.14 ↑2.60 | 56.39 ↑8.12 | 83.40 ↑3.36 | |
| + PR-Clip-Delta | 60.54 ↑3.00 | 58.17 ↑9.90 | 83.22 ↑3.18 | |
| Qwen2-Math-7B-Instruct | Basemodel | 75.30 | 72.09 | 91.24 |
| Success Reward | 76.42 ↑1.12 | 73.12 ↑1.03 | 91.08 ↓0.16 | |
| + PR-Clip-Delta | 76.00 ↑0.70 | 74.09 ↑2.00 | 91.52 ↑0.28 | |
| Qwen2.5-Math-7B-Instruct | Basemodel | 83.3 | 52.76 | 86.6 |
| Success Reward | 83.16 ↓0.14 | 79.95 ↑27.19 | 92.46 ↑5.86 | |
| + PR-Clip-Delta | 83.38 ↑0.08 | 81.22 ↑28.46 | 92.60 ↑6.00 | |
Table 3: Results on MATH test set
| Model | Method | GSM8K | |
| --- | --- | --- | --- |
| Greedy | Sample | | |
| Qwen2-1.5B-Instruct | Basemodel | 50.19 | 44.58 |
| Success Reward | 67.70 ↑17.51 | 65.50 ↑20.92 | |
| + PR-Clip-Delta | 68.76 ↑18.57 | 66.19 ↑21.61 | |
| Qwen2-Math-1.5B-Instruct | Basemodel | 83.62 | 81.50 |
| Success Reward | 84.61 ↑0.99 | 83.93 ↑2.43 | |
| + PR-Clip-Delta | 85.67 ↑2.05 | 84.76 ↑3.26 | |
| Qwen2.5-Math-1.5B-Instruct | Basemodel | 85.14 | 82.11 |
| Success Reward | 86.73 ↑1.59 | 85.82 ↑3.71 | |
| + PR-Clip-Delta | 87.34 ↑2.20 | 85.97 ↑3.86 | |
| Qwen2-7B-Instruct | Basemodel | 86.88 | 80.44 |
| Success Reward | 87.72 ↑0.84 | 86.81 ↑6.37 | |
| + PR-Clip-Delta | 87.64 ↑0.76 | 87.34 ↑6.90 | |
| Qwen2-Math-7B-Instruct | Basemodel | 89.61 | 89.23 |
| Success Reward | 89.46 ↓0.15 | 90.07 ↑0.84 | |
| + PR-Clip-Delta | 90.90 ↑1.29 | 90.14 ↑0.91 | |
| Qwen2.5-Math-7B-Instruct | Basemodel | 95.60 | 80.74 |
| Success Reward | 95.45 ↓0.15 | 95.07 ↑14.33 | |
| + PR-Clip-Delta | 95.60 ↑0.00 | 95.07 ↑14.33 | |
Table 4: Results on GSM8K test set
In Fig. 9, we report the greedy accuracy on MATH test set of different training epochs, where epoch-0 means the base model (i.e., Qwen2-1.5B-Instruct). The introduction of PR-norm caused the model’s accuracy to drop significantly starting from the third epoch.
<details>
<summary>extracted/6028969/Figures/math_acc_vs_training.png Details</summary>
### Visual Description
## Line Chart: Greedy Accuracy vs. Training Epoch
### Overview
The image is a line chart comparing the "Greedy Accuracy" of two models, "SR" and "SR + PR-Normed", over 6 training epochs (0 to 5). The chart shows how the accuracy changes during training.
### Components/Axes
* **X-axis (Horizontal):** "Training Epoch" with ticks at 0, 1, 2, 3, 4, and 5.
* **Y-axis (Vertical):** "Greedy Accuracy" ranging from approximately 10 to 30, with ticks at 10, 15, 20, 25, and 30.
* **Legend (Bottom-Left):**
* Red line: "SR"
* Blue line: "SR + PR-Normed"
### Detailed Analysis
* **SR (Red Line):**
* Trend: Initially increases, then plateaus, and slightly increases again.
* Epoch 0: ~25
* Epoch 1: ~29
* Epoch 2: ~29.5
* Epoch 3: ~29.7
* Epoch 4: ~30.2
* Epoch 5: ~30.6
* **SR + PR-Normed (Blue Line):**
* Trend: Initially increases, plateaus, then decreases sharply, and finally increases slightly.
* Epoch 0: ~25
* Epoch 1: ~28.5
* Epoch 2: ~29.5
* Epoch 3: ~26
* Epoch 4: ~9.8
* Epoch 5: ~12.5
### Key Observations
* Both models start with the same accuracy at epoch 0.
* The "SR" model consistently improves or plateaus in accuracy throughout the training.
* The "SR + PR-Normed" model experiences a significant drop in accuracy between epochs 3 and 4, before recovering slightly by epoch 5.
* The "SR" model outperforms "SR + PR-Normed" after epoch 3.
### Interpretation
The chart suggests that while "SR + PR-Normed" initially performs comparably to "SR", it suffers a performance degradation during later training epochs. The "SR" model demonstrates more stable and consistent improvement in "Greedy Accuracy" over the training period. The PR-Normed model may require further tuning or a different training regime to prevent the observed accuracy drop.
</details>
Figure 9: Greedy accuracy on MATH test set during the training process.
Appendix B Ablation Study on PPO Batch Size
We conduct an ablation study on PPO batch size in Tab. 5 and Tab. 6, where $a× b$ denotes $a$ questions with $b$ solutions sampled per question within each batch. The results indicate that larger final batch sizes improve performance. With a fixed final batch size, configurations of $1024× 8$ and $2048× 4$ achieve higher accuracy compared to $8192× 1$ . In practice, we recommend sampling approximately 8 solutions per question while increasing the number of questions in each batch.
| PPO Batch Size | Greedy | Sample | Pass@16 |
| --- | --- | --- | --- |
| Qwen-2-1.5B-Instruct | 24.90 | 16.79 | 55.68 |
| $1024× 1$ | 29.12 | 24.68 | 60.06 |
| $2048× 1$ | 29.00 | 25.43 | 60.16 |
| $8192× 1$ | 30.12 | 25.82 | 61.06 |
| $2048× 4$ | 30.66 | 26.63 | 61.32 |
| $1024× 8$ | 30.58 | 27.05 | 61.70 |
Table 5: The ablation study on PPO batch size is conducted using Qwen2-1.5B-Instruct and the MATH, where $a× b$ represents $a$ questions with $b$ solutions sampled per question in each batch. All models are trained using only the Success Reward.
| PPO Batch Size | Greedy | Sample | Pass@16 |
| --- | --- | --- | --- |
| Qwen2-7B-Instruct | 57.54 | 48.27 | 80.04 |
| $1024× 8$ | 59.06 | 56.35 | 82.32 |
| $4096× 8$ | 60.14 | 56.39 | 83.40 |
Table 6: The ablation study on PPO batch size is conducted using Qwen2-7B-Instruct and the MATH. All models are trained using only the Success Reward.
Appendix C Synthetic Example
In Fig. LABEL:fig:synthetic, we insert nonsense steps or repeat the last sentences in the following manner. {mdframed} Prompt:
Tom found a box of 220 baseball cards. Being a thoughtful older brother, he wanted to save at least 50 percent of the cards for himself and split the remaining cards evenly among his 5 younger brothers. What is the lowest possible number of cards that Tom can save for himself that will also allow each of his 5 younger brothers to get an equal number of cards? Please reason step by step, and put your final answer within $\backslash$ boxed{}.
Answer by Qwen2-1.5B-instruct:
Step 1: 50% of 220 cards
$$
50\%\times 220=0.50\times 220=110
$$
Therefore, Tom would save 110 of the cards for himself.
Step 2: Remaining cards that Tom would like to distribute evenly among his 5 younger brothers
$$
220-110=110
$$
Tom would have 110 cards left to distribute evenly among his 5 younger brothers.
Step 3: Forming sets of cards and evenly distributing
If the 110 remaining cards are to be divided into 5 sets of equal cards, each set must contain:
$$
\frac{110}{5}=22
$$
Therefore, each of Tom’s 5 younger brothers would get 22 cards, but since each set also must have 22 cards, the lowest possible number of cards for Tom to save so that each brother gets an equal number of cards means Tom would save:
$$
5\times 22=110
$$
The lowest possible number of cards that Tom can save for himself that will allow each of his 5 younger brothers to get an equal number of cards is 110. This way, Tom will save enough cards to permit a remainder that will also allow one card to be shared by each of his brothers out of the total of 110 cards.
The answer is: $\boxed{110}$ .
Repeat Nonsense
Step 1: 50% of 220 cards
$$
50\%\times 220=0.50\times 220=110
$$
…
Step 3: Forming sets of cards and evenly distributing …
Step done.
Step done.
Step end.
Step end.
Step show.
…
Repeat Mid Step
Step 1: 50% of 220 cards
$$
50\%\times 220=0.50\times 220=110
$$
…
Step 2: Remaining cards that Tom would like to distribute evenly among his 5 younger…
Step 2: Remaining cards that Tom would like to distribute evenly among his 5 younger…
Step 2: Remaining cards that Tom would like to distribute evenly among his 5 younger…
…
Step 3: Forming sets of cards and evenly distributing …
The answer is: $\boxed{110}$ .
Repeat Last Sentence
Step 1: 50% of 220 cards
$$
50\%\times 220=0.50\times 220=110
$$
…
Step 3: Forming sets of cards and evenly distributing …
The answer is: $\boxed{110}$ .
The answer is: $\boxed{110}$ .
The answer is: $\boxed{110}$ .
The answer is: $\boxed{110}$ .
…
Appendix D Baselines
Length Normalization.
Length normalization normalizes the rewards for each solution. Formally,
| | $\displaystyle r(q,p^{(k)})=\frac{1}{K}r_{\text{process}}(q,p^{(k)})$ | |
| --- | --- | --- |
Length Penalty.
Length penalty imposes a constant penalty for each step.
| | $\displaystyle r(q,p^{(k)})=r_{\text{process}}(q,p^{(k)})-k*c_{\text{penalty}}$ | |
| --- | --- | --- |
D.1 Theoretical Analysis
**Theorem 1**
*By applying the Delta mechanism to the process rewards, the return for any token in step $p^{(k)}$ is,
$$
\text{Return}(q,p^{(k)})=\begin{cases}\alpha\cdot r_{\text{process}}(q,p^{(k)}%
)+\text{Correct}(q,s)&\text{if }k<K\\
\text{Correct(q,s)}&\text{otherwise}\end{cases}
$$*
* Proof*
For $k≤ K-1$ ,
| | Return | $\displaystyle(q,p^{(k)})=\alpha·\left(\sum_{i=k}^{K-2}r_{\text{process}}(q%
,p^{(i)})-r_{\text{process}}(q,p^{(i+1)})+r_{\text{process}}(q,p^{(K-1)})%
\right)+\text{Correct(q,s)}$ | |
| --- | --- | --- | --- | For $k=K$ , the return is $\text{Correct}(q,s)$ clearly. ∎
This result indicates that when applying the Delta mechanism to the process rewards, the policy gradient for optimizing the policy $\pi$ would be,
| | $\displaystyle∇_{\pi}\mathcal{L}_{\text{RL}}(\pi)=\sum_{k=1}^{K}∇_{%
\pi}\log\pi(s^{(k)}|q,p^{(k-1)})·(\alpha· r_{\text{process}}(q,p^{(k)}%
)+\text{Correct}(q,s))$ | |
| --- | --- | --- |