papers/score/sau.json

{
  "paper_id": "score",
  "paper_title": "SCoRe: Self-Correction via Multi-Turn Reinforcement Learning",
  "D1": [
    {
      "id": "score-D1-001",
      "claim": "MATH training hyperparameters for SCoRe with Gemini 1.5 Flash base model: Adam optimizer, learning rate 5e-6, 3000 training steps, batch size 512, sampling temperature 1.0, reward shaping multiplier alpha=10, standard KL coefficient beta1=0.01, Stage I first-attempt KL coefficient beta2=0.1, discount factor gamma=0 (instantaneous reward only).",
      "source": "Appendix B, Table 5 (left)"
    },
    {
      "id": "score-D1-002",
      "claim": "MBPP code training hyperparameters for SCoRe with Gemini 1.0 Pro base model: Adam optimizer, learning rate 1e-5, 1500 training steps, batch size 128, sampling temperature 1.0, reward shaping multiplier alpha=10, standard KL coefficient beta1=0.01, Stage I first-attempt KL coefficient beta2=0.25.",
      "source": "Appendix B, Table 5 (right)"
    },
    {
      "id": "score-D1-003",
      "claim": "Core structural training parameters shared across all SCoRe tasks: 2 turns (one round of self-correction), reward shaping multiplier alpha constrained to be greater than 1.0, Stage I applies KL penalty exclusively on first-attempt distribution, checkpoint selection based on highest training reward, optional adaptive beta2 to balance first-attempt KL and second-attempt policy objectives.",
      "source": "Section 5.1, Section 5.2, Section 5.3, Section 6"
    },
    {
      "id": "score-D1-004",
      "claim": "Evaluation decoding configuration: greedy decoding at temperature 0 for main results, sampling temperature 0.7 for inference compute scaling experiments, sequential self-correction with K parallel samples plus one round of self-correction per sample under total solution budget per problem as hyperparameter.",
      "source": "Section 6, Section 6.2"
    },
    {
      "id": "score-D1-005",
      "claim": "Dataset composition for MATH and code experiments: MATH500 test set with 500 held-out problems (Lightman et al. 2023 split), training augmented with 4500 additional MATH test set problems, HumanEval benchmark (Chen et al. 2021) with no test case exposure to model, MBPP training with canonical 3-shot prompt for first-attempt training samples.",
      "source": "Section 6 (Tasks paragraph)"
    },
    {
      "id": "score-D1-006",
      "claim": "RL training backbone uses REINFORCE policy gradient with KL-divergence penalty against a fixed reference model (Ahmadian et al. 2024), using binary 0/1 reward: exact answer match for MATH, all test cases pass for code generation; oracle reward used only during training, not at test time.",
      "source": "Section 3, Eq 2, Section 6"
    }
  ],
  "D2": [
    {
      "id": "score-D2-001",
      "claim": "Multi-turn MDP objective for self-correction: max_{pi_theta} E_{x,y*~D, y_{l+1}~pi_theta(·|[x,y_{1:l},p_{1:l}])} [ sum_{i=1}^{l+1} r(y_i, y*) ], where pi_theta is the LLM policy, y_{1:l} are previous model attempts, p_{1:l} are auxiliary instructions (self-correction prompt), r is the oracle binary reward, and l=2 for one round of correction. The policy is trained to maximize reward across ALL attempts simultaneously, not just the final output.",
      "source": "Section 3, Eq 1"
    },
    {
      "id": "score-D2-002",
      "claim": "REINFORCE policy gradient with KL penalty (training backbone): max_theta E_{x_t, y_t~pi_theta(·|x_t)} [ r(y_t, y*) - beta1 * D_KL(pi_theta(·|x_t) || pi_ref(·|x_t)) ], where pi_ref is a frozen reference policy, beta1=0.01 is the standard KL penalty coefficient, and r is the binary reward. This base RL approach from Ahmadian et al. (2024) serves as the training backbone for all SCoRe stages.",
      "source": "Section 3, Eq 2"
    },
    {
      "id": "score-D2-003",
      "claim": "SCoRe Stage I objective for decoupled attempt initialization: max_theta E_{x1, y1~pi_theta(·|x1), y2~pi_theta(·|[x1,p1])} [ r(y2, y*) - beta2 * D_KL(pi_theta(·|x1) || pi_ref(·|x1)) ], where p1 is the self-correction instruction (does NOT reveal correctness), beta2 is the KL penalty applied ONLY to the first attempt (MATH: 0.1, MBPP: 0.25), and the default KL penalty from Eq 2 is also applied with small weight. Purpose: improve second-attempt reward while forcing the first-attempt distribution to stay close to the base model, preventing behavior collapse.",
      "source": "Section 5.1, Eq 3"
    },
    {
      "id": "score-D2-004",
      "claim": "SCoRe Stage II objective for joint multi-turn RL with reward shaping: max_theta E_{x1, y1~pi_theta(·|x1), y2~pi_theta(·|[x1,y1,p1])} [ sum_{i=1}^{2} r'(y_i, y*) - beta1 * D_KL(pi_theta(·|x_i) || pi_ref(·|x_i)) ], where r'(y1, y*) = r(y1, y*) (unchanged binary reward), r'(y2, y*) = r(y2, y*) + alpha * (r(y2, y*) - r(y1, y*)) with shaping bonus b = alpha * delta_r. Initialized from Stage I checkpoint. Jointly optimizes both attempts; without reward shaping, this collapses to producing the best first response with no edits.",
      "source": "Section 5.2, Eq 4"
    },
    {
      "id": "score-D2-005",
      "claim": "Reward shaping bonus for self-correction progress: b(y2 | y1, y*) = alpha * (r(y2, y*) - r(y1, y*)), where alpha is a positive constant multiplier (default 10, ideally >1.0), r is binary 0/1 correctness. With binary reward, the bonus equals +alpha for incorrect-to-correct transitions, 0 for unchanged correctness, and -alpha for correct-to-incorrect transitions. This biases Stage II away from the degenerate non-correcting solution.",
      "source": "Section 5.2"
    },
    {
      "id": "score-D2-006",
      "claim": "On-policy two-turn rollout generation: at each training step, sample first attempt y1~pi_theta(·|x1), compute binary reward r1=r(y1,y*), construct second-attempt context x2=concat([x1,y1,p1]), sample second attempt y2~pi_theta(·|x2), compute binary reward r2=r(y2,y*), and produce rollout tuple tau={x1,y1,r1,x2,y2,r2}. The self-correction instruction p1 does NOT reveal correctness; the model must autonomously detect and fix errors.",
      "source": "Section 5 (overview), Section 5.3"
    },
    {
      "id": "score-D2-007",
      "claim": "Binary reward function for MATH (answer matching): r_MATH(y, y*) = 1 if extract_answer(y) == y*, else 0, where extract_answer(y) parses the 'Final Answer: The final answer is $answer$' block from the response. Reward is binary (0/1) indicating exact answer match. Used only during training; oracle y* is NOT available at test time.",
      "source": "Section 6 (Tasks), Section 3"
    },
    {
      "id": "score-D2-008",
      "claim": "Binary reward function for code generation (test case passing): r_code(y, y*) = 1 if all_test_cases_pass(extract_code(y)), else 0, where extract_code(y) parses the code block and all_test_cases_pass executes the code against a hidden test suite. Reward is binary (0/1). Test cases are NOT exposed to the model at test time, especially for HumanEval.",
      "source": "Section 6 (Tasks), Section 3"
    },
    {
      "id": "score-D2-009",
      "claim": "Five self-correction evaluation metrics defined over N problems with binary correctness c1_i and c2_i at turns 1 and 2: (1) Accuracy@t1 = (1/N)*sum(c1_i), (2) Accuracy@t2 = (1/N)*sum(c2_i), (3) Delta(t1,t2) = Accuracy@t2 - Accuracy@t1 (net improvement), (4) Delta^{i->c} = sum((1-c1_i)*c2_i) / sum(1-c1_i) (fraction of incorrect first attempts corrected), (5) Delta^{c->i} = sum(c1_i*(1-c2_i)) / sum(c1_i) (fraction of correct first attempts broken). All use greedy decoding (temperature=0) for main results.",
      "source": "Section 3 (Metrics paragraph)"
    },
    {
      "id": "score-D2-010",
      "claim": "Edit distance ratio for diagnosing behavior collapse: edit_distance_ratio(y1, y2) = edit_distance(y1, y2) / (len(y1) + len(y2)), where edit_distance is the character-level edit distance between the two responses. Ratio equals 0 for identical responses; larger values indicate more aggressive editing. Defined in Section 4: 'edit distance between the responses normalized by the total length of both the responses'. Used to quantify editing aggressiveness; SFT methods produce low ratios (conservative edits) while SCoRe achieves higher ratios without collapsing.",
      "source": "Section 4, Figure 4"
    },
    {
      "id": "score-D2-011",
      "claim": "SCoRe two-stage training pipeline algorithm: Stage I initializes pi_theta from pi_ref, samples on-policy rollouts, computes Stage I loss L = -[r(y2,y*) - beta2 * D_KL(pi_theta(·|x1) || pi_ref(·|x1))], updates theta via REINFORCE gradient; Stage II initializes from Stage I checkpoint, samples on-policy rollouts, computes shaped reward r'(y2) = r(y2) + alpha*(r(y2)-r(y1)), computes Stage II loss with sum of rewards and KL penalties on both attempts, updates theta via REINFORCE gradient, and selects the checkpoint with highest training reward.",
      "source": "Section 5.1, Section 5.2, Section 5.3, Figure 7"
    },
    {
      "id": "score-D2-012",
      "claim": "SCoRe test-time inference procedure: first attempt y1 = argmax_y pi_theta(y|x1) via greedy decoding (T=0), self-correction instruction p1 prompts the model to detect and fix errors ('There might be an error...Please correct the error, if any, and rewrite the solution'), second-attempt context x2 = concat([x1,y1,p1]), second attempt y2 = argmax_y pi_theta(y|x2) via greedy decoding, return y2 as final answer. The model must AUTONOMOUSLY detect errors without any external feedback or oracle.",
      "source": "Section 5.3, Appendix C"
    },
    {
      "id": "score-D2-013",
      "claim": "Offline data augmentation for on-policy RL: sample y1_off ~ pi_ref(·|x1) from frozen base model; construct augmented batch B_aug = B_on ∪ {(x1, y1_off)} where B_on = {(x1, y1~pi_theta(·|x1))} is the on-policy rollout batch. For each offline pair, build augmented rollout tau_aug = {x1, y1_off, r(y1_off, y*), x2 = [x1, y1_off, p1], y2~pi_theta(·|x2), r(y2, y*)} and add to the RL objective in Eq.(4): max_theta E[Σ_{i=1}^{2} r'(y_i, y*) - beta1 D_KL(pi_theta(·|x_i) || pi_ref(·|x_i))]. Purpose: amplify coverage of first-attempt states when pi_theta(·|x1) has drifted from pi_ref.",
      "source": "Section 5.3, Eq.(4)"
    }
  ],
  "D3": [
    {
      "id": "score-D3-001",
      "claim": "MATH Self-Correction Benchmark: Compare SCoRe against prompting-based (Self-Refine) and fine-tuning-based (STaR, Pair-SFT) baselines on intrinsic self-correction for mathematical reasoning using Gemini 1.5 Flash. Models produce one initial solution and one self-correction attempt (two turns total). All methods use self-generated data only. Binary reward via exact answer match against ground truth, but oracle is NOT available at test time. Evaluation on MATH500 (500 held-out problems) using greedy decoding (T=0) with zero-shot CoT prompting. Metrics: Accuracy@t1, Accuracy@t2, Delta(t1,t2), Delta^{i->c}, Delta^{c->i}.",
      "source": "Section 6, Section 6.1, Table 2"
    },
    {
      "id": "score-D3-002",
      "claim": "Code Generation Self-Correction Benchmark: Compare SCoRe against baselines on code generation using Gemini 1.0 Pro. Models are trained on MBPP (canonical 3-shot prompt) and evaluated zero-shot on HumanEval (Chen et al. 2021) with NO test case exposure. Training uses binary rewards based on whether all test cases pass. At test time, models generate code and self-correct without access to test execution results. Metrics: Accuracy@t1, Accuracy@t2, Delta(t1,t2), Delta^{i->c}, Delta^{c->i}.",
      "source": "Section 6, Section 6.1, Table 3"
    },
    {
      "id": "score-D3-003",
      "claim": "Offline Code Repair Benchmark (MBPP-R): Evaluate models on a static offline repair task where they must correct incorrect first-attempt programs generated from PaLM 2. This is NOT self-correction — models see a fixed external first attempt rather than their own. Tests whether correction ability generalizes beyond self-generated errors. Metric: MBPP-R accuracy (fraction of programs correctly repaired).",
      "source": "Section 6 (Evaluation protocol), Table 3"
    },
    {
      "id": "score-D3-004",
      "claim": "Inference-Time Compute Scaling Experiment: Compare two strategies for spending a fixed compute budget of 32 solution samples per problem on MATH500: (A) parallel majority voting over 32 independent first attempts; (B) sequential self-correction with K=16 parallel samples each followed by one round of self-correction, then majority voting over the 16 corrected answers. Demonstrates that sequential self-correction is more compute-efficient than pure parallel sampling. Sampling temperature T=0.7 for all samples.",
      "source": "Section 6.2, Figure 1 (right)"
    },
    {
      "id": "score-D3-005",
      "claim": "Ablation Study on MATH: Systematically remove or replace each SCoRe component to measure its contribution. Five variants tested: (1) full SCoRe (Stage I + Stage II with reward shaping), (2) without multi-turn training (single-turn RL only), (3) without Stage I (Stage II directly from base model), (4) without reward shaping (remove bonus term, use raw reward for second attempt), (5) replace Stage II REINFORCE with STaR-style SFT on successful correction traces. All variants use identical hyperparameter budgets. Evaluated with greedy decoding (T=0) on MATH500. Metrics: Accuracy@t1, Accuracy@t2, Delta(t1,t2).",
      "source": "Section 6.3, Table 4"
    },
    {
      "id": "score-D3-006",
      "claim": "SFT Failure Mode Analysis: Empirically study why SFT-based approaches (STaR, Pair-SFT) fail at self-correction via two experiments. (A) Edit distance ratio analysis measuring how aggressively each method edits responses between attempts, comparing training and test-time distributions. (B) Distribution shift experiment evaluating correction accuracy on fixed first attempts (from initial model) vs. self-generated first attempts (from learner itself), demonstrating that offline correction gains do not transfer to the model's own mistakes. Uses Gemini 1.5 Flash. STaR runs 3 iterations; Pair-SFT runs 1 iteration; both tested with and without correct-to-correct data (+ variants).",
      "source": "Section 4, Table 1, Figure 4, Figure 5"
    },
    {
      "id": "score-D3-007",
      "claim": "Standard Multi-Turn RL Behavior Collapse Analysis: Run standard multi-turn RL (optimizing the base MDP objective directly without SCoRe's two-stage design or reward shaping) to demonstrate convergence to non-correcting behavior. Track training accuracy curves at turns 1 and 2, Delta(t1,t2) evolution, frequency of answer changes, and edit distance ratios throughout training. Compare with SCoRe Stage I to show how decoupled initialization prevents collapse.",
      "source": "Section 5, Figure 6"
    },
    {
      "id": "score-D3-008",
      "claim": "Multi-Attempt Scaling Analysis (Appendix A.1): Evaluate whether models trained for two-turn self-correction can generalize to more than two sequential attempts. Test models over 10 sequential self-correction attempts on MATH despite being trained only on two attempts. At each attempt, model receives problem + all previous attempts + correction instruction. Compare base model, Pair-SFT, and SCoRe on how performance evolves past the training distribution (2 turns).",
      "source": "Appendix A.1, Figure 8"
    },
    {
      "id": "score-D3-009",
      "claim": "Discount Factor Experiment (Appendix A.2): Test whether using non-zero discount factor gamma=0.8 with alpha=1.0 can elicit self-correction without collapsing, compared to the default gamma=0 with alpha=1.0. Track Delta(t1,t2), Accuracy@t1, and Accuracy@t2 during training to determine whether gamma>0 resolves behavior collapse.",
      "source": "Appendix A.2, Figure 9"
    }
  ],
  "D4": [
    {
      "id": "score-D4-001",
      "claim": "SCoRe training foundational ordering: (1) Multi-turn MDP objective defines the overall goal of maximizing total reward across all attempts -> (2) REINFORCE policy gradient with KL penalty provides the training backbone used by all stages -> (3) Stage I objective (decoupled attempt initialization) built on top of the REINFORCE-KL backbone -> (4) Stage II objective (joint multi-turn RL with reward shaping) built on top of Stage I checkpoint.",
      "source": "Section 5, Figure 7"
    },
    {
      "id": "score-D4-002",
      "claim": "Reward shaping bonus and Stage II joint optimization ordering: Stage I objective must be completed first (producing a model with decoupled attempt distributions) -> Stage II objective then applies joint optimization with the reward shaping bonus b = alpha * (r(y2) - r(y1)) to bias learning toward self-correction progress while preventing the degenerate non-correcting solution, followed by final checkpoint selection based on highest training reward.",
      "source": "Section 5.1, Section 5.2, Section 5.3"
    },
    {
      "id": "score-D4-003",
      "claim": "SCoRe two-stage training pipeline execution order: (1) Initialize pi_theta from pi_ref (frozen base model) -> (2) Stage I: decouple attempts via on-policy rollouts with KL penalty only on first attempt, selecting the checkpoint with decoupled distributions -> (3) Stage II: jointly optimize both attempts using shaped reward r'(y2)=r(y2)+alpha*(r(y2)-r(y1)) with KL penalties on both attempts -> (4) Select checkpoint with highest training reward -> (5) Optionally incorporate offline data augmentation in Stage II by sampling base model to generate additional first-attempt prompts. The two stages are sequential and MUST be run in order; skipping Stage I costs 2% lower Delta(t1,t2) and 3% lower Accuracy@t2.",
      "source": "Section 5.1, Section 5.2, Section 5.3, Figure 7, Section 6.3"
    },
    {
      "id": "score-D4-004",
      "claim": "MATH self-correction evaluation step sequence: (1) Train model on MATH training set + 4500 augmentation problems -> (2) For SCoRe: run Stage I (decouple attempts) then Stage II (joint optimization with reward shaping) -> (3) Evaluate on MATH500 (500 held-out problems) with greedy decoding (T=0), zero-shot CoT prompting -> (4) Report all 5 metrics: Accuracy@t1, Accuracy@t2, Delta(t1,t2), Delta^{i->c}, Delta^{c->i}.",
      "source": "Section 6, Section 6.1, Table 2"
    },
    {
      "id": "score-D4-005",
      "claim": "Code generation self-correction evaluation step sequence: (1) Train model on MBPP with binary test-case-passing reward -> (2) For SCoRe: run Stage I -> Stage II training -> (3) Evaluate zero-shot on HumanEval (Chen et al. 2021) with greedy decoding (T=0) -> (4) Report all 5 metrics: Accuracy@t1, Accuracy@t2, Delta(t1,t2), Delta^{i->c}, Delta^{c->i}.",
      "source": "Section 6, Section 6.1, Table 3"
    },
    {
      "id": "score-D4-006",
      "claim": "Inference-time compute scaling step sequence: (1) For parallel baseline: sample 32 independent first attempts (T=0.7), majority vote on answers -> (2) For sequential SCoRe: sample 16 first attempts (T=0.7), apply 1 round self-correction to each, majority vote on 16 corrected answers -> (3) Compare accuracy gains at equal total compute budget of 32 samples per problem.",
      "source": "Section 6.2, Figure 1 (right)"
    },
    {
      "id": "score-D4-007",
      "claim": "Ablation study step sequence: (1) Train each of 5 SCoRe variants (full, w/o multi-turn, w/o Stage I, w/o reward shaping, w/ STaR instead of REINFORCE Stage II) with identical hyperparameter budgets (same sample and gradient update counts) -> (2) Evaluate all variants with greedy decoding (T=0) on MATH500 -> (3) Compare Accuracy@t1, Accuracy@t2, and Delta(t1,t2) across variants.",
      "source": "Section 6.3, Table 4"
    },
    {
      "id": "score-D4-008",
      "claim": "SFT failure analysis step sequence: (1) Generate two-turn self-correction traces from Gemini 1.5 Flash on MATH -> (2) Construct D_STaR (filtered successful corrections) and D_SFT (incorrect+correct pairs), plus + variants with correct-to-correct data -> (3) Fine-tune on each dataset (STaR: 3 iterations, Pair-SFT: 1 iteration) -> (4) Evaluate edit distance ratios on training and validation sets -> (5) Evaluate correction accuracy on fixed vs. self-generated first-attempt distributions -> (6) Report 5 main self-correction metrics.",
      "source": "Section 4, Table 1, Figure 4, Figure 5"
    },
    {
      "id": "score-D4-009",
      "claim": "Behavior collapse analysis step sequence: (1) Run standard multi-turn RL training on MATH optimizing only the base MDP objective -> (2) Monitor accuracy@t1, accuracy@t2, and Delta(t1,t2) throughout training -> (3) Track frequency of answer changes between attempts and edit distance ratios -> (4) Compare evolution curves with SCoRe Stage I to demonstrate that Stage I prevents collapse.",
      "source": "Section 5, Figure 6"
    },
    {
      "id": "score-D4-010",
      "claim": "Multi-attempt scaling analysis step sequence: (1) For each model (base, Pair-SFT, SCoRe), perform up to 10 sequential self-correction attempts on MATH -> (2) At each attempt, model receives problem + all previous attempts + correction instruction -> (3) Record accuracy at each turn 1 through 10 -> (4) Compare how performance evolves past the training distribution (2 turns) to assess generalization of self-correction ability.",
      "source": "Appendix A.1, Figure 8"
    },
    {
      "id": "score-D4-011",
      "claim": "Discount factor experiment step sequence: (1) Run multi-turn RL with gamma=0, alpha=1.0 (baseline) -> (2) Run multi-turn RL with gamma=0.8, alpha=1.0 -> (3) Track self-correction performance metrics throughout training for both settings -> (4) Compare training curves to determine whether gamma>0 resolves behavior collapse that occurs with gamma=0.",
      "source": "Appendix A.2, Figure 9"
    },
    {
      "id": "score-D4-012",
      "claim": "Test-time inference procedure ordering: (1) Generate first attempt y1 via argmax decoding (T=0) -> (2) Construct self-correction instruction p1 that does NOT reveal correctness -> (3) Build second-attempt context x2 by concatenating [x1, y1, p1] -> (4) Generate second attempt y2 via argmax decoding (T=0) -> (5) Return y2 as final answer. The model must autonomously detect errors in y1 without any oracle, ground truth, or external feedback at test time.",
      "source": "Section 5.3, Appendix C"
    }
  ]
}