Skip to content

Build1 publisher3 min readPublished

Dropping the critic network moves an RL fine-tune's cost from VRAM to rollout tokens

A dev.to walkthrough of DeepSeek's GRPO puts a 70B PPO training loop over 600GB of VRAM before any sharding. The critic-free version deletes the most expensive network and pays for it in sampled completions.

The Engineer · Build desk

Illustration accompanying Dropping the critic network moves an RL fine-tune's cost from VRAM to rollout tokens

What happened

  • A dev.to explainer argues pre-training has run into a data wall, saying high signal-to-noise public text is virtually exhausted and that feeding in low-quality synthetic web dumps risks model collapse.
  • It credits OpenAI o1/o3 and DeepSeek-R1 with a second growth curve, test-time compute scaling, where a compact base model runs long chain-of-thought with self-verification and backtracking.
  • GRPO, from DeepSeek's DeepSeekMath paper and scaled in DeepSeek-R1, deletes the critic and uses the empirical distribution of G completions sampled per prompt as the baseline instead.

Compiled by The EngineerSomething wrong?How this is made

Why it matters

  • cost Each gradient step now generates G completions of 8,000 to 16,000 tokens, so the spend moves from critic memory to sampling and verification throughput, and whoever runs the sandbox absorbs it.
  • constraint The reward comes from a matcher, a unit test or a Python sandbox, which limits this recipe to tasks a program can grade. Anything scored by human judgement needs a different setup.
  • decision A team planning a reasoning fine-tune is choosing a group size and a verifier budget instead of a parallelism strategy for a second trainable model the size of the policy.

Start with the 600GB. The post puts that figure on a 70B actor plus a critic of roughly the same size, with AdamW optimizer states for both, and says the loop needs tensor and pipeline parallelism merely to fit [7]. Divide 600 by 70 and you get about 8.6 bytes per parameter to cover two trainable models and two sets of optimizer state [14]. The post says "over", so read it as a floor. It transfers to your cluster only if the critic really is actor-sized, the optimizer really is AdamW with full moment state, and nothing is being offloaded to host memory. Nobody deploys pipeline parallelism for fun.

The same post's case against scale is thinner: it asserts that high-signal public text is close to exhausted [2] and that going from 70B to 700B parameters spikes capital expenditure, interconnect overhead and power for marginal gains on everyday reasoning [3]. There is no measurement behind either claim in the text.

The infrastructure argument is the stronger half, and it is mostly about variance. A critic in this setting has to predict expected discounted return at every intermediate token of a trajectory that runs 8,000 to 16,000 tokens, and the post says critic error amplifies gradient variance until losses explode into NaNs [8]. GRPO, from DeepSeek's DeepSeekMath paper and scaled in DeepSeek-R1, replaces that estimate with the empirical distribution of G completions sampled for the same prompt [9]. Rewards come from the verifier: a regex answer parser or a compiler test run scores each completion [10].

That baseline has a failure mode the group size controls. If all G completions in a group earn the same scalar reward, each completion's advantage against the group mean is zero and the step carries no gradient signal [17]. Groups that never disagree are groups that never teach, so task difficulty and sampling temperature stop being tuning knobs and start being part of the training design.

Count the networks before assuming the saving is three quarters. PPO hosts four: trainable actor, trainable critic, frozen reference for per-token KL, frozen reward model [6]. The GRPO diagram keeps the actor and keeps reference weights for an analytical KL term, and swaps the reward model for a deterministic environment, listed as a Python sandbox, unit tests or a matcher [11]. Two components go, and the one that mattered for memory is the trainable critic with its optimizer state.

What the post claims DeepSeek-R1 proved is that pure rule-based RL induces deep reasoning behaviour without hand-engineered process reward models [12]. That is a claim about math and code, where a program can grade the answer. For memory topology, the post refers readers to the publisher's own NVIDIA GPU Package Architecture Deep Dive [13].

What to watch

  • A measured VRAM trace for a 70B GRPO loop published alongside its PPO baseline, instead of an asserted lower bound.
  • Ablations on group size G and reward spread, showing where the group baseline gets too noisy or too flat to train.
  • Whether critic-free RL is reported working on tasks with no program-checkable answer, where the matcher and unit-test rewards do not exist.
Loading claim ledger
Loading source directory links
Loading share composer
Loading topic controls
Loading related stories