Improve Mathematical Reasoning in Language Models with Automated Process Supervision

## Abstract

Abstract Complex multi-step reasoning tasks, such as solving mathematical problems or generating code, remain a significant hurdle for even the most advanced large language models (LLMs). Verifying LLM outputs with an Outcome Reward Model (ORM) is a standard inference-time technique aimed at enhancing the reasoning performance of LLMs. However, this still proves insufficient for reasoning tasks with a lengthy or multi-hop reasoning chain, where the intermediate outcomes are neither properly rewarded nor penalized. Process supervision addresses this limitation by assigning intermediate rewards during the reasoning process. To date, the methods used to collect process supervision data have relied on either human annotation or per-step Monte Carlo estimation, both prohibitively expensive to scale, thus hindering the broad application of this technique. In response to this challenge, we propose a novel divide-and-conquer style Monte Carlo Tree Search (MCTS) algorithm named OmegaPRM for the efficient collection of high-quality process supervision data. This algorithm swiftly identifies the first error in the Chain of Thought (CoT) with binary search and balances the positive and negative examples, thereby ensuring both efficiency and quality. As a result, we are able to collect over 1.5 million process supervision annotations to train a Process Reward Model (PRM). Utilizing this fully automated process supervision alongside the weighted self-consistency algorithm, we have enhanced the instruction tuned Gemini Pro model’s math reasoning performance, achieving a 69.4% success rate on the MATH benchmark, a 36% relative improvement from the 51% base model performance. Additionally, the entire process operates without any human intervention, making our method both financially and computationally cost-effective compared to existing methods.

## 1 Introduction

Despite significant progress in various large language model (LLM) benchmarks achieved through simply scaling up the model (Wei et al., ), the development of complex reasoning abilities, particularly in tasks like mathematical problem-solving and code generation, necessitates a deeper understanding and remains an active research frontier.
Chain-of-Thought (CoT) Prompting (Wei et al., ) was proposed to guide the LLM to break down a reasoning task into a sequence of intermediate steps, similar to a human’s reasoning process. CoT boosts the performance of LLMs on many reasoning tasks, but the greedy decoding strategy limits its performance. To address that, Wang et al. () proposed the self-consistency decoding strategy, leveraging multiple reasoning paths to reach a voted answer. Besides these prompting focused work, fine-tuning LLM with question and CoT solution pairs (Perez et al., ; Ouyang et al., ) proved to be effective, outperforming prompting-only methods, understandably.

A third active area of research aiming to improve reasoning capability is using a verifier to aid LLM reasoning. Off-the-shelf LLMs are a straightforward option for verifiers (Huang et al., ; Luo et al., ). While they can be used to verify the result after reaching the final answer, identify potential mistakes and suggest corrections, the performance with such aids is still limited when it comes to complex multi-step math reasoning problems. Since the advent of RLHF (Ouyang et al., ), reward models have been used to align LLM behaviors to human preferences and are proven to be a crucial step in training. With reward models as verifiers, model candidate outcomes can be reranked according to the reward to ensure higher accuracy and reliability.

Two predominant types of reward models are frequently employed: the Outcome Reward Models (ORMs; Yu et al., ; Cobbe et al., ) and the Process Reward Models (PRMs; Li et al., ; Uesato et al., ; Lightman et al., ). The ORM, what’s widely used in RLHF, produces signals only at the end of problem solving, which means the intermediate steps of a reasoning chain are not at all rewarded or penalized. In light of such an obvious shortcoming, the PRM emerged to leverage the reward model in a more granular fashion, by explicitly rewarding or penalizing every reasoning step, namely, with process supervision.

Figure: Figure 1: Example tree structure built with our proposed OmegaPRM algorithm. Each node in the tree indicates a state of partial chain-of-thought solution, with information including accuracy of rollouts and other statistics. Each edge indicates an action, i.e., a reasoning step, from the last state. Yellow edges are correct steps and blue edges are wrong.
Refer to caption: extracted/5644475/figures/tree.png

