# 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 $π_θ(s|q)$ parameterized by $θ$ . In reasoning tasks, $π_θ$ 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_T)$ . From the perspective of steps, $s$ consists of $K$ reasoning steps, $s=(s^(1),s^(2),⋯,s^(K))$ where $s^(k)$ denotes the $k$ -th reasoning step. For convenience, we use $p^(k)=(s^(1),s^(2),⋯,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_outcome$ is then trained with the following objective,
| | $\displaystyleL_ORM=E_q,s∼D≤ft[ ∑_t=1^TLoss(Correct(q,s),r_outcome(q,s_1:t))\right]$ | |
| --- | --- | --- |
where $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,
| | $\displaystyleL_PRM=E_q,p^(k),y_k∼ D≤ft[Loss(y_k,r_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 $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(π_θ)=E_q∼D,s∼π_
θ≤ft[Correct(q,s)-β\log\frac{π_θ(s|q)}{π_ref(
s|q)}\right] \tag{1}
$$
where $π_ref$ is the reference model for regularizing $π_θ$ . 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(π_θ)=E_q∼D,s∼π_
θ≤ft[α·∑_t=1^|s|r(q,s_1:t)+Correct(q,s)-
β\log\frac{π_θ(s|q)}{π_ref(s|q)}\right] \tag{2}
$$
where $r$ denotes the dense reward and $α$ is a coefficient for the dense reward. For example, a PRM $r_process$ can provide dense feedback at the end of reasoning steps, formally represented as $r(q,p^(k))=r_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, $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_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_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
\n
## Diagram: Reinforcement Learning Process Flow with Confidence Scores
### Overview
The image is a technical diagram illustrating a step-by-step process for solving a mathematical sequence problem, annotated with confidence scores (likely from a machine learning model). The diagram is structured as a flowchart with a question header, a main process section, and a footer indicating the reinforcement learning method and a final return value. The primary language is English.
### Components/Axes
The diagram is divided into three distinct visual regions:
1. **Header (Purple Rounded Rectangle):**
* **Title:** "Question" (in large, purple serif font).
* **Content:** The mathematical problem statement: "What is the 10-th term in 1,3,9,15,25,35, ... ?"
2. **Main Process Section (Pink Rounded Rectangle):**
* This section lists a sequence of steps, each followed by a numerical value in a green box. The steps are presented in a left-aligned list.
* **Steps and Associated Values:**
* 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]`
* `...` (ellipsis indicating omitted steps)
* Step 😉. `[0.20]` (The step label includes a "winking face with tongue" emoji 😉).
* Step ready. `[0.12]`
* Step nothing. `[0.13]`
* `<EOS>` (End of Sequence token).
3. **Footer (Text on light gray background):**
* **Method Label:** "PPO w. Success Reward + PR" (in bold, black serif font). "PPO" likely stands for Proximal Policy Optimization, a reinforcement learning algorithm.
* **Result:** "Return=146.42" (in bold, with the numerical value in red).
### Detailed Analysis
The diagram details a sequential decision-making process, where each step is assigned a confidence or probability score (the number in the green box). The process begins with high-confidence, logical steps for solving the math problem and transitions into lower-confidence, less defined, or terminal steps.
* **Trend Verification:** The confidence scores show a clear downward trend. The initial, well-defined problem-solving steps (1-5) have very high scores (0.93-0.98). After the ellipsis, the scores drop dramatically to the 0.12-0.20 range for the more ambiguous or terminal steps ("😉", "ready", "nothing").
### Key Observations
1. **Confidence Decay:** There is a stark contrast between the high confidence (>0.93) in the initial, logical reasoning steps and the low confidence (<0.21) in the later, less structured steps.
2. **Emoji as a Step:** The inclusion of "Step 😉." with a low score (0.20) is notable. It may represent a non-verbal, heuristic, or "gut-feeling" step in the model's reasoning process, or it could be a placeholder for an uninterpretable action.
3. **Terminal Steps:** The steps "ready" (0.12) and "nothing" (0.13) have the lowest scores and appear just before the `<EOS>` token, suggesting they are low-confidence termination or idle states.
4. **Final Return Value:** The footer reports a "Return" of `146.42`. In reinforcement learning, this is the cumulative reward obtained by the agent (the model) over the entire episode (solving the problem).
### Interpretation
This diagram visualizes the internal reasoning trace and associated confidence of an AI agent, trained with **PPO (Proximal Policy Optimization) using a Success Reward and possibly a Progress Reward (PR)**, as it attempts to solve a sequence prediction problem.
* **What it demonstrates:** The agent successfully identifies and executes a high-confidence, logical strategy for the core mathematical task (Steps 1-5). However, its process doesn't end cleanly after "Solve." It continues into a series of low-confidence, possibly redundant or exploratory actions ("😉", "ready", "nothing") before generating an end-of-sequence signal. This suggests the agent's policy may not be perfectly optimized to terminate immediately upon task completion.
* **Relationship between elements:** The high initial scores indicate the model's strong alignment with the correct problem-solving methodology. The low later scores highlight inefficiency or uncertainty in its termination policy. The final **Return=146.42** is the aggregate measure of performance, combining the reward for solving the problem (Success Reward) and potentially for making progress (PR), minus any penalties for the inefficient steps.
* **Notable anomaly:** The significant drop in confidence after the logical steps is the primary anomaly. It indicates a disconnect between the model's capability to perform the core task and its ability to recognize when the task is complete and stop acting. This is a common challenge in training sequential decision-making models.
</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
## Diagram: Reward Processing Mechanisms (Clip vs. Delta)
### Overview
The image is a technical diagram illustrating and comparing two distinct mechanisms for processing step-wise rewards in a sequential decision-making or learning context, likely within reinforcement learning or AI training. The diagram is divided into a top section showing an initial reward sequence and two main panels below, each detailing one mechanism: the "Clip Mechanism" on the left and the "Delta Mechanism" on the right.
### Components/Axes
**Top Section (Input Sequence):**
* **Header Elements:** A blue box labeled "Question q" followed by four blue boxes labeled `s⁽¹⁾`, `s⁽²⁾`, `s⁽³⁾`, `s⁽⁴⁾`, representing sequential steps or states.
* **Chart:** A bar chart with:
* **Y-axis:** Labeled "Process Reward" (vertical text).
* **X-axis:** Labeled "Step".
* **Data:** Four blue, diagonally striped bars of varying heights corresponding to steps 1 through 4. The bar for step 1 is the tallest, step 2 is the shortest, step 3 is of medium height, and step 4 is the second tallest.
* **Flow:** Two black arrows point downwards from this top chart, one leading to the left panel (Clip Mechanism) and one to the right panel (Delta Mechanism).
**Left Panel: Clip Mechanism**
* **Background:** Light purple rounded rectangle.
* **Top Sub-chart ("Process Reward"):**
* **Y-axis:** "Process Reward".
* **X-axis:** "Step".
* **Threshold:** A horizontal dashed grey line labeled with the Greek letter η (eta) on the right side.
* **Data Bars:** The original blue striped bars are shown. Bars exceeding the η threshold (steps 1 and 4) have a solid green segment above the line. Bars below the threshold (steps 2 and 3) have a solid red segment on top.
* **Bottom Sub-chart ("Clipped Reward"):**
* **Y-axis:** "Clipped Reward".
* **X-axis:** "Step".
* **Data:** Only solid red bars are present, located at steps 2 and 3. These bars are positioned below the zero line, indicating negative values. No bars are shown for steps 1 and 4.
* **Label:** The text "Clip Mechanism" is centered below this panel.
**Right Panel: Delta Mechanism**
* **Background:** Light purple rounded rectangle.
* **Top Sub-chart ("Process Reward"):**
* **Y-axis:** "Process Reward".
* **X-axis:** "Step".
* **Data & Annotations:** The original blue striped bars are shown. Each bar is annotated with an arrow:
* Step 1: A green upward-pointing arrow.
* Step 2: A red downward-pointing arrow.
* Step 3: A green upward-pointing arrow.
* Step 4: The bar is crossed out with a large purple "X".
* **Reference Line:** A horizontal dashed grey line is present, aligned with the top of the bar for step 1.
* **Bottom Sub-chart ("Delta Reward"):**
* **Y-axis:** "Delta Reward".
* **X-axis:** "Step".
* **Data:** Arrows represent the reward delta:
* Step 1: A green upward-pointing arrow (positive delta).
* Step 2: A red downward-pointing arrow (negative delta).
* Step 3: A green upward-pointing arrow (positive delta).
* Step 4: No arrow or bar is present.
* **Label:** The text "Delta Mechanism" is centered below this panel.
### Detailed Analysis
**Clip Mechanism Flow:**
1. **Input:** The sequence of four process rewards.
2. **Clipping Operation:** A threshold `η` is applied. Rewards above `η` are "clipped" to `η` (the green segments represent the clipped-off portion). Rewards below `η` are left as-is, but the diagram highlights them in red for the next stage.
3. **Output ("Clipped Reward"):** The final output only shows negative reward signals (red bars) for the steps where the original reward was below the threshold (steps 2 and 3). Steps with rewards above the threshold (1 and 4) produce no output signal in this chart.
**Delta Mechanism Flow:**
1. **Input:** The same sequence of four process rewards.
2. **Delta Calculation:** The mechanism appears to compute a change or advantage relative to a reference (the dashed line from step 1's reward).
* Step 1: Serves as the reference (delta = 0, but marked with a green up arrow, possibly indicating a positive baseline).
* Step 2: Reward is lower than the reference → negative delta (red down arrow).
* Step 3: Reward is higher than the reference → positive delta (green up arrow).
* Step 4: The reward is crossed out, suggesting it is ignored or treated specially, resulting in no delta output.
3. **Output ("Delta Reward"):** The output chart visualizes these computed deltas as directional arrows (green for positive, red for negative).
### Key Observations
* **Divergent Outputs:** The two mechanisms produce fundamentally different final reward signals from the same input sequence. The Clip Mechanism outputs only negative, threshold-based penalties. The Delta Mechanism outputs signed (positive/negative) change signals.
* **Handling of High Rewards:** The Clip Mechanism caps high rewards (steps 1 & 4) and generates no output for them. The Delta Mechanism uses the first high reward as a reference and ignores the last one (step 4 is crossed out).
* **Visual Coding:** Consistent color coding is used: blue stripes for original data, green for positive/above-threshold, red for negative/below-threshold, and purple for exclusion.
* **Spatial Layout:** The legend (color meaning) is embedded directly in the charts via the colored bars and arrows, not in a separate box. The threshold `η` is placed in the top-right of its sub-chart.
### Interpretation
This diagram contrasts two philosophies for shaping reward signals in learning systems:
1. **Clip Mechanism (Conservative/Penalty-Focused):** It acts as a filter that only generates a training signal (a penalty) when performance falls below a predefined acceptable threshold (`η`). This could be used to discourage poor steps without being influenced by how exceptionally good a step is. It simplifies the reward landscape to "acceptable" vs. "unacceptable."
2. **Delta Mechanism (Comparative/Advantage-Focused):** It computes a relative advantage or disadvantage compared to a baseline (step 1's reward). This provides richer, signed feedback: "this step was better/worse than our reference." The crossing out of step 4 is a critical anomaly; it suggests the mechanism may discard rewards that are too high or outliers, possibly to prevent reward hacking or to maintain stable learning by focusing on incremental changes.
**Underlying Message:** The choice between mechanisms involves a trade-off. The Clip Mechanism is simpler and may lead to more stable but potentially less nuanced learning. The Delta Mechanism provides more informative gradient-like signals but requires careful handling of baselines and outliers (as shown by the crossed-out step 4). The diagram effectively argues that how intermediate rewards are processed significantly alters the feedback a learning agent receives.
</details>
Figure 6: The Clip mechanism and the Delta mechanism. The Clip mechanism subtracts the rewards with a suitable threshold $η$ 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_process$ are upper-bounded by a selected threshold $η$ . We further ensure the return of a trajectory is bounded by subtracting all rewards by $η$ . Formally, with a threshold $η$ ,
$$
\displaystyle r(q,p^(k))=\min(r_process(q,p^(k))-η,0) \tag{5}
$$
If a suitable $η$ is chosen, the majority of the reasoning steps would receive a reward of 0, and only steps with low $r_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_process(q,p^(k))-r_\text
{process}(q,p^(k+1))& if k<K-1\\
r_process(q,p^(k))& if k=K-1\\
0& if k=K\end{cases} \tag{6}
$$
A nice property of the Delta mechanism is that it ensures the return of a solution is $α· r_process(q,s^(1))+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 $α· r_process(q,p^(k))+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
\n
## Line Chart: Greedy Accuracy vs. Training Epoch
### Overview
The image displays a line chart comparing the performance of two methods, "SR" and "SR + PR-Normed," over the course of six training epochs (0 through 5). The chart plots "Greedy Accuracy" on the vertical axis against "Training Epoch" on the horizontal axis. The primary visual story is the stark divergence in performance trends between the two methods after the second epoch.
### Components/Axes
* **Chart Type:** Line chart with two data series.
* **X-Axis (Horizontal):**
* **Label:** "Training Epoch"
* **Scale:** Linear, with integer markers from 0 to 5.
* **Y-Axis (Vertical):**
* **Label:** "Greedy Accuracy"
* **Scale:** Linear, with major gridlines and labels at intervals of 5, from 10 to 30.
* **Legend:**
* **Position:** Bottom-left corner of the plot area.
* **Series 1:** "SR" - Represented by a solid red line.
* **Series 2:** "SR + PR-Normed" - Represented by a solid blue line.
* **Background:** Light gray grid with white gridlines.
### Detailed Analysis
**Data Series: SR (Red Line)**
* **Trend:** Shows a steady, monotonic increase that plateaus.
* **Data Points (Approximate):**
* Epoch 0: 25
* Epoch 1: ~29
* Epoch 2: 30
* Epoch 3: ~30
* Epoch 4: ~30.2
* Epoch 5: ~30.5
* **Visual Path:** The line slopes upward sharply from epoch 0 to 1, continues a gentler rise to epoch 2, and then remains nearly flat with a very slight positive slope through epoch 5.
**Data Series: SR + PR-Normed (Blue Line)**
* **Trend:** Shows initial improvement followed by a dramatic collapse and partial recovery.
* **Data Points (Approximate):**
* Epoch 0: 25 (identical starting point to SR)
* Epoch 1: ~28.5
* Epoch 2: 30 (peaks, matching the SR line)
* Epoch 3: ~26
* Epoch 4: 10 (lowest point)
* Epoch 5: ~12
* **Visual Path:** The line follows a similar upward trajectory to the SR line from epoch 0 to 2. After epoch 2, it slopes downward to epoch 3, then plummets steeply to a minimum at epoch 4, before showing a modest upward slope to epoch 5.
### Key Observations
1. **Identical Start:** Both methods begin at the same accuracy (~25) at epoch 0.
2. **Convergence then Divergence:** The two lines track closely until epoch 2, where they both reach an accuracy of approximately 30. After this point, their paths diverge radically.
3. **Catastrophic Drop:** The "SR + PR-Normed" method experiences a severe performance degradation between epochs 2 and 4, losing roughly 20 points of accuracy.
4. **Stability vs. Instability:** The "SR" method demonstrates stable, improving performance throughout training. The "SR + PR-Normed" method exhibits significant instability after an initial period of effective learning.
5. **Partial Recovery:** The blue line shows a slight upward trend from epoch 4 to 5, suggesting a minor recovery from its lowest point, but it remains far below its peak and the performance of the SR method.
### Interpretation
This chart likely illustrates the outcome of an experiment in machine learning or optimization, comparing a baseline method ("SR") with a variant that incorporates an additional technique ("PR-Normed").
* **What the data suggests:** The "PR-Normed" addition appears beneficial or neutral in the very early stages of training (epochs 0-2), matching the baseline's performance. However, it introduces a critical instability that manifests after epoch 2, leading to a collapse in greedy accuracy. This could indicate issues like overfitting, gradient instability, or a harmful interaction between the PR-Normed technique and the training dynamics as the model converges.
* **How elements relate:** The x-axis (Training Epoch) is the independent variable, showing the progression of the training process. The y-axis (Greedy Accuracy) is the dependent performance metric. The legend defines the experimental conditions. The direct comparison of the two lines on the same axes allows for a clear, controlled assessment of the "PR-Normed" technique's impact.
* **Notable anomalies:** The most striking anomaly is the precipitous drop in the blue line after epoch 2. This is not a gradual decline but a sharp failure, which is a significant red flag for the reliability of the "SR + PR-Normed" method. The fact that both methods peak at the same point (epoch 2) before diverging suggests that the instability is triggered by a specific phase or state in the training process.
</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. 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\
$$
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× 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\
$$
…
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\
$$
…
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\
$$
…
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_process(q,p^(k))$ | |
| --- | --- | --- |
#### Length Penalty.
Length penalty imposes a constant penalty for each step.
| | $\displaystyle r(q,p^(k))=r_process(q,p^(k))-k*c_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,
$$
Return(q,p^(k))=\begin{cases}α· r_process(q,p^(k)
)+Correct(q,s)&if k<K\\
Correct(q,s)&otherwise\end{cases}
$$*
* Proof*
For $k≤ K-1$ ,
| | Return | $\displaystyle(q,p^(k))=α·≤ft(∑_i=k^K-2r_process(q ,p^(i))-r_process(q,p^(i+1))+r_process(q,p^(K-1)) \right)+Correct(q,s)$ | |
| --- | --- | --- | --- | For $k=K$ , the return is $Correct(q,s)$ clearly. ∎
This result indicates that when applying the Delta mechanism to the process rewards, the policy gradient for optimizing the policy $π$ would be,
| | $\displaystyle∇_πL_RL(π)=∑_k=1^K∇_ π\logπ(s^(k)|q,p^(k-1))·(α· r_process(q,p^(k) )+Correct(q,s))$ | |
| --- | --- | --- |