Wardn Hub
MCP ServersSkillsCategoriesAPI docsSubmit server
Submit server
Wardn HubTrusted MCP server directory.

Registry

  • MCP Servers
  • Skills
  • Categories

Resources

  • API docs
  • Score method

Contribute

  • Submit server
  • Advertise
© 2026 Wardn Hub
Wardn Hub
MCP ServersSkillsCategoriesAPI docsSubmit server
Submit server
skills/benchflow-ai/skillsbench/tasks-debug-trl-grpo-environment-skills-grpo

grpo

1
benchflow-ai/skillsbench·Data Science Tools·Audit passed·Snapshot 0d801c54a5d4

Summary

Reference for the GRPO (Group Relative Policy Optimization) algorithm. Use when implementing, debugging, or verifying a GRPO training pipeline — covers the mathematical formulation (group-relative advantages, clipped surrogate loss, KL penalty), the training loop (generate → score → advantage → loss), log-probability computation, advantage estimation, and relationship to PPO/REINFORCE.

SKILL.md

GRPO Algorithm Reference

Overview

Group Relative Policy Optimization (GRPO) is a policy gradient method that eliminates the need for a learned critic by computing advantages from group statistics. For each prompt, multiple completions are sampled and their rewards are normalized within the group to produce advantages.

Key insight: Instead of training a value function to estimate V(s), GRPO uses the mean reward of the group as the baseline. This removes the critic entirely, reducing memory and avoiding value function approximation errors.

Training Loop

Each step follows this pipeline:

1. Sample G completions per prompt from current policy
2. Decode completions to text
3. Score completions with reward function
4. Compute group-relative advantages
5. Compute per-token log-probs (current policy + reference policy)
6. Compute clipped surrogate loss with KL penalty
7. Backpropagate and update

Advantage Estimation

Rewards are normalized within each group of G completions for the same prompt:

mu   = mean(r_1, ..., r_G)
sigma = std(r_1, ..., r_G)
A_i  = (r_i - mu) / (sigma + epsilon)

epsilon is a small constant (typically 1e-4 to 1e-8) for numerical stability only. It prevents division by zero when all rewards in a group are identical.

Properties:

  • Advantages within each group sum to approximately zero;
  • High-reward completions get positive advantages, low-reward get negative;
  • The learning signal vanishes if epsilon is too large (dominates denominator) or if rewards are constant. For example, if all rewards in a group are identical (or nearly identical), then causing all advantages to collapse to 0;
Installs
0

Log-Probability Computation

Per-token log probabilities via log-softmax:

log_prob(token_i) = logit(token_i) - logsumexp(logits)

Critical invariant: log_prob <= 0 always, since it's the log of a probability in (0, 1].

Sequence-level log probability: log_pi(y|x) = sum_t log_pi(t_j | x, t_<j)

Loss Function

The GRPO loss combines a clipped surrogate objective with a KL divergence penalty:

ratio = exp(log_pi_theta(y|x) - log_pi_old(y|x))
L_clip = min(ratio * A, clip(ratio, 1-eps, 1+eps) * A)
L_kl = beta * KL(pi_theta || pi_ref)
loss = -E[L_clip] + L_kl
ComponentPurpose
ratioHow much the policy has changed from the generation policy
ClippingPrevents destructively large policy updates
beta * KLKeeps the policy close to the reference (prevents degeneration)

Key Hyperparameters

ParameterTypical RangeEffect
num_generations (G)4–16More = lower variance advantages, higher compute cost
beta0.01–0.1Higher = more conservative updates (closer to reference)
epsilon (clip)0.1–0.2Narrower = more conservative updates
epsilon (advantage)1e-8–1e-4Must be small; only for numerical stability
learning_rate1e-7–5e-6Much lower than SFT; RL is sensitive to LR

Available References

FileContentsWhen to load
references/grpo-algorithm.mdFull mathematical formulation with notation table, step-by-step derivations, comparison to PPO and REINFORCEWhen you need to verify whether a specific implementation detail matches the algorithm specification
references/grpo-trainer-internals.mdGRPOTrainer implementation from popular frameworks (TRL): method-by-method breakdown, data flow diagram, and how each algorithm step maps to codeWhen tracing bugs through a GRPOTrainer implementation or understanding how the algorithm maps to specific code paths

Related skills

testing-python13f-analyzerAutomatic Speech Recognition (ASR)Multimodal Fusion for Speaker DiarizationSpeaker Clustering Methods