As the name suggests, process supervision requires supervised data. So far, collecting such data relies largely on human annotation (Uesato et al., ; Lightman et al., ). Annotators have to label each step of every multi-step reasoning problem meticulously, the level of skills and sheer labor demanded render such a practice costly and difficult to scale. Recent efforts to automate such a data collection process with per-step Monte Carlo estimation have shown promising results (Wang et al., , ). This data collection process excludes the human annotator from the loop, yet the efficiency of such algorithms remains a problem.

Inspired by AlphaGo Zero (Silver et al., ), we developed a novel divide-and-conquer style Monte Carlo Tree Search (MCTS) algorithm named OmegaPRM for automated collection of process supervision data. For each question, we build a Monte Carlo Tree, as shown in Fig. 1, with the details explained in Section 3.3.
Our algorithm allows for an efficient collection of over 1.5 million high-quality process annotations. Our PRM trained with this dataset, when combined with the weighted self-consistency algorithm to select candidate responses, achieves a 69.4% success rate on the Hendrycks MATH (Hendrycks et al., ) benchmark.

Our main contributions are as follows:

- •
We propose a novel divide-and-conquer style Monte Carlo Tree Search algorithm for automated process supervision data generation.
- •
The algorithm enables the efficient generation of over 1.5 million process supervision annotations, representing the largest and highest quality dataset of its kind to date. Additionally, the entire process operates without any human annotation, making our method both financially and computationally cost-effective.
- •
We combine our verifier with weighted self-consistency to further boost the performance of LLM reasoning. We reached 69.4% success rate on the MATH benchmark.

The rest of the paper is structured as follows. We discuss related work on using LLMs to solve mathematical reasoning problems in Section 2. We describe our main method in Section 3. Our experimental setup including the task, model configuration, baselines and metrics are discussed in Section 4. We showcase our superior result also in Section 4.

## 2 Related Work

#### Improving Mathematical reasoning ability of LLMs.

Mathematical reasoning poses significant challenges for LLMs, and it is one of the key tasks for evaluating the reasoning ability of LLMs. With a huge amount of math problems in pretraining datasets, the pretrained LLMs (OpenAI, ; Gemini Team et al., ; Touvron et al., ) are able to solve simple problems, yet struggle with more complicated reasoning. To overcome that, the chain-of-thought (Wei et al., ; Fu et al., ) type prompting algorithms were proposed. These techniques were effective in improving the performance of LLMs on reasoning tasks without modifying the model parameters. The performance was further improved by supervised fine-tuning (SFT; Cobbe et al., ; Liu et al., ; Yu et al., ) with high quality question-response pairs with full CoT reasoning steps.

#### Application of Reward Models in Mathematical Reasoning of LLMs.

To further improve the LLM’s math reasoning performance, verifiers can help to rank and select the best answer when multiple rollouts are available. Several works (Huang et al., ; Luo et al., ) have shown that using LLM as verifier is not suitable for math reasoning. For trained verifiers, two types of reward models are commonly used: Outcome Reward Model (ORM) and Process Reward Model (PRM). Both have shown performance boost on math reasoning over self-consistency (Cobbe et al., ; Uesato et al., ; Lightman et al., ), yet evidence has shown that PRM outperforms ORM (Lightman et al., ; Wang et al., ). Generating high quality process supervision data is the key for training PRM, besides expensive human annotation (Lightman et al., ), Math-Shepherd (Wang et al., ) and MiPS (Wang et al., ) explored Monte Carlo estimation to automate the data collection process with human involvement, and both observed large performance gain. Our work shared the essence with MiPS and Math-Shepherd, but we explore further in collecting the process data using MCTS.

#### Monte Carlo Tree Search (MCTS).

MCTS (Świechowski et al., ) has been widely adopted in reinforcement learning (RL). AlphaGo (Silver et al., ) and AlphaGo Zero (Silver et al., ) were able to achieve great performance with MCTS and deep reinforcement learning. For LLMs, there are planning algorithms that fall in the category of tree search, such as Tree-of-Thought (Yao et al., ), Reasoning-via-Planing (Hao et al., ) and inference-time MCTS (Feng et al., ). Most of the work focuses on tree-like decoding to find the best output.

