请遵循下面内容，总结下面的内容；然后基于qwen模型生成训练代码和推理代码，要求1，必须体现论文的所有创新内容；2，代码必须完整且能够直接运行

Training Language Models to Self-Correct via Reinforcement Learning
Aviral Kumar*+,1, Vincent Zhuang*+,1, Rishabh Agarwal*,1, Yi Su*,1, JD Co-Reyes1, Avi Singh1, Kate Baumli1, Shariq Iqbal1, Colton Bishop1, Rebecca Roelofs1, Lei M Zhang1, Kay McKinney1, Disha Shrivastava1, Cosmin Paduraru1, George Tucker1, Doina Precup1, Feryal Behbahani†,1 and Aleksandra Faust†,1 1Google DeepMind, *Equal Contribution, +Randomly ordered via coin flip, †Jointly supervised.
Self-correction is a highly desirable capability of large language models (LLMs), yet it has consistently been found to be largely ineffective in modern LLMs. Existing approaches for training self-correction either require multiple models or rely on a more capable model or other forms of supervision. To this end, we develop a multi-turn online reinforcement learning (RL) approach, SCoRe, that significantly improves an LLM’s self-correction ability using entirely self-generated data. To build SCoRe, we first show that variants of supervised fine-tuning (SFT) on offline model-generated correction traces are insufficient for instilling self-correction behavior. In particular, we observe that training via SFT either suffers from a distribution mismatch between the training data and the model’s own responses or implicitly prefers only a certain mode of correction behavior that is often not effective at test time. SCoRe addresses these challenges by training under the model’s own distribution of self-generated correction traces and using appropriate regularization to steer the learning process into learning a self-correction strategy that is effective at test time as opposed to simply fitting high-reward responses for a given prompt. This regularization prescribes running a first phase of RL on a base model to generate a policy initialization that is less susceptible to collapse and then using a reward bonus to amplify self-correction during training. When applied to Gemini 1.0 Pro and 1.5 Flash models, we find that SCoRe achieves state-of-the-art self-correction performance, improving the base models’ self-correction by 15.6% and 9.1% respectively on the MATH and HumanEval benchmarks.
1. Introduction
Large language models (LLMs) have proven to be a useful tool in reasoning and scientific domains such as mathematical problem-solving and coding (Lozhkov et al., 2024; Shao et al., 2024; Team, 2024). An aspirational property of LLMs in such settings is to able to implement algorithms: strategies that help the LLM to use computation and interaction to improve its response on the test-time query. Modern LLMs largely do not implement algorithms reliably: for instance, consider a problem setting that requires models to detect and revise (or “self-correct”) their own responses to a given test-time query, so as to be able to eventually arrive at the best-possible final response. This sort of self-correction capability has been shown by several recent works to be severely lacking in current LLMs, especially in the absence of external input (also referred to as intrinsic self-correction) (Huang et al., 2023; Kamoi et al., 2024).
To make progress towards the eventual goal of teaching LLMs to implement algorithms to handle challenging inputs, we study a special instance of training LLMs to implement self-correction strategies to fix their mistakes “on-the-fly”. This should be possible: on many queries where current LLMs fail, they still contain the underlying “knowledge” needed to arrive at the correct response but are unable to correctly elicit and draw inferences about their own knowledge when needed (Snell et al., 2024). For example, strong LLMs can often successfully complete a sub-part of a math proof when prompted with the remainder, but may not be able to complete it from scratch. In a similar vein, leveraging their previous responses should, in principle, enable LLMs to improve their subsequent ones. Nevertheless,self-correction has remained elusive, highlighting the need for going beyond existing training paradigms.
How can we instill LLMs with self-correction abilities? Prior attempts toward self-correcting LLMs either rely on prompt-engineering (Kim et al., 2023; Madaan et al., 2023) or fine-tuning models specifically for self-correction (Havrilla et al., 2024b; Qu et al., 2024; Welleck et al., 2023; Yuan et al., 2024). While the former class of approaches often fail to effectively perform meaningful intrinsic self-correction, existing fine-tuning based approaches require running multiple models upon inference, e.g., a separate verifier or refinement model (Havrilla et al., 2024b; Welleck et al., 2023), or require oracle “teacher” supervision to guide the process of self-correction (Qu et al., 2024), without which self-correction does not necessarily outperform independent uncorrelated attempts at the problem. We develop an approach that is effective at self-correction without any of the aforementioned requirements. Our approach, Self-Correction via Reinforcement Learning (SCoRe), trains only a single model that can both produce a response to a reasoning problem and also correct errors despite not receiving any oracle feedback. More importantly, SCoRe teaches this ability to models entirely by training on self-generated data, without any oracle.
We begin by studying the failure modes of existing fine-tuning based strategies in this setting. We observe that running supervised fine-tuning on multi-turn self-correction traces coupled with rejection sampling (i.e., a “multi-turn” variant of STaR (Zelikman et al., 2022)) often amplifies the model’s bias to not make any error corrections. A minimal edit strategy appears somewhat optimal as it inhibits the model from learning to make correct responses worse in the second attempt, even though it does not instill self-correction abilities to the model. If the training dataset for SFT is altered to explicitly down-weight certain correction traces that only make minor edits, then the resulting training is able to avoid collapse. However, it suffers from the curse of distributional shift: a correction strategy learned by training on off-policy data does not necessarily enable the model to be succeed at correcting its own mistakes.
How does SCoRe work? SCoRe addresses the aforementioned challenges with SFT by utilizing online multi-turn reinforcement learning (RL). Concretely, SCoRe runs multi-turn RL on self-generated data to avoid challenges with distribution mismatch between training and inference. To avoid the failure mode of learning a minimal edit strategy when training on on-policy data, we train SCoRe in two stages, with each stage regularizing the learning process to not collapse its behavior. The first stage replaces SFT in conventional LLM fine-tuning workflows by training a model initialization that optimizes correction performance while constraining the first attempt to be close to the base model. The second stage runs multi-turn RL to optimize reward at both attempts, while using a reward bonus term that encourages improving responses from the first attempt to the second. Both the initialization and the reward bonus ensure that the model cannot simply learn to produce the best first-attempt response and only minorly edit it. Overall, SCoRe is able to elicit knowledge from the base model to enable positive self-correction.
Our main contribution is SCoRe, a multi-turn RL approach for teaching LLMs how to correct their own mistakes. To the best of our knowledge, SCoRe is the first approach to attain significantly positive intrinsic self-correction: relative to base Gemini models, our method attains an absolute 15.6% gain on self-correction for reasoning problems from MATH (Hendrycks et al., 2021) and an absolute 9.1% gain on coding problems from HumanEval (Chen et al., 2021). We additionally motivate the design of SCoRe by extensively studying the failure modes of baseline approaches, which broadly indicate that reinforcement learning may play an essential role in self-learned self-correction.2. Related Work
Prior works study self-correction for LLMs under a variety of assumptions and problem settings. The most prominent problem settings include problems where external input tokens from an environment is available, for e.g., agentic tasks (Liu et al., 2023), code repair (Jain et al., 2024), and tool use (Chen et al., 2023). While self-correction with external feedback is possible with strong proprietary models (Pan et al., 2023), even the strongest models struggle in the substantially more challenging setting when no external input is available (Kamoi et al., 2024). This setting is called intrinsic self-correction. Prior work that attempts to amplify intrinsic correction abilities are largely based on prompting and fine-tuning.
Prompting for intrinsic self-correction. Recent work demonstrates that LLMs struggle to self-correct their reasoning errors without external feedback and naïvely running self-correction can degrade perfor- mance (Huang et al., 2023; Qu et al., 2024; Tyen et al., 2024; Zheng et al., 2024). These experimental studies are at odds with prior work (Kim et al., 2023; Madaan et al., 2023; Shinn et al., 2023) and largely stem from mismatched assumptions on the setting (Kamoi et al., 2024). For example, Kim et al. (2023); Shinn et al. (2023) use oracle ground-truth answers during self-correction that may not be available generally. Madaan et al. (2023) use weak prompts for initial responses, thereby perhaps overestimate the improvement possible by self-correction. This indicates that there is no major work showing successful intrinsic self-correction via prompting alone. In the context of code self-repair, Olausson et al. (2023) show that even when strong models are prompted with some form of partial feedback, e.g., showing test-cases but not the desired outcomes on those test-cases, they are often unable to correct their mistakes. Sampling multiple responses in parallel attains much better results in Olausson et al. (2023).
Fine-tuning for intrinsic self-correction. To address the issues with prompting off-the-shelf models alone, several works run supervised fine-tuning (SFT) or weighted SFT on the LLM to generate a revision given an initial response. Nonetheless typical works in this literature rely on oracle feedback: e.g., obtaining revisions directly from human annotators (Saunders et al., 2022) or stronger models (Qu et al., 2024; Ye et al., 2023). Our work aims to train for self-correction entirely without the use of bigger models or humans, when the learner itself is asked to generate its own training data. Similar to these prior works, we assume access to a reward function for evaluating model-generated outputs, similar to Akyürek et al. (2023); Welleck et al. (2023); Zhang et al. (2024). Other approaches build pipelines with multiple models for self-correction (e.g., GLoRE (Havrilla et al., 2024b), Self-correct (Welleck et al., 2023), or Akyürek et al. (2023); Paul et al. (2023)). While this can lead to good results, these pipelines do not quite tackle self-correction and require system design for serving multiple models at deployment.
Problem. If 𝑛 ≡ 2 (mod 7), then find the remain- der when (𝑛 + 2)(𝑛 + 4)(𝑛 + 6) is divided by 7.
SCoRe turn 1 solution (incorrect). Since 𝑛 ≡ 2 (mod 7), we can write 𝑛 = 7𝑘+2 for some integer 𝑘. Substituting, we get
(𝑛 + 2)(𝑛 + 4)(𝑛 + 6) = (7𝑘 + 4)(7𝑘 + 6)(7𝑘 + 8) ≡4⋅6⋅8 (mod7)
≡ 192 (mod 7) ≡ 1 (mod 7).
Final Answer: The final answer is 1. I hope it is correct.
Self-correction instruction. There might be an error in the solution above because of lack of un- derstanding of the question. Please correct the error, if any, and rewrite the solution.
SCoRe turn 2 solution (correct). Since 𝑛 ≡ 2 (mod 7), we can write 𝑛 = 7𝑘+2 for some integer 𝑘. Substituting, we get
(𝑛 + 2)(𝑛 + 4)(𝑛 + 6) = (7𝑘 + 4)(7𝑘 + 6)(7𝑘 + 8) ≡4⋅6⋅8 (mod7)
≡4⋅6⋅1 (mod7) ≡ 24 (mod 7) ≡ 3 (mod 7).
Final Answer: The final answer is 3. I hope it is correct.



