The reward went up. What changed inside the model?

reward-lens instruments the path from a grader's score to the advantages training used, the update that followed, and the policy that came out. Inspect what was favoured, what moved, and what the account still cannot explain.

pip install reward-lens

installs 3.1.0

Follow the signal

A score has to pass through a training process before it can change a model.

  1. The scorer

    The score is where the investigation starts, not where it ends.

    People specify an outcome. A real training system then executes something else on its behalf: a grader, a verifier, a reward model, or a program. The number it returns may be composed from several parts, sensitive to surface features, or reachable by a route nobody intended.

    reward-lens keeps that scoring process inspectable wherever the available access allows, and preserves the components, gates and overrides before they collapse into one number.

  2. The effective training signal

    A score is not an update.

    In the policy-gradient runs shown here the optimizer never sees the score. It sees an advantage. Grouping, baselines, normalization, masks and clipping all sit between the two, and any of them can change the sign as well as the size of what a rollout contributes.

    Keeping the score tree and the run record intact makes the alternative computable: change one component of the reward and the same recorded rollouts can be scored again, without calling the grader, to see which of them would have been reinforced instead.

  3. The update

    One update has an address.

    The optimizer computes local credit and then discards the decomposition, keeping only the summed direction. reward-lens partitions that immediate gradient back across the rollouts that produced it, and checks the partition against an independently computed full update rather than trusting it.

    Contributions align, oppose, and cancel. On the recorded step shown here more than half of the per-rollout gradient mass cancels before the optimizer sees any direction at all.

    This audits one step at the current parameters. It does not assign long-run responsibility for a behaviour that emerged over a whole run.

  4. The policy response

    The policy is the object that changed.

    Weight distance is not the question. Behaviour and internal features can move differently from each other, and both can move differently from what the training signal selected for. Four quantities are distinct here: the pressure applied, the response the policy could cheaply make, the movement actually observed, and the part of that movement nothing accounts for.

    This is the account reward-lens is built to make close or visibly fail. On the run available here it does not close. The budget balances, but it balances on the sampling noise of two small batches, and the test's own detection floor sits hundreds of thousands of times above the effect it is arbitrating. Neither verdict could have failed meaningfully, and that is the honest reading.

  5. The live run

    A useful warning arrives before the decision is irreversible.

    On one public labelled run, a variance-derivative signal alarms before the fitted behavioural transition, and the named gradient-norm comparator peaks after it. The interesting part is not the lead. It is the control.

    Two signals appeared to lead by more and were both discarded, because on order-destroyed surrogates built from the same series they fire on roughly two thirds of cases. A signal that alarms on noise has not detected anything. Separating those was the work.

    One run, one scalar time series. No activations were read and no mechanism was named. An alarm and an explanation are different achievements.

What the instrument can already show

Three places where the ordinary training story loses information.

Where a reward appears is not where it is caused.

Rank a reward model's components by how much attribution assigns them, then rank them again by how much causal patching says they carry. On one widely used model the two orderings disagree, sharply on some objectives. On another they are almost unrelated, in the other direction. Attribution answers where the reward is visible. Patching asks what changes it when intervened on. Neither number licenses the other's claim.

subject
Skywork/Skywork-Reward-Llama-3.1-8B-v0.2
dimensionCount
12
attributedComponentCount
65
patchedComponentCount
64
unpatchedComponents
embed
patchingMode
noising

reward-lens-assay/fixtures/e_parity/golden.json:9

Fig. 1 · Attribution rank against patch-effect rank One model, twelve dimensions, one frozen study.

Twelve objective dimensions on one model. Above the zero line the two methods agree on a component's importance; below it they disagree. Eight of twelve fall below.

Inside a reward model

Change the reward. Watch the update change with it.

Open a reward score tree, disable one component, and see which of the recorded advantages change sign. Then follow a single rollout from its score, through its advantage, into its signed contribution to the update, and compare the summed partition against an independently computed full gradient.

Follow a training update

The policy is only as aligned as the pressure applied to it.

A grader card treats a scoring program as a measurement device rather than a leaderboard row: its source, its corpus, its branch coverage, how much of it a deliberate mutation can change without being caught, and which of its fields are even readable under the access you actually have. On one widely used equivalence checker, none of the tested mutations was caught.

subjectCount
4
corpus
MATH-500 gold answers, 240 rollouts
graderCalls
2400
fingerprint
verifier:95be1ad8dbf1474a1a7d56058e5f2b25
source
https://raw.githubusercontent.com/hendrycks/math/main/modeling/math_equivalence.py (sha256 c4101b1f51a2bb65)
Fig. 2 · Sixty mutations, and the answer key that noticed none of them
  • hendrycks/math is_equiv

    killedMutants 0

  • SWE-bench grading.py

    killedMutants 2

  • verl GSM8K reward

    killedMutants 24

  • verl Search-R1 QA exact match

    killedMutants 26

Each mark is one mutant of the equivalence checker, run against its own benchmark's gold answer pairs. A mutant is killed when the pairs disagree with the original. None were.

exploratory

One checker, and the comparison rests on two of the other three subjects rather than all three: the same instrument kills a substantial share of mutants on both verl environments and almost none on SWE-bench's report builder. That is what makes a score of zero a finding rather than a broken harness. The counts are in the table.

Audit a grader

Every claim says how far it reaches.

A result carries its subject, its access, its uncertainty, its comparator, its source and its scope. When the available record cannot support an answer, the result names what is missing and what would make the question answerable, rather than returning a worse number. A measured zero and a missing measurement are never allowed to look the same.

hendrycks/math is_equiv · full

coverage

read exploratory

Across 240 rollouts is_equiv has never taken 32% of its branches (12 of 38). Those are behaviours it cannot distinguish.

  • never fired: _fix_fracs.clause4, _fix_fracs.clause5, _remove_right_units.clause1, _strip_string.clause1, _strip_string.clause5, is_equiv.clause1, is_equiv.clause2, is_equiv.clause3
  • a random sample of the same size reaches 0.653 against the corpus's 0.684

hendrycks/math is_equiv · log_only

coverage

ACCESS_INSUFFICIENT declined

needs GRADER: SOURCE; you have GRADER: RECORD, RECORD: RECORD

remedy

supply grader at SOURCE. If you cannot, ask for the same quantity at a lower rung: `reward-lens capabilities` prints which rungs your access reaches and what each costs.

What this has earned, and what it has not.

Works now

  • Inspect reward models with observational and causal instruments.
  • Preserve composed scores and replay them against the advantages a run actually used.
  • Audit where one immediate update came from, against an independent full gradient.
  • Inspect graders and verifier programs, including what a mutation can change unnoticed.
  • Measure behavioural and representational movement in stated feature spaces.
  • Return a sourced reading, or a specific reason it cannot read.

Not established

  • A general decoder of a policy's true objective.
  • A causal explanation of a naturalistic reward-hacking run.
  • Forecasting that holds across models, seeds and mechanisms.
  • Separating a target from a correlated passenger, in practice.
  • Long-horizon credit across many turns and tool calls.
  • A closed account of selection through to policy response, at an informative scale.

Everything this does not do

Start with your run.

pip install reward-lens copy copied select to copy

installs 3.1.0

The published release is 3.1.0. This is what pip install reward-lens gets.
bash
reward-lens capabilities

The capability report reads what your record and your access can actually support. It names which questions are answerable, what each one costs, and which information was never recorded, before you spend anything.