## 3 Methods

### 3.1 Process Supervision

Process supervision is a concept proposed to differentiate from outcome supervision. The reward models trained with these objectives are termed Process Reward Models (PRMs) and Outcome Reward Models (ORMs), respectively. In the ORM framework, given a query $q$ (e.g., a mathematical problem) and its corresponding response $x$ (e.g., a model-generated solution), an ORM is trained to predict the correctness of the final answer within the response. Formally, an ORM takes $q$ and $x$ and outputs the probability $p=\mathrm{ORM}(q,x)$ that the final answer in the response is correct. With a training set of question-answer pairs available, an ORM can be trained by sampling outputs from a policy model (e.g., a pretrained or supervised fine-tuned LLM) using the questions and obtaining the correctness labels by comparing these outputs with the golden answers.

In contrast, a PRM is trained to predict the correctness of each intermediate step $x_{t}$ in the solution. Formally, $p_{t}=\mathrm{PRM}([q,x_{1:t-1}],x_{t})$, where $x_{1:i}=[x_{1},\ldots,x_{i}]$ represents the first $i$ steps in the solution. This provides more precise and fine-grained feedback than ORMs, as it identifies the exact location of errors. Process supervision has also been shown to mitigate incorrect reasoning in the domain of mathematical problem solving. Despite these advantages, obtaining the intermediate signal for each step’s correctness to train such a PRM is non-trivial. Previous work (Lightman et al., ) has relied on hiring domain experts to manually annotate the labels, which is and difficult to scale.

### 3.2 Process Annotation with Monte Carlo Method

In two closely related works, Math-Shepherd (Wang et al., ) and MiPS (Wang et al., ), the authors propose an automatic annotation approach to obtain process supervision signals using the Monte Carlo method. Specifically, a “completer” policy is established that can take a question $q$ and a prefix solution comprising the first $t$ steps $x_{1:t}$ and output the completion — often referred to as a “rollout” in reinforcement learning — of the subsequent steps until the final answer is reached. As shown in Fig. 2(a), for any step of a solution, the completer policy can be used to randomly sample $k$ rollouts from that step. The final answers of these rollouts are compared to the golden answer, providing $k$ labels of answer correctness corresponding to the $k$ rollouts. Subsequently, the ratio of correct rollouts to total rollouts from the $t$-th step, as represented in Eq. 1, estimates the “correctness level” of the prefix steps up to $t$. Regardless of false positives, $x_{1:t}$ should be considered correct as long as any of the rollouts is correct in the logical reasoning scenario.

$$ $c_{t}=\mathrm{MonteCarlo}(q,x_{1:t})=\frac{\mathrm{num}(\text{correct rollouts from $t$-th step})}{\mathrm{num}(\text{total rollouts from $t$-th step})}$ (1) $$

Taking a step forward, a straightforward strategy to annotate the correctness of intermediate steps in a solution is to perform rollouts for every step from the beginning to the end, as done in both Math-Shepherd and MiPS. However, this brute-force approach requires a large number of policy calls. To optimize annotation efficiency, we propose a binary-search-based Monte Carlo estimation.

Monte Carlo estimation using binary search. As suggested by Lightman et al. (), supervising up to the first incorrect step in a solution is sufficient to train a PRM. Therefore, our objective is locating the first error in an efficient way. We achieve this by repeatedly dividing the solution and performing rollouts. Assuming no false positives or negatives, we start with a solution with potential errors and split it at the midpoint $m$. We then perform rollouts for $s_{1:m}$ with two possible outcomes: (1) $c_{m}>0$, indicating that the first half of the solution is correct, as at least one correct answer can be rolled out from $m$-th step, and thus the error is in the second half; (2) $c_{m}=0$, indicating the error is very likely in the first half, as none of the rollouts from $m$-th step is correct. This process narrows down the error location to either the first or second half of the solution. As shown in Fig. 2(b), by repeating this process on the erroneous half iteratively until the partial solution is sufficiently small (i.e., short enough to be considered as a single step), we can locate the first error with a time complexity of $O(k\log M)$ rather than $O(kM)$ in the brute-force setting, where $M$ is the total number of steps in the original solution.