Standard training
Loss response (y)
Foundation model
prompt (x)
Loss
Improved
response (y2) Foundation model trained with ScoRe
Training via SCoRe (Ours)
prompt (x)
first attempt (y1)
Figure 2 ∣ An example trace and the problem setting of self-correction.


Multi-turn RL for LLMs. Our approach utilizes a multi-turn policy gradient approach for training for self-correction, which extends the single-turn approach of Ahmadian et al. (2024) and can be viewed as an instantiation of the hierarchical RL framework from Zhou et al. (2024). Generally, prior work at the intersection of LLMs and multi-turn RL builds value-based (Farebrother et al., 2024; Shani et al., 2024; Snell et al., 2022; Zhou et al., 2024), policy-based (Shao et al., 2024; Xiong et al., 2024), and model-based (Hong et al., 2024) approaches. While this line of work builds machinery to do RL (i.e., optimize rewards) in a multi-turn Markov decision process (MDP), our primary contribution in this paper is to devise a formalization, for learning self-correction behavior instead of the RL machinery itself.
Self-correction with external feedback. Many works study self-correction with additional feedback from the environment, most commonly in the setting of code generation, where unit test results or compiler execution feedback are available (Chen et al., 2024; Jain et al., 2024; Olausson et al., 2023). Largely these works prompt models to reason about code execution; Ni et al. (2024) propose a self-training method that leverages execution traces, though only evaluate it on correcting a fixed dataset of errors.
The problem setting of self-correction. SCoRe trains a model to not just produce the best possible response, but instead aims to train the model to produce the best final response in the final attempt. In the second turn, extra input in the form of an instruction asking the model to correct itself or model-generated may be provided.
3. Preliminaries and Problem Setup
Our goal is to develop an approach for training LLMs to improve their own predictions by entirely
training on self-generated data. As discussed so far, we situate ourselves in the intrinsic self-correction
setting (Huang et al., 2023), where models attempt to correct their initial responses without any external
feedback. Concretely, given a dataset 𝒟 = {(𝒙 , 𝒚∗)}𝑁 of problems 𝒙 and oracle responses 𝒚∗, we will 𝑖 𝑖 𝑖=1 𝑖 𝑖
train an LLM policy 𝜋𝜃(⋅∣[𝒙, ˆ𝒚1∶𝑙, 𝑝1∶𝑙]) that, given the problem 𝒙, previous 𝑙 model attempts ˆ𝒚1∶𝑙 at the
problem, and auxiliary instructions 𝑝1∶𝑙 (e.g., instruction to find a mistake and improve the response),
solves the problem 𝒙 as correctly as possible. This formalism is akin to the multi-turn MDP in Qu et al.
(2024). Moreover, we assume access to a reward function / verifier 𝑟̂(𝒚, 𝒚∗), such as a string-matching
based answer checking function) that evaluates correctness of response 𝒚 by comparing with the oracle ∗
We aim to find a model 𝜋(□∣◦) (which we will also refer to as a policy) mapping a sequence of input tokens ◦ to a sequence of output tokens □ that maximizes the correctness reward obtained from the verifier at the end of 𝑙 + 1 turns. Formally, this can be written as the following multi-step RL objective:
𝜋 𝜃
Crucially, note that unlike standard SFT or prevalent RL fine-tuning workflows that train the policy 𝜋 to directly produce an optimal response ˆ𝒚 for an input 𝒙, Equation 1 trains 𝜋 over multiple turns / attempts simultaneously, where intermediate turn responses ˆ𝒚1∶𝑙 are supervised indirectly with the final rewards.
A base RL approach for fine-tuning LLMs. Our RL toolkit is based on on-policy policy gradient. These methods, such as REINFORCE with a KL-divergence penalty against a fixed model (Ahmadian et al., 2024), are widely used in RL fine-tuning of LLMs, primarily in setting of single-turn RL from human feedback. Formally, such policy gradient approaches train a policy 𝜋𝜃(⋅∣𝒙) to optimize:
𝜃
response𝒚 .Critically,wedonotassumeaccesstosuchafunctionattest-timeandthemodelitselflearns to deduce whether there was a mistake and corrects it, as is often the case in e.g. mathematical reasoning problems. An example and overview of our problem setting is given in Figure 2.
max E ∗ [𝑟̂(ˆ𝒚 ,𝒚∗)]. (1)
𝒙,𝒚 ∼𝒟,ˆ𝒚𝑙+1∼𝜋𝜃(⋅∣[𝒙,ˆ𝒚0∶𝑙,𝑝1∶𝑙]) 𝑙+1
maxE [𝑟̂(𝒚,𝒚∗)−𝛽𝐷 (𝜋(⋅∣𝒙)∣∣𝜋 (⋅∣𝒙))], (2)
𝒙𝑡,𝒚𝑡∼𝜋𝜃(⋅∣𝒙𝑡) 𝑡 1 𝐾𝐿 𝜃 𝑡 ref 𝑡 where 𝜋ref is a reference anchor policy, typically chosen to be a pre-trained or SFT policy.
Metrics. For measuring self-correction performance, we report and analyze the following metrics: (1) Accuracy@t1: the model’s accuracy at the first attempt; (2) Accuracy@t2: the model’s accuracy at the second attempt, (3) Δ(t1, t2): the net improvement in model accuracy between the first and second attempts, which measures the efficacy of self-correction, (4) Δi→c(t1, t2): the fraction of problems that are incorrect in the first attempt but become correct at the second attempt, which measures how many new problems can self-correction solve; and (5) Δc→i(t1, t2): the fraction of problems that are correct in the first attempt but become incorrect at the second attempt, which measures how well the model is able to understand what makes a response correct.
4. Supervised Fine-Tuning on Self-Generated Data is Insufficient for Self-Correction
Perhaps a natural approach to train for self-correction is to utilize some form of supervised fine-tuning on data collected from a base model. Variants of this recipe have been shown to scale well in single- turn reasoning problems (Havrilla et al., 2024a; Singh et al., 2023; Zelikman et al., 2022). Can such SFT-based approaches be effective for self-correction as well?
Table 1 ∣ Self-correction performance after training on 𝒟STaR and 𝒟SFT. For both approaches, we find that the gap between second-attempt and first-attempt performance (Δ(𝑡1, 𝑡2)) is either overly negative or very small. In addition, both approaches erroneously modify a correct response to be incorrect, i.e., reflected in a high Δc→i(𝑡1, 𝑡2) and a low Δi→c(𝑡1, 𝑡2).
Method
Base model STaR 𝒟StaR
Accuracy@t1 Accuracy@t2
52.6% 41.4%
55.4% 41.2% 52.4% 54.2%
Δ(t1, t2) -11.2%
-14.2% 1.8%
Δi→c(t1, t2) 4.6% 5.4%
5.4%
Δc→i(t1, t2) 15.8%
19.6% 3.6%
Pair-SFT 𝒟SFT Table 2 ∣ Self-correction performance after training on 𝒟+ and 𝒟+
. Performance improves for STaR indicating that a higher coverage dataset helps improve performance, but not for SFT where traning on traces where both responses are correct
STaR SFT forces the model to simply not make any changes to its first-attempt response, no matter how correct or incorrect that is.
Method
Base model
+
Accuracy@t1
52.6%
53.6% 55.0%
Accuracy@t2
41.4%
54.0% 55.0%
Δ(t1, t2) -11.2%
0.4% 0%
Δi→c(t1, t2) 4.6%
2.6% 0%
Δc→i(t1, t2) 15.8%
2.2% 0%
STaR 𝒟StaR +
Pair-SFT 𝒟SFT
In this section, we perform an empirical study to answer this question. We study two approaches: STaR (Zelikman et al., 2022) and an approach akin to Welleck et al. (2023) that trains only one model. We do not use learned process or outcome verifiers to guide correction traces, so our setup differs from SFT in Snell et al. (2024). We find that such methods improve substantially compared to the base model’s self-correction behavior, but still fail to attain a positive self-correction rate and produce a worse second attempt compared to their first attempt. By probing trained models, we find that these failures largely stem from supervised fine-tuning amplifying the initial bias of the base model resulting in only minor changes to its first-attempt response. While these failures can be addressed if a different distribution over initial responses is used for training, doing so fails to induce effective self-correction behavior under the model’s own response distribution. Either way, learning is affected by distribution shift or amplification of the base model’s bias. These observations motivate the design of our method in Section 5.
4.1. Analysis Setup: Methods and Dataset Construction
Methods. We prompt off-the-shelf models to obtain a large number of two-turn self-correction traces. The STaR approach, analogous to ReST𝐸𝑀 (Singh et al., 2023), filters these trajectories to only retain those that successfully revise incorrect responses and runs SFT on the resulting dataset. In contrast, Welleck et al. (2023) use the base model data from above to construct sets of correct and incorrect responses and then generates “synthetic” repair traces by pairing incorrect responses with correct ones. We study a variant of their method we call Pair-SFT, which does not train a separate corrector model and does not augment this initial dataset with multi-turn traces.
Dataset construction. We perform our study on the MATH dataset, and generate self-correction traces
by prompting the Gemini 1.5 Flash (Reid et al., 2024) using temperature 1.0. We construct datasets for
STaR and Pair-SFT as follows: (1) 𝒟 ∶= {(𝒙 , ˆ𝒚−, ˆ𝒚+)}𝑁 , where ˆ𝒚− and ˆ𝒚+ correspond to incorrect
(a) Histograms of edit distance ratios on MATH 500. (c) Pair-SFT edit distance ratios.
Figure 3 ∣ Edit distance between first-attempt and second-attempt responses obtained from fine-tuned models, our approach (SCoRe) and the base model. Observe that while training on self-generated error correction traces inherits the bi-modal distribution of edits as the base model, SFT tends to be quite conservative.
and correct responses appearing within a single sequence of attempts from the current model, and (2) 𝒟 ∶= {(𝒙 , ˆ𝒚−, ̃𝒚+)}𝑁 , where ̃𝒚+ is a random correct response for problem 𝒙, randomly sampled
SFT 𝑖𝑖𝑖𝑖=1 𝑖 from the set of all first-turn and second-turn responses produced by the model. We then ran supervised
fine-tuning on both of these datasets: following Singh et al. (2023), we repeat 3 iterations of collecting and running SFT on 𝒟STaR, but only 1 epoch on 𝒟SFT given the large dataset size.
4.2. Empirical Findings
We plot the self-correction performance of the Gemini 1.5 Flash before and after running fine-tuning on 𝒟STaR (3 iterations) and 𝒟SFT in Table 1. We find that although Δ(t1, t2) is substantially higher for Pair-SFT relative to the base model, there is still little benefit to doing self-correction (1.8% gain). By considering Δi→c and Δc→i, we find that SFT mainly helps by reducing the number of correct problems that are mistakenly changed to incorrect after revision, and does not significantly increase the fraction of incorrect first attempts that are correctly repaired. This result is consistent with prior studies on intrinsic self-correction that have found negligible or even negative Δ(t1, t2) (Huang et al., 2023; Qu et al., 2024).
We also find that unlike Pair-SFT, training on 𝒟STaR does not reduce Δc→i, indicating that the STaR policy
does not have a clear understanding of when and when not to make modifications. We hypothesize
that this discrepancy is due to the data distributions of 𝒟𝑆𝐹𝑇 and 𝒟𝑆𝑇𝑎𝑅: the former covers a much more
diverse space of revision trajectories due to the nature of random pairing. Observing this, we also
++
trained on an extended version of 𝒟STaR (and also 𝒟SFT), which additionally presents more tuples with both correct responses. We would expect the addition of such “correct-to-correct” data to prevent the model from erroneously revising a correct response and, at the very least, restrict the modification of a correct response into only another correct response. As shown in Table 2, perhaps interestingly, we find that including such data has opposite effects on STaR and SFT: for STaR, inclusion of this data helps substantially, though it still results in barely any meaningful self-correction performance. On the other hand, for SFT, inclusion of this data overly biases the model to not change its answer at all.
Diving deeper: analyzing self-correction behavior. We also visualized how the STaR and SFT models edit their responses. In particular, we measured edit distance ratio, defined as the edit distance be- tween the responses normalized by the total length of both the responses, to sum- marize the extent to which models mod- ify their first-attempt response. As shown in Figure 3a, while the base model some- times makes substantially large edits to the original response, models fine-tuned on 𝒟STaR and 𝒟SFT are overly conserva- tive, and often make no edits at all. We will show in Section 5 that our proposed method SCoRe is able to avoid amplifying this bias of not making changes, without any explicit training for controlling how much to edit solutions.
0.10 0.08 0.06 0.04 0.02
0.4 0.3 0.2 0.1
Training Language Models to Self-Correct via Reinforcement Learning
0.0
0.2
0.4 Epoch fraction
0.8
1.0
Figure 4 ∣ Tracking self-correction performance on a different sets of first-attempt responses: (a) “fixed validation”: first response is distributed identically as the training set, (b) “self-generated”: first response is generated by the learner itself. Observe that over the course of training, while accuracy of correcting a fixed validation set of responses largely stays constant (and perhaps even slightly improves) and the accuracy on the training data improves substantially (note the different axis for the training set accuracy on the right), the model’s correction abilities its own first-attempt response degrade substantially. This indicates that training on a fixed offline dataset may not be effective at inducing self-correction abilities due to distribution shift.
We also plotted edit distance ratios in cor- rection traces appearing in the training data and compared it against the ratios in self-correction traces generated by STaR and Pair-SFT on training and validation problems in Figures 3b and 3c. While STaR produces qualitatively similar edit distance ratios on both train and validation problems (meaning that it performs within the training distribution very well), we still observe somewhat of a discrepancy between train and validation edit distance ratios for SFT. This means that Pair-SFT is not very effective at generalizing to new problems from the same distribution.
Seeing the discrepancy in the edit distance ratios between train and validation problems for Pair-SFT, we also analyzed the self-correction accuracy of the SFT model on a fixed set of first-attempt responses and self-generated first-attempt responses in Figure 4. We observe clearly different behaviors on both training vs. validation as well as static vs self-generated first-attempt distributions: while the model is able to optimize training correction accuracy well and also maintains its initial correction accuracy on first attempts appearing in the validation set (distributed i.i.d. to the training distribution), its self-correction accuracy degrades with more training.
Takeaways: Insufficiency of SFT
We showed two distinct sources of failure of SFT methods: STaR latched onto only one mode of correction behavior that made minor changes, and training via Pair-SFT on data with wider coverage resulted in a degradation in self-correction abilities on responses from the model’s distribution of initial responses, due to distribution shift. This implies that an effective approach must satisfy two desiderata: [D1] it should directly train on self-generated traces to alleviate distribution mismatch that affected SFT (Figure 4), and [D2] self-generated traces employed should prevent a collapse to making minor edits during learning. We will next develop an online RL approach that addresses these challenges with a careful initialization and reward shaping.
These results more generally suggest that offline supervised fine-tuning is likely not effective at making use of additional in-context tokens to learn nuanced algorithmic behaviors, due to challenges of distribution shift in training data and amplification of certain pathological behaviors that seem promising on the training data but do not learn the right strategy.
5. SCoRe: Self-Correction via Multi-Turn Reinforcement Learning
To develop an effective approach for teaching LLMs to self-correct by training entirely on self-generated data, we have to satisfy the two desiderata discussed above. Utilizing on-policy RL in our method is a natural way to satisfy desideratum [D1]. Our approach, SCoRe will extend standard single-turn RL (Equation 2) to the multi-turn setting under the hierarchical framework from Zhou et al. (2024).
Key challenges. While multi-turn RL that optimizes Equation 1 addresses the issue with distribution shift, it is unclear whether it also satisfies desideratum [D2]. Base model initializations for fine-tuning present a highly-skewed distribution over edit distances (Figure 3a), which makes them susceptible to mode collapse, a well-known issue in deep RL (Mei et al., 2020; Schaul et al., 2019). Even if the base model could produce a less-skewed distribution over edit distance ratios during self-correction, we still need the RL training procedure to learn a self-correction strategy from the training data that generalizes to test prompts.
To see whether RL training can learn a self-correction strategy by purely optimizing the final attempt’s reward, we ran a naïve multi-turn RL baseline to optimize Equation 1. We find empirically in Figure 5 that while the performance of each attempt improves with training via naïve multi-turn RL, the performance of the second attempt is tightly coupled with the first attempt. As training progresses, standard multi-turn converges to be overly biased towards not changing its response, resulting in no self-correction ability.
Why does this happen? There are at least two equally good solutions when optimizing a policy with RL on the training data: (i) learning to improve from the first to the second attempt, or (ii) learning to produce the best first-attempt response followed by no correction in the second attempt. Of course only the former strategy generalizes to new problems, but an overparameterized LLM may not necessarily learn strategy (i) instead of (ii), since both of these strategies appear equally optimal on the training set.
Abstractly, learning the “meta strategy” of self-correction during training is difficult unless the “direct” strategy that optimizes reward appears less viable. Conceptually, this is similar to the memorization challenge in meta-learning (Yin et al., 2019), which suggests that when provided with mutually exclusive tasks, few-shot meta-learning is likely to recover the supervised learning solution (without relying on additional context from the few shots) that directly predicts the output for an input. In our case, this is analogous to not self-correcting past attempts, but rather directly attempting produce a good response.
Method overview. Our approach SCoRe is designed to address the key challenges identified above. SCoRe operates in two stages. In the first stage (Stage I), SCoRe trains a model initialization that is less prone to collapse in subsequent RL by explicitly teaching the model to correct its second-attempt responses under a relatively static first-attempt distribution. This initialization amplifies the coverage of second-attempt responses given the model’s own first attempt distribution, with a bias towards high-reward responses. We then use this model initialization to seed the actual multi-turn RL run (Stage II). To bias learning towards a solution that learns to self-correct, we shape the reward at the second attempt to provide a large positive reward bonus in favor of self-correction. Both stages bias the model towards learning
(a) Evolution of training reward with more training. When training with naïve multi-turn RL, the responses at both the attempts become tightly coupled together, leading to poor cov- erage for subsequent iterations and worse learning progress. Stage I in SCoRe is explicitly designed to alleviate this, leading to increased exploration and better final performance.
(b) Frequency in which the learner proposes a different answer in the second turn. Without explicitly modifying the policy initialization as in SCoRe, the policy quickly learns to not change its answer, leading to poor exploration. This is evident by a decrease in the number of prompts for which the second attempt produces a different answer.
Training Language Models to Self-Correct via Reinforcement Learning
0.6 0.8
0.0
0.6 0.8 1.0
Figure 5 ∣ Failure modes of naïve multi-turn RL training for inducing self-correction capabilities. These results indicate that some explicit approach to alter the policy initialization is required for learning. Stage I in SCoRe exactly tackles this.
self-correction by initializing the model appropriately and controlling subsequent RL.
5.1. Stage I: Training a Model Initialization to Prevent Collapse
The goal of Stage I of SCoRe is to obtain a good model initialization by improving the base model’s coverage over second-attempt responses so that subsequent training for self-correction is less susceptible to collapse we observed with STaR/SFT. While this would typically be done via SFT in LLM fine-tuning pipelines, our experiments in Section 4 show that SFT trains the model to latch onto only one mode of correction behavior. As a result, an SFT initialization is not expected to generate informative and exploratory traces for learning. Therefore, we do not initialize our RL training with SFT and instead develop Stage I to produce a separate initialization that is less prone to collapse.
To do so, we explicitly fine-tune the base model to produce high-reward revisions at the second attempt, while forcing the model to not change its first-attempt response, by constraining the first-attempt response distribution as close as possible to that of the base model using a KL-divergence. While does this appear sub-optimal – a first-attempt response with fewer mistakes could be corrected to a better second-attempt response – but as we will show, this stage is critical in reducing the base model’s bias towards simply coupling the first and second-attempt distributions, and thus becoming trapped in a local optima when actual multi-turn RL is run. Formally, the objective we optimize is:
𝜃
where 𝛽2 is a hyper parameter designed to enforce a strict KL penalty only on the first attempts to avoid shift of the first-turn responses (denoted by the term in blue). Note that we still utilize the default KL-divergence penalty from Equation 2, but that is applied with a much smaller weight and is omitted from Equation 3 for brevity. Indeed, we show that unlike naïve multi-turn RL, Stage I is more effective at decoupling the two responses (Figure 5b).
Figure 6 ∣ An overview of our approach (SCoRe). SCoRe trains a model in two stages: Stage I: instead of running SFT (that produces pathological amplification of biases) to initialize RL training, we train a good initialization that can produce high-reward responses in the second-attempt while mimicking the base model’s initial response at the first attempt. Stage II: jointly optimizing both attempts, where the latter uses a shaped reward to incentivize discovery of the self-correction strategy instead of the simple strategy of product the best first response followed by making any minor edits to it in the second attempt.
5.2. Stage II: Multi-Turn RL with Reward Shaping
Equipped with a model initialization from Stage I that exhibits a substantially smaller bias to couple the two responses, the second stage of SCoRe now trains responses at both attempts towards optimizing reward in line with Equation 1. Of course, we also want to make sure to not degrade the first-attempt responses in the process. Therefore, for two-turn self-correction problem, we train the policy 𝜋𝜃(⋅∣⋅) against the following objective:
2 [∑𝑟̂(𝒚,𝒚∗)−𝛽𝐷 (𝜋(⋅∣𝒙)∣∣𝜋 (⋅∣𝒙))], (4)
𝑖=1
maxE 𝜃
𝒙1,𝒚1∼𝜋𝜃(⋅∣𝒙),𝒚2∼𝜋𝜃(⋅∣[𝒙1,𝑝1]) where 𝒙𝑖, 𝑖 ∈ {1, 2} corresponds to the set of input tokens passed as context to the model. SCoRe optimizes
Equation 4 with an on-policy policy gradient approach.
Reward shaping to incentivize self-correction. As discussed earlier, it is unclear if running RL for
optimizing Equation 4 prefers a strategy that incentivizes self-correction over finding the best first-attempt
response and keeping it unchanged, since both of these strategies appear equally good on the small
training dataset. To mitigate this issue, we bias the learning problem towards the self-correction strategy
via reward shaping: by providing a higher emphasis to traces that flip correctness from the first attempt
to the second, we can bias the model to learn a self-correction solution. Concretely, given an two-turn
on-policy rollout 𝜏 = {𝒙 , ˆ𝒚 , 𝑟̂(𝒚 , 𝒚∗), 𝒙 , ˆ𝒚 , 𝑟̂(𝒚 , 𝒚∗)} (where 𝒙 denotes all the tokens from the first 1112222
turn concatenated with each other), we propose to modify the reward 𝑟̂(𝒚 , 𝒚∗) used for training in 2
Equation 4, at the second attempt with an additional bonus 𝑏̂(𝒚 ∣𝒚 , 𝒚∗) given by: 21
𝑏̂(𝒚 ∣𝒚 ,𝒚∗)=𝛼⋅(𝑟̂(𝒚 ,𝒚∗)−𝑟̂(𝒚 ,𝒚∗)), (5) 2121
where 𝛼 is a positive constant multiplier, ideally a real number significantly larger than 1.0. Adding this bonus to the second attempt only emphasizes traces that flip the correctness of the response and assigns a heavy negative penalty to transitions that change a correct response to incorrect in the second attempt. In contrast, transitions that do not flip correctness of the response and are likely to lead to collapse of not
making meaningful edits contribute much less to the overall loss. Thus, the addition of this bonus should regularize the training process from collapsing on to the “direct” solution that might look optimal on the training set but does not produce self-correction behavior on new examples.
5.3. Putting it Together and Implementation Details
Our approach is illustrated pictorially in Figure 6. SCoRe applies stages I and II in an interleaved fashion for multiple iterations (e.g., Figure 5 shows two applications each of Stage I and II). We use a small 𝛽1 for all experiments (i.e., the coefficient on the KL divergence penalty against the base model in Equation 2), and found that setting 𝛽2 = 10𝛽1 to work sufficiently well in our experiments. In practice, one can also use an adaptive 𝛽2 that attempts to balance the magnitudes of the first-attempt KL regularization and the second-attempt policy loss. In some of our experiments, we also choose to amplify the coverage of states used for on-policy RL by incorporating first-attempt solutions obtained by repeatedly sampling the base model as offline prompts in RL. We find that incorporating this data, especially in Stage 2, where the first-turn policy may have drifted further from that of the base model, can have substantial benefits especially when attempting to learn from limited data.
Takeaways and Implications
The core insight behind our method is that we must make it more attractive to learn the more nuanced algorithmic strategy instead of collapsing to an ungeneralizable behavior mode. Further- more, to avoid the challenge of distribution shift, this must be done on self-generated online data. SCoRe instantiates this principle when learning the model initialization for multi-turn RL (Stage I) and when using a reward bonus to prevent training from producing non-correcting strategies (Stage II).
6. Experimental Evaluation
The goal of our experiments is to demonstrate the efficacy of SCoRe in teaching LLMs how to correct their own mistakes by training on their own data. In addition, we also aim to understand the impact of each of the components of SCoRe in contributing to this ability. To this end, we perform a comparative evaluation of SCoRe against prior methods that also use self-generated data to train for self-correction, and run several ablation studies on two representative reasoning tasks where error correction is crucial.
Tasks. We mainly focus on math and coding tasks: (a) math problem solving on MATH (Hendrycks et al., 2021), and (b) code generation on MBPP (Austin et al., 2021) and HumanEval (Chen et al., 2021) for evaluating the efficacy of our approach. Concretely, we use the following train-test splits in our experiments: (1) MATH: following Lightman et al. (2023), we augment the MATH training set with 4500 problems from the test set, and report results on the remaining 500 problems; and (2) Code generation: we train on MBPP and report results on HumanEval, which does not expose test cases to the model.
Evaluation protocol and metrics. We report the self-correction accuracy on a number of tasks with two sequential attempts at the problem, i.e., one round of self-correction. For MBPP, following the evaluation protocol of Ni et al. (2024), we also report results on MBPP-R, an offline repair task that requires correcting incorrect first-attempt programs generated from PaLM 2.
Models. For all of our experiments on MBPP, we fine-tune Gemini 1.0 Pro and for MATH, we fine- tune Gemini 1.5 Flash. For all evaluations, we use greedy decoding (i.e. temperature 0), except for inference-compute scaling in Section 6.2 where we set temperature to be 0.7. For all training methods, we Table 3 ∣ Performance of SCoRe on MATH. Observe that SCoRe not only attains a higher accuracy at both attempts, but also provides the most positive self-correction performance Δ(t1, t2), and improves upon the number of problems that move from incorrect to correct, while substantially reducing the number of problems that become incorrect in the second attempt.
Approach Accuracy@t1
Base model 52.6% Self-Refine 52.8%
Accuracy@t2
41.4% 51.8% 54.0% 54.2%
64.4%
Δ(t1, t2) -11.2%
-1.0% 0.4% 1.8%
4.4%
Δi→c(t1, t2) Δc→i(t1, t2) 4.6% 15.8%
3.2% 4.2% 2.6% 2.2% 5.4% 3.6%
5.8% 1.4%
+
SCoRe (Ours)
STaR w/ 𝒟StaR Pair-SFT w/ 𝒟SFT
53.6% 52.4%
60.0%
attempted to use a fixed budget of model samples and gradient updates, and do not vary hyperparameters such as learning rate and batch size between runs. For all RL runs, we selected checkpoints with the highest training reward, although a small held-out validation set of problems can also be used. Additional details about the experimental setup can be found in the Appendix.
Evaluation prompts. We use a zero-shot CoT prompting for evaluation on MATH, zero-shot prompting for evaluation on HumanEval, and the canonical three-shot prompt for first-attempt training samples on MBPP. At the second attempt, we utilize an instruction that does not reveal the correctness of the previous answer, but asks the model to attempt to deduce whether a mistake exists in its first attempt response, and, if so, potentially rewrite its response. Full prompts and self-correction instructions can be found in Appendix A.
Prior approaches and comparisons. We compare SCoRe to prior approaches and baselines. We compare to Self-Refine (Madaan et al., 2023), a representative prompting-based approach to elicit self-correction behaviors from a model, akin to Reflexion (Shinn et al., 2023). Of the fine-tuning based approaches, we compare to Pair-SFT based on the approach from Welleck et al. (2023), and multi-turn STaR (Singh et al., 2023; Zelikman et al., 2022) that fine-tune the model by minimizing negative log-likelihood on synthetically paired repair traces and successful repair traces respectively. Due to a difference in assumptions and base models, we cannot compare SCoRe directly with results in prior papers that utilize oracle information (e.g., RISE (Qu et al., 2024)) or run multiple models (e.g., GLoRE (Havrilla et al., 2024b), the full version of Self-Correct (Welleck et al., 2023) with a refinement model), largely because these comparisons will be apples-to-oranges with distinct setups, different refinement or oracle models.
6.1. Benchmark Results
MATH. Our results are in Table 3, as well as in Figure 1. SCoRe exhibits substantially stronger performance on both direct and self-correction accuracies. Notably, the intrinsic self-correction gain Δ(t1, t2) of 4.4% is the first significantly positive delta, despite having fewer incorrect problems to correct by virtue of its higher Accuracy@t1. Relative to the base 1.5 Flash model, SCoRe improves Δ(t1, t2) by 15.6%, and Accuracy@t2 by 23.0%, and over the nearest baseline, Pair-SFT, by 10.2% and 2.6% respectively.
By observing the frequency of problems that change from incorrect at from the first attempt to correct in the second attempt and vice versa, we see that SCoRe improves the rate at which it fixes incorrect answers (14.5%, compared to 9.5% for base) and reduces the proportion of correct answers it changes.Table 4 ∣ Performance of SCoRe on HumanEval. Observe that ScoRe attains the highest accuracy at the second attempt (Accuracy@t2), and also substantially improves the number of problems that become correct with the use of additional sequential attempts. In addition, SCoRe also attains the highest correction rate on MBPP-R, an offline repair task.
Table 5 ∣ Ablation studies to understand the impact of various components in SCoRe. Observe that while single-turn training is effective at optimizing the first-attempt accuracy of the model, it leads to degradation in the second attempt. Instead, SCoRe allows us to attain a higher second-attempt accuracy even though it attains a slightly worse first-attempt accuracy. The performance improvements without Stage I or without reward shaping in SCoRe are small when measured by the difference in accuracy over the two attempts. Utilizing STaR generally leads to worse performance even when it is run from an effective Stage I checkpoint. These results highlight the importance of various components in SCoRe.
Method
SCoRe (Ours) w/o multi-turn training w/o Stage I w/o reward shaping w/ STaR instead of REINFORCE Stage II
Accuracy@t1
60.0% 61.8% 59.2% 60.0% 56.2%
Accuracy@t2 64.4%
59.4% 61.4% 62.6% 58.4%
Δ(t1, t2) 4.4%
-2.4% 2.2% 2.6% 2.2%
Code generation. Our results for the code generation task are shown in Table 4. Generally, we find that SCoRe achieves both improved self-correction as well as strong offline repair performance. For MBPP-R, we find that SCoRe improves the base model from 47.3% to 60.6%, which is comparable to the gap between GPT-3.5 and GPT-4 (42.9% and 63.2% respectively) (Ni et al., 2024). Despite only training on MBPP, we find that SCoRe is especially effective at generalizing to HumanEval, achieving a 12.2% intrinsic self-correction delta, or 9% higher than the base model. By contrast, Pair-SFT works nearly as well on the static repair task MBPP-R, but actually degrades the base model when evaluated in the self-correction setting, thus underscoring the importances of on-policy sampling for self-correction.
6.2. Inference-Compute Scaling with Self-Correction
Next, we investigate if SCoRe can be used in conjunction with inference-time compute scaling strategies. To do so, we evaluate self-consistency decoding (Wang et al., 2022), also known as majority voting, where we sample a diverse set of solutions, and then select the most consistent answer among these solutions. Typically, the default strategy is to sample all solutions in parallel to perform majority voting. However, we show in Figure 1 (right) that instead of sampling 2𝐾 solutions in parallel, it is more compute-efficient to sample 𝐾 solutions in parallel, then perform one round of self-correction on each solution. With 32 solution budget per problem, parallel sampling shows a 7.4% accuracy gain, while combining it with sequential sampling using self-correction yields a 10.5% improvement.6.3. Ablation Studies: Understanding the Impact of SCoRe Components
Finally, we also present a number of ablation studies to understand the importance of various compo- nents in SCoRe. We perform these ablations on the MATH dataset. Concretely, we aim to answer the following questions: (1) the importance of multi-turn training: Can RL trained to maximize single-turn performance achieve better accuracy@t1 or accuracy@t2?; (2) the importance of multi-stage training: How essential is Stage I to SCoRe? In other words, why not run Stage II directly?; (3) the impact of reward shaping. How would removing the reward shaping terms affect performance of SCoRe in Stage II, assuming Stage I was done identically?; (4) the importance of on-policy RL: What if we replaced REINFORCE in Stage II with STaR?.
The results of all of these ablation experiments are shown in Table 5. As expected, single-turn training improves turn 1 performance, but has negative Δ(t1, t2). As shown in Figure 5, Stage I is critical to SCoRe; without it, the model achieves 2% lower Δ(t1, t2) and 3% lower accuracy@t2. Similarly, we find that removing reward shaping also hurts performance, indicating that the RL objectives in both stages play a significant role in teaching self-correction behavior. We also find that replacing REINFORCE with STaR in Stage II results in significantly lower absolute performance with no visible improvements in self-improvement performance, which contrasts with the findings in Havrilla et al. (2024a) that STaR and on-policy RL have similar convergence rates for single-turn RL. This suggests that leveraging on-policy samples is especially critical in the self-correction setting, which presents a multi-turn problem that admits potentially spurious solutions.
6.4. Qualitative Analysis of SCoRe
We also perform a qualitative investigation into how SCoRe addresses the self-repair shortcomings of base LLMs, and provide several examples in Appendix B. We find that SCoRe is able to refine its own responses in a variety of manners - rewriting the entire solution when necessary, or reproducing the correct parts of the solution, while revising the incorrect ones. For the latter, we interestingly find that SCoRe is especially adept at revising its computational mistakes, and even demonstrates a bias towards showing more steps in certain computations and manipulations in order to increase its probability of producing a correct answer. We additionally observe that the model learns to occasionally self-correct within a turn, e.g. MATH example 4.
7. Discussion, Limitations, and Conclusion
In this work, we investigated how to imbue LLMs with a self-correction strategy that enables them to correct their own responses on the fly, at test-time. Specifically, we proposed SCoRe, a multi-turn online reinforcement learning (RL) approach for training language models to correct their own mistakes, and demonstrated through extensive evaluations that it is the first method that can attain significantly positive intrinsic self-correction performance. To motivate the design of SCoRe, we rigorously analyzed the behavior of various fine-tuning baselines and identified failure modes in which the model learns a non-correcting strategy (e.g. learning to make no edits) under these approaches. SCoRe is designed to elicit a self-correcting strategy by utilizing a two-stage structure and reward shaping, both of which help prevent model collapse into not learning effective self-improvement behavior.
Limitations. There are various limitations of this work that also provide interesting avenues for future work. We did not train SCoRe for more than one round of iterative self-correction in this paper, which means that subsequent rounds of self-correction may not be as effective as the first one. An interesting avenue for future work is to train with more than two attempts via RL, which is already a common and
effective practice to obtain effective self-correction behavior over more than two rounds with SFT (Qu et al., 2024; Snell et al., 2024). Unifying Stages I and II of SCoRe is also an interesting avenue for research, since that would alleviate the limitation of running multiple steps and help in designing a more robust method.
Broader perspectives. Our work has several implications. First, it suggests that learning meta-strategies (e.g., self-correction in this paper) might require going beyond the standard paradigm of supervised fine-tuning followed by single-turn RL (as shown in Section 4). It demonstrates that multi-turn RL can provide for one such approach. Second, our results also hint that perhaps using more detailed or granular supervision when generating on-policy rollouts in multi-turn RL might further improve the model’s capabilities at implementing nuanced strategies: even though SCoRe did not use dense or fine-grained feedback, it was already able to improve performance of existing models substantially. Utilizing dense feedback is likely to complement our method well. Finally, the importance of our two-stage recipe (based on careful initialization and reward shaping) in obtaining positive self-correction perhaps more generally hints that some kind of regularization is required to ensure that LLMs learn nuanced strategies that can generalize well to novel, unseen queries at test-time.
Acknowledgements
The authors would like to thank Satinder Baveja, Kalesha Bullard, Gheorghe Comanici, Claire Cui, Valentin Dalibard, Angelos Filos, Yang Gao, Zoubin Ghahramani, Izzeddin Gur, Raia Hadsell, Clara Huiyi Hu, Melvin Johnson, Mina Khan, Balaji Lakshminarayanan, Yiran Mao, Hussain Masoom, Junhyuk Oh, Jordi Orbay, David Silver, and Yury Sulsky for helpful discussions, feedback, and sponsorship. We thank Amrith Setlur, Yuxiao Qu, Charlie Snell, Tianhe Yu, and Xinyang (Young) Geng for helpful discussions and feedback on an earlier version of the paper.
Author Contributions
AK and VZ led the paper, with substantial technical contributions from RA and YS. VZ led the experimen- tation in the final paper with AK, with support from RA and YS. AK and RA conceived the initial idea with advice and discussions from DS, FB, AF, JDC, AS, and GT. JDC, YS, AS, RA, and AK iterated on the methodology. The development of the final method was done by AK and VZ, with inputs from RA and FB. VZ led the infrastructure development, while RA, YS, CP, SI, KB, DS, and LMZ contributed to the infrastructure. AK, RA, FB, AF, DP, GT advised on the overall direction. AK and VZ wrote the manuscript, with input from all co-authors. KM provided program management. FB, and AF co-supervised the project.