{
  "paper_id": "ma-rlhf",
  "paper_title": "MA-RLHF: RL from Human Feedback with Macro Actions",
  "D1": [
    {
      "id": "ma-rlhf-D1-001",
      "claim": "Macro action termination strategies are: fixed n-gram (default, n in {3,5,10,infinity}), randomized n-gram (lengths from {2,3,5,10} shuffled and repeated 3 times), parsing-based (DFS on constituent tree, cutoff threshold C=5; programming-language parser for code), and perplexity-based (terminate when adding next token increases perplexity, using reference model logits). Default strategy is fixed n-gram.",
      "source": "3.2.1"
    },
    {
      "id": "ma-rlhf-D1-002",
      "claim": "Macro action internal configuration: intra-macro-action reward discount factor rho=1 (simple sum of token rewards). Three sigma assignment variants for mapping token-level critic values to macro-level values: (1) equal assignment sigma_i=1/|omega_tau| (default, used in all main experiments, produces highest RM scores), (2) unit assignment sigma={0,...,0,1} (last token only, best consistency/fluency in GPT-4 eval), (3) position-decayed assignment sigma_i=1/((|omega_tau|-i)*H) where H normalizes sum to 1 (later tokens get higher weight).",
      "source": "3.2.2, D.1"
    },
    {
      "id": "ma-rlhf-D1-003",
      "claim": "SFT stage hyperparameters: Gemma-2B: batch_size=512, epochs=3, lr=5e-5, cosine scheduler, warmup_ratio=0.1. Gemma-7B: batch_size=128, epochs=1, lr=2e-5, cosine, warmup_ratio=0.1. Gemma-27B: batch_size=128, epochs=3, lr=5e-6, cosine, warmup_ratio=0.1. CodeGemma-2B: batch_size=16, epochs=1, lr=5e-6, warmup_ratio=0. CodeGemma-7B: batch_size=32, epochs=1, lr=2e-6, warmup_ratio=0. WebGPT variant: Gemma-2B batch_size=64/lr=1e-4, Gemma-7B epochs=5.",
      "source": "B.2, B"
    },
    {
      "id": "ma-rlhf-D1-004",
      "claim": "RM stage hyperparameters: Gemma-2B: batch_size=64, epochs=1, lr=1e-5, cosine scheduler, warmup_ratio=0.1. Gemma-7B: batch_size=128(TL;DR)/64(HH-RLHF), epochs=1, lr=1e-6, cosine, warmup_ratio=0.1. Gemma-27B: batch_size=128, epochs=1, lr=8e-6, cosine, warmup_ratio=0.1. CodeGemma has no RM stage (compiler feedback replaces RM). WebGPT: Gemma-2B batch_size=32/lr=2e-5, Gemma-7B epochs=32.",
      "source": "B.2, B"
    },
    {
      "id": "ma-rlhf-D1-005",
      "claim": "PPO stage hyperparameters: Shared across all models: clip_ratio=0.2, GAE lambda=0.95, GAE gamma=1, max_response_length=512, PPO epochs=1, rollout=1. Gemma-2B: batch_size=256, policy_lr=1.5e-5, critic_lr=1.5e-5, max_prompt_length=512, temperature=0.8, top_p=1.0, top_k=50. Gemma-7B: batch_size=256, policy_lr=1e-6, critic_lr=1e-6, max_prompt_length=512, temperature=0.8, top_p=1.0, top_k=50. Gemma-27B: batch_size=256, policy_lr=7e-7, critic_lr=1e-6. CodeGemma-2B: batch_size=16, policy_lr=5e-7, critic_lr=5e-5, max_prompt_length=600, temperature=1.0, top_k=5, warmup_steps=20. CodeGemma-7B: batch_size=16, policy_lr=5e-7, critic_lr=5e-5, max_prompt_length=600, temperature=1.0, top_k=5, warmup_steps=20. KL coefficient beta: Gemma-2B=0.05, Gemma-7B(TL;DR)=0.01/WebGPT=0.1/others=0.05, Gemma-27B=0.1, CodeGemma=0.05. Gemma warmup_steps=200, CodeGemma warmup_steps=20. WebGPT: epochs=4.",
      "source": "B.2, B"
    },
    {
      "id": "ma-rlhf-D1-006",
      "claim": "Data split ratios and training stages: Text tasks use 3-stage pipeline (SFT 20%, RM 40%, PPO 40%). Code task (APPS) uses 2-stage pipeline (SFT 20%, PPO 80%, no RM). WebGPT uses 5% validation split from training data.",
      "source": "B"
    },
    {
      "id": "ma-rlhf-D1-007",
      "claim": "Evaluation configuration: RM validation uses 2000 instances. GPT-4 pairwise win rate evaluated on 50 instances using gpt-4o-05-13. Pass@k uses k in {1,5} on 5000 test instances (APPS). Human evaluation uses 3 annotators (Gemma-7B), with inter-rater agreement measured on 100 total samples (50 per task). Generalization probing: Best-of-N values in {4,8,16,32}, temperature robustness evaluated at {0.0,0.2,0.4,0.6,0.8,1.0}, with training temperature 0.8.",
      "source": "4, B"
    },
    {
      "id": "ma-rlhf-D1-008",
      "claim": "Code generation compiler reward constants: successful compile base offset=-0.3 with multiplier=1.3*(N_pass/(N_pass+N_fail)); runtime error penalty=-0.6; compile error penalty=-1.0.",
      "source": "4.5, B.5"
    },
    {
      "id": "ma-rlhf-D1-009",
      "claim": "Additional baseline hyperparameters: DPO: lr=2e-7, beta=0.1 (TL;DR) / beta=0.01 (HH-RLHF). RLOO: policy_lr=1.5e-5, K=4 online samples (TL;DR only). Cross-model validation: Llama-3.2-3B on TL;DR with actor_lr=5e-6, critic_lr=1e-5, KL coefficient=0.1. Model sizes tested: Gemma-2B, Gemma-7B, Gemma-2-27B (open-ended generation); CodeGemma-1.1-2B, CodeGemma-1.1-7B-it (code generation); Llama-3.2-3B (cross-model validation).",
      "source": "C.3, C.4"
    }
  ],
  "D2": [
    {
      "id": "ma-rlhf-D2-001",
      "claim": "Reward Model Ranking Loss: L_RM = -log(sigma(log(r_phi(x, y_plus)) - r_phi(x, y_minus))). Binary ranking loss for training the reward model on human preference pairs; the reward model r_phi outputs scalar scores. Higher score for chosen response y_plus over rejected y_minus. Standard RLHF RM loss used before MA-RLHF is applied.",
      "source": "2.2"
    },
    {
      "id": "ma-rlhf-D2-002",
      "claim": "RLHF Reshaped Reward with KL Penalty: R(x, y) = r_phi(x, y) - beta * D_KL(pi_theta(.|x) || pi_sft(.|x)). Combines the reward model score with a KL divergence penalty preventing the RL policy from deviating too far from the SFT model. This token-level reward feeds into the macro-level reward computation in MA-RLHF.",
      "source": "2.2"
    },
    {
      "id": "ma-rlhf-D2-003",
      "claim": "Standard PPO Clipped Surrogate Objective: J^{ppo-clip}(theta) = E_t[min(r_t(theta)*A_t, clip(r_t(theta), 1-epsilon, 1+epsilon)*A_t)], where r_t(theta) = pi_theta(a_t|s_t)/pi_theta_old(a_t|s_t). Token-level PPO loss used as the baseline; MA-PPO replaces token-level importance ratios with macro-action-level ratios.",
      "source": "2.1"
    },
    {
      "id": "ma-rlhf-D2-004",
      "claim": "MA-PPO Macro-Level Clipped Surrogate Objective: L^{MA-PPO}(theta) = E_tau[min(pi_theta(omega_tau|s_tau)/pi_theta_old(omega_tau|s_tau)*hat_A_tau, clip(pi_theta(omega_tau|s_tau)/pi_theta_old(omega_tau|s_tau), 1-epsilon, 1+epsilon)*hat_A_tau)]. Core novel loss; adapts PPO clipped surrogate to operate at macro-action granularity using joint probabilities of entire macro-action sequences instead of individual tokens.",
      "source": "3.2.2"
    },
    {
      "id": "ma-rlhf-D2-005",
      "claim": "Macro Action Joint Probability: pi_theta(omega_tau | s_tau) = Prod_{t=t_tau}^{t_{tau+1}-1} pi_theta(a_t | a_{<t}). Computes joint probability of a macro action (token sequence) as the product of conditional token probabilities. This is the key bridge from token-level policy outputs to macro-level importance ratios; implemented by summing log-probabilities of tokens within each macro action segment, then exponentiating.",
      "source": "3.2.2"
    },
    {
      "id": "ma-rlhf-D2-006",
      "claim": "Macro Reward Definition: R_tau = E[Sum_{i=0}^{|omega_tau|-1} rho^i * r_{t_tau + i} | s_tau] with rho=1 in practice. Macro-level reward defined as the expected discounted sum of per-token reshaped RLHF rewards over the macro action span. With rho=1, this is a simple sum of token rewards within the macro action.",
      "source": "3.2.2"
    },
    {
      "id": "ma-rlhf-D2-007",
      "claim": "Option-Level State Value Function: V^pi(s_tau, omega_tau) = E[R_tau + gamma*V^pi(s_{t_{tau+1}}) | s_tau, omega_tau]. Estimates the expected return when executing macro action omega_tau at macro state s_tau by combining immediate macro reward R_tau with discounted value of the resulting state. Used in GAE computation at macro level.",
      "source": "3.2.2"
    },
    {
      "id": "ma-rlhf-D2-008",
      "claim": "Fixed n-gram Macro Action Termination: |omega_tau| = n (constant). Terminates each macro action after exactly n tokens; the default strategy in MA-RLHF. When n=1, MA-PPO reduces to standard token-level PPO; when n->infinity, it approaches REINFORCE/RLOO/GRPO.",
      "source": "3.2.1"
    },
    {
      "id": "ma-rlhf-D2-009",
      "claim": "Randomized n-gram Termination: |omega_tau| in {2,3,5,10}, shuffled and repeated 3 times. Randomly selects macro action lengths from a predefined set; the length list is repeated 3 times to cover the full response, then shuffled. Trailing remainder absorbed by an infinite-length macro action. Found to perform best across multiple evaluation dimensions.",
      "source": "3.2.1"
    },
    {
      "id": "ma-rlhf-D2-010",
      "claim": "Parsing-based Termination: DFS on constituent tree; terminate when leaf token count <= C (C=5). Uses syntactic/semantic parsing to determine macro action boundaries. Single-token nodes (e.g., punctuation) are merged into the preceding macro action. For code tasks, a programming-language parser is used instead of NLP constituency parser.",
      "source": "3.2.1"
    },
    {
      "id": "ma-rlhf-D2-011",
      "claim": "Perplexity-based Termination: Terminate when ppl(omega_tau union a_{t_{tau+1}}) > ppl(omega_tau). Terminates a macro action when adding the next token increases overall perplexity. Perplexity computed from reference model logits without extra forward passes. Identifies natural semantic boundaries where model uncertainty spikes.",
      "source": "3.2.1"
    },
    {
      "id": "ma-rlhf-D2-012",
      "claim": "Macro Action Value Estimation from Token-Level Values: V^pi(s_tau, omega_tau) = Sum_{i=0}^{|omega_tau|-1} sigma_{t_tau+i} * V^pi(s_{t_tau+i}, a_{t_tau+i}). Computes macro-action value as a weighted sum of the critic's token-level value predictions. Three sigma assignment variants defined. This maps token-level critic outputs to macro-level values used in GAE.",
      "source": "D.1"
    },
    {
      "id": "ma-rlhf-D2-013",
      "claim": "Generalized Advantage Estimation at Macro Action Level: Apply standard GAE with lambda=0.95 and gamma=1 using macro-level values V^pi(s_tau, omega_tau) and macro rewards R_tau as inputs. Reuses existing GAE implementation unchanged but operates on reduced-dimension macro-level sequences. Outputs macro-level advantages hat_A_tau and returns for policy and critic losses.",
      "source": "3.2.2"
    },
    {
      "id": "ma-rlhf-D2-014",
      "claim": "Code Generation Piecewise Compiler Reward: R(x,y) = {-0.3 + 1.3*N_pass/(N_pass+N_fail) if compiled; -0.6 if runtime error; -1.0 if compile error}. Adaptive compiler-based reward for APPS code generation, replacing the reward model. Base offset -0.3 prevents reward collapse at 0% pass rate; piecewise formula produces a scalar reward feeding into MA-PPO pipeline.",
      "source": "B.5"
    },
    {
      "id": "ma-rlhf-D2-015",
      "claim": "Compute Macro Action Boundary Positions (get_macro_action_positions): Supports four termination strategies: (1) Fixed n-gram: count valid tokens, split every n; (2) Randomized n-gram: create shuffled length list [2,3,5,10] repeated 3 times, use cumulative sums as boundaries; (3) Parsing: DFS on constituent tree, terminate nodes with <C leaf tokens; (4) Perplexity: terminate when ppl[i] > ppl[i-1]. Returns list of token indices marking macro action boundaries.",
      "source": "E"
    },
    {
      "id": "ma-rlhf-D2-016",
      "claim": "Compute Macro Action Values/Rewards (get_macro_action_values): Aggregates per-token values/rewards into macro-level values/rewards. Splits token-level values tensor by macro action boundaries (from sequence diff), masks out padding tokens, and computes the mean over valid tokens in each segment. Returns tensor of shape [1, num_macro_actions]. Implements the equal-assignment sigma variant (mean aggregation).",
      "source": "E"
    },
    {
      "id": "ma-rlhf-D2-017",
      "claim": "Model Initialization Scheme (Section 3.2.2, Appendix D.1): Initialize policy π_θ ← π_SFT (SFT model weights) and critic V_φ ← V_rm (reward model weights). For text-based tasks (TL;DR, HH-RLHF, WebGPT), the SFT model initializes the policy model and the reward model initializes the critic model. For APPS code generation with no RM stage, both the policy and critic models are initialized from the SFT checkpoint. The reward model is initialized from the fine-tuned SFT model.",
      "source": "B.2"
    },
    {
      "id": "ma-rlhf-D2-018",
      "claim": "Training Framework: MA-RLHF is implemented using the Deepspeed-Chat package, following a 3-stage pipeline: (1) SFT: L_SFT(θ) = -E_{(x,y)~D_SFT}[log π_θ(y|x)], 20% data split; (2) RM: L_RM(φ) = -log σ(r_φ(x, y⁺) - r_φ(x, y⁻)), 40% data split; (3) PPO: policy π_θ updated via MA-PPO clipped surrogate L^{MA-PPO}(θ) = E[min(r_τ·Â_τ, clip(r_τ, 1-ε, 1+ε)·Â_τ)] with KL penalty R(x,y) = r_φ(x,y) - β·D_KL(π_θ||π_SFT), 40% data split. SFT and RM are fine-tuned on the same dataset to avoid distribution gap.",
      "source": "B.2, 4.1"
    },
    {
      "id": "ma-rlhf-D2-019",
      "claim": "SFT Training Data Formatting: TL;DR dataset — D_SFT = {(x_i, y_i)} where x_i = Concat(post, summary) (Stiennon et al. approach); dialogue/QA — x = '<human>:' + query + '<assistant>:' + response (human-assistant chat template); APPS — x = '<instruction>' + problem + '<|endoftext|>' + solution (Hendrycks et al. 2021 format). Data split: 20% SFT, 40% RM, 40% PPO for text tasks; 20% SFT, 80% PPO for APPS.",
      "source": "B.2"
    }
  ],
  "D3": [
    {
      "id": "ma-rlhf-D3-001",
      "claim": "TL;DR Summarization Main Experiment: Evaluate whether MA-PPO outperforms vanilla PPO on Reddit TL;DR text summarization in terms of RM scores, GPT-4 win rates, and human preference win rates. Training framework: Deepspeed-Chat with Gemma-2B and Gemma-7B models. Models initialized from SFT checkpoint (policy) and RM checkpoint (critic).",
      "source": "4.2"
    },
    {
      "id": "ma-rlhf-D3-002",
      "claim": "HH-RLHF Dialogue Main Experiment: Evaluate whether MA-PPO outperforms vanilla PPO on Anthropic HH-RLHF single-turn dialogue task in terms of helpfulness and harmlessness alignment. Same framework (Deepspeed-Chat), same Gemma-2B/7B models, same PPO hyperparameter setup.",
      "source": "4.2"
    },
    {
      "id": "ma-rlhf-D3-003",
      "claim": "WebGPT QA Main Experiment: Evaluate whether MA-PPO outperforms vanilla PPO on WebGPT Comparisons question-answering task, testing robustness on structured fact-based generation. Early stopping applied during PPO training to prevent reward hacking (repetition tokens). RM performs suboptimally on this task.",
      "source": "4.2"
    },
    {
      "id": "ma-rlhf-D3-004",
      "claim": "APPS Code Generation Experiment: Evaluate whether MA-PPO outperforms vanilla PPO on APPS code generation using compiler-based feedback as the reward signal. No RM stage; compiler reward substitutes. Both policy and critic models initialized from SFT checkpoint.",
      "source": "4.5"
    },
    {
      "id": "ma-rlhf-D3-005",
      "claim": "Termination Strategy Comparison: Compare four macro action termination strategies (fixed n-gram, randomized n-gram, parsing-based, perplexity-based) against vanilla PPO on reward maximization and linguistic quality dimensions (relevance, coherence, consistency, fluency).",
      "source": "4.3.1"
    },
    {
      "id": "ma-rlhf-D3-006",
      "claim": "N-gram Size Ablation: Study effect of varying the n-gram size n on MA-PPO performance, covering the continuum from MDP (n=1, PPO) through SMDP (intermediate n) to contextual bandit (n=infinity, REINFORCE). Evaluated on both TL;DR and HH-RLHF tasks.",
      "source": "4.3.2"
    },
    {
      "id": "ma-rlhf-D3-007",
      "claim": "Best-of-N and Temperature Robustness: Evaluate robustness of MA-PPO, vanilla PPO, and SFT under rejection sampling (Best-of-N) at various temperatures, testing generalization to sampling conditions different from training (training temperature=0.8).",
      "source": "4.4"
    },
    {
      "id": "ma-rlhf-D3-008",
      "claim": "Scaling Study: Evaluate how MA-PPO performance scales with model size (2B to 27B) on TL;DR summarization, verifying the macro-action benefit is not restricted to small models.",
      "source": "4.4"
    },
    {
      "id": "ma-rlhf-D3-009",
      "claim": "DPO and RLOO Baseline Comparison: Compare MA-PPO against DPO and RLOO baselines on Gemma-2B to demonstrate MA-PPO exceeds both offline (DPO) and online (RLOO) RLHF alternatives. DPO trained with lr=2e-7, eval set beta=0.1 (TL;DR)/0.01 (HH-RLHF); RLOO with policy lr=1.5e-5, K=4 online samples (TL;DR only).",
      "source": "C.3"
    },
    {
      "id": "ma-rlhf-D3-010",
      "claim": "Llama Cross-Model Validation: Validate that MA-PPO's benefits generalize beyond the Gemma model family by testing on Llama-3.2-3B with TL;DR dataset.",
      "source": "C.4"
    },
    {
      "id": "ma-rlhf-D3-011",
      "claim": "Value Function Sigma Assignment Comparison: Compare three methods for weighting token-level critic values when computing macro-action value functions: equal assignment (default, highest RM), unit/last-token-only (best consistency/fluency), and position-decayed. Analyse trade-off between reward maximization and linguistic quality.",
      "source": "D.1"
    }
  ],
  "D4": [
    {
      "id": "ma-rlhf-D4-001",
      "claim": "Standard MA-RLHF three-stage training pipeline (paper-explicit for all text-based tasks: TL;DR, HH-RLHF, WebGPT): Phase 1 - SFT training on 20% data; Phase 2 - RM training on 40% data; Phase 3 - PPO training on 40% data, comparing vanilla PPO and MA-PPO; Phase 4 - Evaluate RM scores (training curves), GPT-4 win rates, and human win rates at final checkpoint.",
      "source": "4.2, 4.4"
    },
    {
      "id": "ma-rlhf-D4-002",
      "claim": "Code generation MA-RLHF two-stage pipeline (paper-explicit for APPS): Phase 1 - SFT training on 20% data; Phase 2 - No RM stage (compiler feedback replaces RM); Phase 3 - PPO training on 80% data with compiler-based piecewise reward, comparing vanilla PPO and MA-PPO; Phase 4 - Evaluate pass@1 and pass@5 on 5k test set.",
      "source": "4.5"
    },
    {
      "id": "ma-rlhf-D4-003",
      "claim": "MA-RLHF internal method dependency chain (Phase 3 computation flow, Sec 3.2.1-3.2.2, D.1): Positioned within the PPO training stage (Phase 3 of the text pipeline / the code pipeline), this is the computation sub-stage that converts upstream artifacts into policy updates during each PPO iteration. Upstream inputs from Phases 1-2: (a) SFT model pi_sft from Phase 1 serves as the KL penalty reference in the reshaped reward R(x,y) = r_phi(x,y) - beta * D_KL(pi_theta || pi_sft) (KL-penalized reshaped reward formula); (b) RM model r_phi from Phase 2 provides per-prompt scalar rewards (code tasks: piecewise compiler reward formula substitutes r_phi); (c) critic model initialized from RM checkpoint for text tasks, or from SFT checkpoint for code tasks (model initialization scheme). Internal 6-step chain within Phase 3: [Step 1] Reshaped per-token rewards from R(x,y) are summed (discount rho=1) into macro rewards R_tau per boundary segment (macro reward summation). [Step 2] Termination condition zeta (fixed/random n-gram, parsing, perplexity) segments the generated response into macro action boundaries {omega_tau} via get_macro_action_positions (boundary computation). [Step 3] Joint probability pi_theta(omega_tau | s_tau) = prod pi_theta(a_t | a_<t) is computed over each boundary segment (joint probability over segment). [Step 4] Token-level critic values are aggregated by sigma assignment (equal/unit/position-decayed) into macro-level values V_pi(s_tau, omega_tau) (value aggregation and option-level value function). [Step 5] Macro values and macro rewards jointly feed standard GAE (lambda=0.95, gamma=1) without modification, producing macro-level advantages A_hat_tau and returns (GAE at macro level). [Step 6] Macro advantages drive the MA-PPO clipped surrogate objective L^{MA-PPO} = E[min(r_tau * A_hat_tau, clip(r_tau, 1-epsilon, 1+epsilon) * A_hat_tau)] (MA-PPO clipped surrogate loss), yielding the policy loss. Downstream to Phase 4: the policy loss and critic loss drive gradient updates to model parameters; the updated policy generates the next response batch for the subsequent PPO iteration; after convergence over all PPO training data, the final model checkpoint proceeds to Phase 4 evaluation per the text protocol (RM scores, GPT-4 win rates, human evaluation) or code protocol (pass@1, pass@5).",
      "source": "3.2.1, 3.2.2, D.1"
    },
    {
      "id": "ma-rlhf-D4-004",
      "claim": "MA-PPO Algorithm 1 per-iteration execution order (Appendix E, Algorithm 1): Single-batch execution sequence repeated within Phase 3 PPO training (text/code pipelines), iterating over the Phase 3 data split until all training data is consumed. Upstream inputs per iteration: (a) prompt batch drawn from Phase 3 training data (40% split for text tasks or 80% split for code tasks); (b) current policy model pi_theta and reference model pi_ref (= Phase 1 SFT model); (c) critic model (initialized from RM checkpoint per model initialization scheme, or SFT checkpoint for code); (d) RM model r_phi (or piecewise compiler reward for code tasks); (e) termination rule zeta selected from the termination strategy step. Nine-step execution per batch: [S1] Generate responses y = pi_theta(x) for each prompt via rollout (1 sample per prompt). [S2] Compute per-token critic values V(s_t) = pi_critic(x, s_t) for every time step t in [0, |y|). [S3] Score each response r = pi_RM(x, y), then apply KL penalty to obtain reshaped per-token rewards (KL-penalized reward formula); for code tasks, use piecewise compiler reward formula instead. [S4] Compute macro action boundaries {omega_tau} = zeta(y) via get_macro_action_positions (boundary computation). [S5] Aggregate token-level values and rewards into macro-level tensors per segment via get_macro_action_values (macro value aggregation via mean). [S6] Apply standard GAE unchanged (lambda=0.95, gamma=1) on the reduced-dimension macro-level sequences to produce macro advantages A_hat_tau and returns (GAE at macro level). [S7] Compute MA-PPO policy loss L^{MA-PPO} from macro advantages and segment-level joint probability ratios via policy_loss_macro_action (MA-PPO clipped surrogate loss). [S8] Compute critic loss L^{value} from predicted macro values vs. target macro returns via critic_loss_macro_action. [S9] Gradient-descent update both policy and critic model parameters (PPO epochs=1, clip_ratio=0.2 per hyperparameter config). Downstream to Phase 4: the updated policy and critic models become the old_policy and old_critic for the next batch (return to S1); after exhausting all PPO training data, the final checkpoint proceeds to Phase 4 evaluation per the text evaluation protocol (RM scores on 2k validation instances, GPT-4 pairwise win rates on 50 instances, human win rates with 3 annotators) or the code evaluation protocol (pass@1 and pass@5 on 5k APPS test set).",
      "source": "E"
    },
    {
      "id": "ma-rlhf-D4-005",
      "claim": "Ablation and analysis experiment ordering (paper-explicit): For termination strategy comparison on TL;DR (Gemma-2B): First train vanilla PPO (control), then train MA-PPO with each of the four termination strategies, evaluate RM scores, evaluate GPT-4 on four quality dimensions, analyze per-dimension strengths. For n-gram ablation: train MA-PPO with each n value (1,3,5,10,infinity) on TL;DR, then HH-RLHF, evaluate RM scores, evaluate GPT-4 (TL;DR), identify optimal n per task.",
      "source": "4.3.1, 4.3.2"
    }
  ]
}