Figure: (a) Monte Carlo estimation of a prefix solution.
Refer to caption: x1.png

### 3.3 Monte Carlo Tree Search

Although binary search improves the efficiency of locating the first error in a solution, we are still not fully utilizing policy calls as rollouts are simply discarded after stepwise Monte Carlo estimation. In practice, it is necessary to collect multiple PRM training examples (a.k.a., triplets of question, partial solution and correctness label) for a question (Lightman et al., ; Wang et al., ). Instead of starting from scratch each time, we can store all rollouts during the process and conduct binary searches from any of these rollouts whenever we need to collect a new example. This approach allows for triplets with the same solution prefix but different completions and error locations. Such reasoning structures can be represented as a tree, as described in previous work like Tree of Thought (Yao et al., ).

Formally, consider a state-action tree representing detailed reasoning paths for a question, where a state $s$ contains the question and all preceding reasoning steps, and an action $a$ is a potential subsequent step from a specific state. The root state is the question without any reasoning steps: $r_{\text{root}}=q$. The policy can be directly modeled by a language model as $\pi(a|s)=\mathrm{LM}(a|s)$, and the state transition function is simply the concatenation of the preceding steps and the action step, i.e., $s^{\prime}=\mathrm{Concatenate}(s,a)$.

Collecting PRM training examples for a question can now be formulated as constructing such a state-action tree. This reminds us the classic Monte Carlo Tree Search (MCTS) algorithm, which has been successful in many deep reinforcement learning applications (Silver et al., , ). However, there are some key differences when using a language model as the policy.
First, MCTS typically handles an environment with a finite action space, such as the game of Go, which has fewer than $361$ possible actions per state (Silver et al., ). In contrast, an LM policy has an infinite action space, as it can generate an unlimited number of distinct actions (sequences of tokens) given a prompt. In practice, we use temperature sampling to generate a fix number of $k$ completions for a prompt, treating the group of $k$ actions as an approximate action space. Second, an LM policy can sample a full rollout until the termination state (i.e., reaching the final answer) without too much overhead than generating a single step, enabling the possibility of binary search. Consequently, we propose an adaptation of the MCTS algorithm named OmegaPRM, primarily based on the one introduced in AlphaGo (Silver et al., ), but with modifications to better accommodate the scenario of PRM training data collection. We describe the algorithm details as below.

#### Tree Structure.

Each node $s$ in the tree contains the question $q$ and prefix solution $x_{1:t}$, together with all previous rollouts $\{(s,r_{i})\}_{i=1}^{k}$ from the state. Each edge $(s,a)$ is either a single step or a sequence of consecutive steps from the node $s$. The nodes also store a set of statistics,

$$ $\{N(s),\mathrm{MC}(s),Q(s,r)\},$ $$

where $N(s)$ denotes the visit count of a state, $\mathrm{MC}(s)$ represents the Monte Carlo estimation of a state as specified in Eq. 1, and $Q(s,r)$ is a state-rollout value function that is correlated to the chance of selecting a rollout during the selection phase of tree traversal. Specifically,

$$ $Q(s,r)=\alpha^{1-\mathrm{MC}(s)}\cdot\beta^{\frac{\mathrm{len}(r)}{L}},$ (2) $$

where $\alpha,\beta\in(0,1]$ and $L>0$ are constant hyperparameters; while $\mathrm{len}(r)$ denotes the length of a rollout in terms of number of tokens.
$Q$ is supposed to indicate how likely a rollout will be chosen for each iteration and our goal is to define a heuristic that selects the most valuable rollout to search with. The most straightforward strategy is uniformly choosing rollout candidates generated by the policy in previous rounds; however, this is obviously not an effective way. Lightman et al. () suggests surfacing the convincing wrong-answer solutions for annotators during labeling. Inspired by this, we propose to prioritize supposed-to-be-correct wrong-answer rollouts during selection. We use the term supposed-to-be-correct to refer to the state with a Monte Carlo estimation $\mathrm{MC}(s)$ closed to $1$; and use wrong-answer to refer that the specific rollout $r$ has a wrong final answer. The rollout contains mistakes made by the policy that should have been avoided given its high $\mathrm{MC}(s)$. We expect a PRM that learns to detect errors in such rollouts will be more useful in correcting the mistakes made by the policy.
The first component in Eq. 2, $\alpha^{1-\mathrm{MC}(s)}$, has a larger value as $\mathrm{MC}(s)$ is closer to $1$. Additionally, we incorporate a length penalty factor $\beta^{\frac{\mathrm{len}(r)}{L}}$, to penalize excessively long rollouts.

#### Select.

The selection phase in our algorithm is simpler than that of AlphaGo (Silver et al., ), which involves selecting a sequence of actions from the root to a leaf node, forming a trajectory with multiple states and actions. In contrast, we maintain a pool of all rollouts $\{(s_{i},r^{i}_{j})\}$ from previous searches that satisfy $0<\mathrm{MC}(s_{i})<1$. During each selection, a rollout is popped and selected according to tree statistics, $(s,r)=\operatorname*{arg\,max}_{(s,r)}[Q(s,r)+U(s)]$, using a variant of the PUCT (Rosin, ) algorithm,

$$ $U(s)=c_{\text{puct}}\frac{\sqrt{\sum_{i}N(s_{i})}}{1+N(s)},$ (3) $$

where $c_{\text{puct}}$ is a constant determining the level of exploration. This strategy initially favors rollouts with low visit counts but gradually shifts preference towards those with high rollout values.

#### Binary Search.

We perform a binary search to identify the first error location in the selected rollout, as detailed in Section 3.2. The rollouts with $0<\mathrm{MC}(s)<1$ during the process are added to the selection candidate pool. All divide-and-rollout positions before the first error become new states. For the example in Fig. 2(b), the trajectory $s[q]\rightarrow s[q,x_{1:4}]\rightarrow s[q,x_{1:6}]\rightarrow s[q,x_{1:7}]$ is added to the tree after the binary search. The edges $s[q]\rightarrow s[q,x_{1:4}]$ and $s[q,x_{1:4}]\rightarrow s[q,x_{1:6}]$ are correct, with $\mathrm{MC}$ values of $0.25$ and $0.5$, respectively; while the edge $s[q,x_{1:6}]\rightarrow s[q,x_{1:7}]$ is incorrect with $\mathrm{MC}$ value of 0 0.

#### Maintain.

After the binary search, the tree statistics $N(s)$, $\mathrm{MC}(s)$, and $Q(s,r)$ are updated. Specifically, $N(s)$ is incremented by $1$ for the selected $(s,r)$. Both $\mathrm{MC}(s)$ and $Q(s,r)$ are updated for the new rollouts sampled from the binary search. This phase resembles the backup phase in AlphaGo but is simpler, as it does not require recursive updates from the leaf to the root.

#### Tree Construction.

By repeating the aboved process, we can construct a state-action tree as the example illustrated in Fig. 1. The construction ends either when the search count reaches a predetermined limit or when no additional rollout candidates are available in the pool.

### 3.4 PRM Training

Each edge $(s,a)$ with a single-step action in the constructed state-action tree can serve as a training example for the PRM. It can be trained using the standard classification loss

$$ $\mathcal{L}_{\text{pointwise}}=\sum_{i=1}^{N}\hat{y}_{i}\log y_{i}+(1-\hat{y}_ {i})\log(1-y_{i}),$ (4) $$

where $\hat{y}_{i}$ represents the correctness label and $y_{i}=\mathrm{PRM}(s,a)$ is the prediction score of the PRM.
Wang et al. () have used the Monte Carlo estimation as the correctness label, denoted as $\hat{y}=\mathrm{MC}(s)$.
Alternatively, Wang et al. () have employed a binary labeling approach, where $\hat{y}=\mathbf{1}[\mathrm{MC}(s)>0]$, assigning $\hat{y}=1$ for any positive Monte Carlo estimation and $\hat{y}=0$ otherwise.
We refer the former option as pointwise soft label and the latter as pointwise hard label.
In addition, considering there are many cases where a common solution prefix has multiple single-step actions, we can also minimize the cross-entropy loss between the PRM predictions and the normalized pairwise preferences following the Bradley-Terry model (Christiano et al., ). We refer this training method as pairwise approach. We use the pointwise soft label when evaluating the main results in Section 4.1, and a comparion of the three objectives are discussed in Section 4.3.

## 4 Experiments

#### Data Generation.

We conduct our experiments on the challenging MATH dataset (Hendrycks et al., ). We use the same training and testing split as described in Lightman et al. (), which consists of $12$K training examples and a subset with $500$ representative problems from the original $4.5$K testing examples introduced in Hendrycks et al. (). We observe similar policy performance on the full test set and the subset. For creating the process annotation data, we use the questions from the training split and set the search limit to $100$ per question, resulting $1.5$M per-step process supervision annotations. We use $\alpha=0.5$, $\beta=0.9$ and $L=500$ for calculating $Q(s,r)$ in Eq. 2; and $c_{\text{puct}}=0.125$ in Eq. 3.

#### Base model.

As mentioned in previous studies (Lightman et al., ; Wang et al., , ), the quality of the policy model significantly influences the quality of sampled model responses, thereby affecting the PRM data quality. Lightman et al. () obtain their base model by fine-tuning GPT-4 (OpenAI, ) on MathMix, a corpus of $1.5$B math-related tokens. Meanwhile, Wang et al. () employed various base models fine-tuned on MetaMath (Yu et al., ) for their policy models.
Similarly, we tune a pretrained Gemini Pro (Gemini Team et al., ) by distilling knowledge from Gemini Ultra on math instruction datasets, resulting in a policy model that achieves an accuracy of approximately $51$% on the MATH test set.
This results in a policy model significantly smaller than GPT-4 used in Lightman et al. (), enabling more efficient data sampling while maintaining competitive math problem-solving capabilities. All the PRMs are trained based on the pretrained Gemini Pro.

#### Metrics and baselines.

We evaluate the PRM-based majority voting results following Wang et al. () using PRMs trained on different datasets. The final solution score is calculated by the product of scores across all steps. Baseline datasets include PRM800K (Lightman et al., ) and Math-Shepherd (Wang et al., ), both publicly available. Additionally, we generate a process annotation dataset with our Gemini policy model using the brute-force approach described in Wang et al. (), referred to as MiPS in subsequent sections.

### 4.1 Main Results

Figure: Figure 3: A comparison of PRMs trained with different process supervision datasets, evaluated by their ability to search over many test solutions using a PRM-weighted majority voting. We visualize the variance across many sub-samples of the $256$ solutions we generated in total per problem.
Refer to caption: x4.png

Fig. 3 presents the performance comparison of PRMs trained on various process annotation datasets. OmegaPRM consistently outperforms the other datasets. Specifically, the fine-tuned Gemini Pro achieves $69.4$% accuracy on MATH using OmegaPRM-weighted majority voting. It shows superior performance comparing to both human annotated PRM800K but also automatic annotated Math-Shepherd and MiPS. More specifically, when the number of samples is small, all the PRM models outperformed the majority vote. However, as the number of samples increases, the performance of other PRMs gradually converges to the same level of the majority vote. In contrast, our PRM model continues to demonstrate a clear margin of accuracy.

### 4.2 Step Distribution

An important factor in process supervision is the number of steps in a solution and the length of each step. Previous works (Lightman et al., ; Wang et al., , ) use rule-based strategies to split a solution into steps, e.g., using newline as delimiters. In contrast, we propose a more flexible method for step division, treating any sequence of consecutive tokens in a solution as a valid step. We observe that many step divisions in Math-Shepherd lack semantic coherence to some extent. Therefore, we hypothesize that semantically explicit cutting is not necessary for training a PRM.

Figure: Figure 4: Number of steps distribution.
Refer to caption: x5.png

In practice, we first examine the distribution of the number of steps per solution in PRM800K and Math-Shepherd, as shown in Fig. 4, noting that most solutions have less than $20$ steps. During binary search, we aim to divide a full solution into $16$ pieces. To calculate the expected step length, we divide the average solution length by $16$. The binary search terminates when a step is shorter than this value. The resulting distributions of step lengths for OmegaPRM and the other two datasets are shown in Fig. 5. This flexible splitting strategy produces a step length distribution similar to that of the rule-based strategy.

Figure: Figure 5: Step length distribution in terms of number of tokens.
Refer to caption: x7.png

### 4.3 PRM Training Objectives

**Table 1: Comparison of different training objectives for PRMs.**
|  | Soft Label | Hard Label | Pairwise |
| --- | --- | --- | --- |
| PRM Accuracy (%) | 70.1 | 63.3 | 64.2 |

As outlined in Section 3.4, PRMs can be trained using multiple objectives. We construct a small process supervision test set using the problems from the MATH test split. We train PRMs using pointwise soft label, pointwise hard label and pairwise loss respectively, and evaluate how accurately they can classify the per-step correctness. Table 1 presents the comparison of different objectives, and the pointwise soft label is the best among them with $70.1$% accuracy.

## 5 Limitations

There are some limitations with our paper, which we reserve for future work:

#### Automatic process annotation is noisy.

Our method for automatic process supervision annotation introduces some noise because false positives and negatives, but experiments indicate that it can still effectively train a PRM. The PRM trained on our dataset performs better than one trained on the human-annotated PRM800K dataset. The precise impact of noise on PRM performance remains uncertain. For future research, a comprehensive comparison of human and automated annotations should be conducted. One other idea is to integrate human and automated annotations, which could result in more robust and efficient process supervision.

#### Human supervision is still necessary.

Unlike the work presented in AlphaGo Zero (Silver et al., ), our method requires the question and golden answer pair. The question is necessary for LLM to start the MCTS and the golden answer is inevitable for the LLM to compare its rollouts with and determine the correctness of the current step. This will limit the method to the tasks with such question and golden answer pairs. Therefore, we need to adapt the current method further to make it suitable for open-ended tasks.

## 6 Conclusion

In conclusion, we introduce OmegaPRM, a divide-and-conquer Monte Carlo Tree Search algorithm, designed to automate the process supervision data collection for LLMs. By efficiently pinpointing the first error in the Chain-of-Thought and balancing data quality, OmegaPRM addresses the shortcomings of existing methods. Our automated approach enables the collection of over 1.5 million process supervision annotations, which are used to train a PRM. Leveraging this automated process supervision with the weighted self-consistency algorithm, we improve LLM mathematical reasoning performance, achieving a 69.4% success rate on the MATH benchmark — a 18.4% absolute increase over the base model which amounts to a relative improvement of 36%. Additionally, our method significantly reduces data collection costs compared to human annotation and brute force Monte-Carlo sampling. These findings highlight OmegaPRM’s potential to enhance LLM capabilities in complex multi-step reasoning tasks.

## 7 Acknowledgements

We would like to express our deepest gratitude to Matt Barnes, Jindong Chen and Rif A. Saurous, for their support and helpful feedback to our work. We also thank Peiyi Wang for clarifying the details in Math-Shepherd and providing insightful suggestions.

## Peer Reviews

confidence: 3
contribution: 3
initial_rating: 6
presentation: 3
questions: - How do the value of $\alpha$.$\beta$, L and $c_{puct}$ are selected empirically?
- Will the collected step annotation data, or the PRM, be released to public?
soundness: 3
strengths: - This paper collects a large size of step annotation data without human labelling for math reasoning. Step-wise data is more fine-grained and enable many potentials such as PRM training.

- When preparing the data, the authors contract a space-action tree in math reasoning environment with a efficient binary search approach to locate where a solution starts to make mistake.

- With the trained PRM as verifier, the math reasoning capability improves a bit compared to previous approaches.
summary: This paper proposes to train a PRM as verifier for LLM math reasoning. Since human annotation for step-wise reasoning is expensive, the authors propose to use mcts score as the annotation signals. To enhance the efficiency of construct tree, a binary search method is used to accelerate pruning. Trained on the collected step supervision data, the PRM is able to help LLM outperform previous methods on math reasoning in inference time.
weaknesses: - This paper aims to improve MCTS efficiency by binary search the first incorrect step and reusing rollouts. However, the efficiency gain described in the experiment section is very vague. The authors only report they can generate much more examples with same computational cost. Since efficiency is one major claim of this paper, it would be more clear to give more details, e.g., with same hardware environment, how much exact time the proposed method can save compared to existing approaches. 

- A candidate poll of all rollouts from the binary search is maintained for later selection in mcts, which might increases memory / storage overhead. The authors could discuss more, e..g, with experiments results, about the time-space efficiency trade-off.

---

confidence: 4
contribution: 2
initial_rating: 3
presentation: 1
questions: - Consider including a broader range of experiments to evaluate the generalizability of OmegaPRM across different reasoning domains.

- It might be helpful to discuss more explicitly the limitations of relying on human-annotated data alongside your automated methods, perhaps by providing quantitative analysis on the impact of noise on performance metrics.
soundness: 1
strengths: - The automated process reduces data collection costs significantly compared to traditional human annotation methods.
summary: The paper introduces OmegaPRM, a divide-and-conquer Monte Carlo Tree Search (MCTS) algorithm aimed at automating the collection of process supervision data for large language models (LLMs). It efficiently identifies the first error in a reasoning chain, thus improving the performance of LLMs in mathematical reasoning tasks, demonstrated by a significant improvement in accuracy on the MATH benchmark.
weaknesses: - While OmegaPRM's efficiency is emphasized, a direct comparison with methods that rely on human annotations and noise mitigation strategies would enhance its practical evaluation.

- Present only the results of Gemini and Gemma on MATH500 and GSM8K.

- The accuracy gain is minimal and may be due to variance; the accuracy improvement mentioned in the abstract is not solely attributable to OmegaPRM.

- The proposed OmegaPRM primarily combines MCTS and binary search, which limits its novelty.

---

confidence: 4
contribution: 2
initial_rating: 5
presentation: 2
questions: 1. Given the higher inference cost associated with using reward models, does the method ultimately reduce the overall cost of inference?
1. Is the method scalable? For instance, how could one expect to improve MATH500 to 90% accuracy by iterating on this method?
1. How effective is the method when the base model is either very weak or very strong (e.g., performance improvement on o1)?
soundness: 3
strengths: 1. The paper significantly enhances the efficiency of generating process labels by maintaining a tree structure of stepwise derivations and efficiently expanding the tree to minimize the number of required rollouts.
1. The application of binary search to pinpoint the first incorrect step is a novel approach.
summary: This paper proposes an efficient automated method for labeling each step in a process reward model. The core concept involves using binary search to identify the first incorrect step in a rollout and applying a tree-based search to explore the sample space. The resulting artifact contains 1.5 million stepwise annotations. The authors demonstrate the method's effectiveness by comparing the quality of process reward models (PRMs) trained with this dataset to those trained on previously proposed datasets.
weaknesses: 1. Empirical results on the MATH and GSM8K datasets indicate a clear upper bound on this distillation-based self-improvement method, showing that performance improvement is constrained by the initial capability of the base model (e.g., Gemini Pro and Gemma 2).
1. The improvement observed on the GSM8K dataset is particularly questionable, as it shows a less than 2% gain compared to majority voting.
1. This paper needs to improve its presentation. On page 3, L159, the sub-indece in x are inconsistent. On page 4, L163 `which is and difficult _?_ to scale`. On page 5, L267, `(s,r)` stands for a full rollout, while `(s,a)` represents a on-step rollout. The duplicate notations are confusing.

Meta-review: This paper proposes a new MCTS-based algorithm for the efficient collection of high-quality data for learning Process Reward Model (PRM), and show the improvements gained by proposed methods on existing benchmarks for math problems. While reviewers raised several questions concerning the experiment details, efficiency and the legitimacy of results, it's unfortunate that authors was not able to provide any rebuttal to the reviews. We thus recommend rejection.

Decision: Reject