Hugging Face's logo

Datasets:
SLM-Lab
/
benchmark

Modalities:
Image
Formats:
imagefolder
Size:
1K - 10K
Libraries:
Datasets
Dataset card Data Studio Files
xet
 Community
1
benchmark / docs /PHASE5_OPS.md
kengzwl's picture
kengzwl
Upload folder using huggingface_hub
e313100 verified
preview code
|
raw
history blame contribute delete
37.2 kB

Phase 5.1 PPO — Operations Tracker

Single source of truth for in-flight work. Resume from here.

Principles

  1. Two canonical specs: ppo_playground (DM Control) and ppo_playground_loco (Loco). Per-env variants only when officially required: ppo_playground_fingerspin (gamma=0.95), ppo_playground_pendulum (training_epoch=4, action_repeat=4 via code).
  2. 100M frames hard cap — no extended runs. If an env doesn't hit target at 100M, fix the spec.
  3. Strategic reruns: only rerun failing/⚠️ envs. Already-✅ envs skip revalidation.
  4. Score metric: use total_reward_ma (final moving average of total reward) — measures end-of-training performance and matches mujoco_playground reference scores.
  5. Official reference: check ~/.cache/uv/archive-v0/ON8dY3irQZTYI3Bok0SlC/mujoco_playground/config/dm_control_suite_params.py for per-env overrides.

Wave 3 (2026-03-16)

Fixes applied:

  • stderr suppression: MuJoCo C-level warnings (ccd_iterations, nefc overflow, broadphase overflow) silenced in playground.py
  • obs fix: _get_obs now passes only "state" key for dict-obs envs (was incorrectly concatenating privileged_state+state)

Envs graduated to ✅ (close enough): FishSwim, PointMass, ReacherHard, WalkerStand, WalkerWalk, SpotGetup, SpotJoystickGaitTracking, AlohaHandOver

Failing envs by root cause:

  • Humanoid double-norm (rs10 fix): HumanoidStand (114→700), HumanoidWalk (47→500), HumanoidRun (18→130)
  • Dict obs fix (now fixed): Go1Flat/Rough/Getup/Handstand, G1Flat/Rough, T1Flat/Rough
  • Unknown: BarkourJoystick (0/35), Op3Joystick (0/20)
  • Needs hparam work: H1Inplace (4→10), H1Joystick (16→30), SpotFlat (11→30)
  • Manipulation: AlohaPeg (188→300), LeapCubeReorient (74→200)
  • Infeasible: PandaRobotiqPushCube, AeroCubeRotateZAxis

Currently running: (to be populated by ops)

Currently Running (as of 2026-03-14 ~00:00)

Wave V (p5-ppo17) — Constant LR test (4 runs, just launched)

Testing constant LR (Brax default) in isolation — never tested before. Key hypothesis: LR decay hurts late-converging envs.

Run Env Spec Key Change Old Best Target
p5-ppo17-csup CartpoleSwingup constlr constant LR + minibatch=4096 576.1 800
p5-ppo17-csupsparse CartpoleSwingupSparse constlr constant LR + minibatch=4096 296.3 425
p5-ppo17-acrobot AcrobotSwingup vnorm_constlr constant LR + vnorm 173 220
p5-ppo17-fteasy FingerTurnEasy vnorm_constlr constant LR + vnorm 571 950

Wave IV-H (p5-ppo16h) — Humanoid with wider policy (3 runs, ~2.5h remaining)

New ppo_playground_humanoid variant: 2×256 policy (vs 2×64), constant LR, vnorm=true. Based on Phase 3 Gymnasium Humanoid-v5 success (2661 MA with 2×256 + constant LR).

Run Env Old Best Target
p5-ppo16h-hstand HumanoidStand 18.36 700
p5-ppo16h-hwalk HumanoidWalk 7.68 500
p5-ppo16h-hrun HumanoidRun 3.19 130

Wave VI (p5-ppo18) — Brax 4×32 policy + constant LR + vnorm (3 runs, just launched)

Testing Brax default policy architecture (4 layers × 32 units vs our 2 × 64). Deeper narrower policy may learn better features for precision tasks.

Run Env Old Best Target
p5-ppo18-fteasy FingerTurnEasy 571 950
p5-ppo18-fthard FingerTurnHard 484 950
p5-ppo18-fishswim FishSwim 463 650

Wave IV tail (p5-ppo16) — completed

Run Env strength Target New best?
p5-ppo16-swimmer6 SwimmerSwimmer6 509.3 560 ✅ New best (final_strength=560.6)
p5-ppo16-fishswim FishSwim 420.6 650 ❌ Worse than 463

Wave IV results (p5-ppo16, vnorm=true rerun with reverted spec — completed):

All ran with vnorm=true. CartpoleSwingup/Sparse worse (vnorm=false is better for them — wrong setting). Precision envs also scored below old bests. Humanoid still failing with standard 2×64 policy.

Env p16 strength Old Best Target Verdict
CartpoleSwingup 316.2 576.1 (false) 800 ❌ wrong vnorm
CartpoleSwingupSparse 288.7 296.3 (false) 425 ❌ wrong vnorm
AcrobotSwingup 145.4 173 (true) 220 ❌ worse
FingerTurnEasy 511.1 571 (true) 950 ❌ worse
FingerTurnHard 368.6 484 (true) 950 ❌ worse
HumanoidStand 12.72 18.36 700 ❌ still failing
HumanoidWalk 7.46 7.68 500 ❌ still failing
HumanoidRun 3.19 3.19 130 ❌ still failing

CONCLUSION: Reverted spec didn't help. No new bests. Consistency was negative for CartpoleSwingup/Sparse (high variance). Need constant LR test (Wave V) and wider policy for Humanoid (Wave IV-H).

Wave III results (p5-ppo13/p5-ppo15, 5-layer value + no grad clip — completed):

Only CartpoleSwingup improved slightly (623.8 vs 576.1). All others regressed. FishSwim p5-ppo15: strength=411.6 (vs 463 old best). AcrobotSwingup p5-ppo15: strength=95.4 (vs 173).

CONCLUSION: 5-layer value + no grad clip is NOT a general improvement. Reverted to 3-layer + clip_grad_val=1.0.

Wave H results (p5-ppo12, ALL completed — NONE improved over old bests): Re-running same spec (variance reruns + vnorm) didn't help. Run-to-run variance is high but old bests represent lucky runs. Hyperparameter tuning has hit diminishing returns.

Wave G/G2 results (normalize_v_targets=false ablation, ALL completed):

Env p11 strength Old Best (true) Target Change Verdict
PendulumSwingup 533.5 276 395 +93% ✅ NEW PASS
FingerSpin 652.4 561 600 +16% ✅ NEW PASS
CartpoleBalanceSparse 690.4 545 700 +27% ⚠️ 99% of target
CartpoleSwingup 576.1 443/506 800 +30% ⚠️ improved
CartpoleSwingupSparse 296.3 271 425 +9% ⚠️ improved
PointMass 854.4 863 900 -1% ⚠️ same
FishSwim 293.9 463 650 -36% ❌ regression
FingerTurnEasy 441.1 571 950 -23% ❌ regression
SwimmerSwimmer6 386.2 485 560 -20% ❌ regression
FingerTurnHard 335.7 484 950 -31% ❌ regression
AcrobotSwingup 105.1 173 220 -39% ❌ regression
HumanoidStand 12.87 18.36 500 -30% ❌ still failing

CONCLUSION: normalize_v_targets: false helps 5/12, hurts 6/12, neutral 1/12.

  • false wins: PendulumSwingup, FingerSpin, CartpoleBalanceSparse, CartpoleSwingup, CartpoleSwingupSparse
  • true wins: FishSwim, FingerTurnEasy/Hard, SwimmerSwimmer6, AcrobotSwingup, PointMass
  • Decision: Per-env spec selection. New ppo_playground_vnorm variant for precision envs.

Wave F results (multi-unroll=16 + proven hyperparameters):

Env p10 strength p10 final_str Old best str Target Verdict
CartpoleSwingup 342 443 443 800 Same
FingerTurnEasy 529 685 571 950 Better final, worse strength
FingerSpin 402 597 561 600 Better final (near target!), worse strength
FingerTurnHard 368 559 484 950 Better final, worse strength
SwimmerSwimmer6 251 384 485 560 Worse
CartpoleSwingupSparse 56 158 271 425 MUCH worse
AcrobotSwingup 31 63 173 220 MUCH worse

CONCLUSION: Multi-unroll adds no benefit over single-unroll for any env by strength metric. The final_strength improvements for Finger tasks are offset by strength regressions. Root cause: stale old_net (480 vs 30 steps between copies) makes policy ratio less accurate. Spec reverted to single-unroll (num_unrolls=1). Multi-unroll code preserved in ppo.py.

Wave E results (multi-unroll + Brax hyperparameters — ALL worse):

Brax-matched spec (clip_eps=0.3, constant LR, 5-layer value, reward_scale=10, minibatch=30720) hurt every env except HopperStand (which used wrong spec before). Reverted.

Wave C completed results (all reward_scale=10, divide by 10 for true score):

Run Env strength/10 final_strength/10 total_reward_ma/10 Target vs Old
p5-ppo7-cartpoleswingup CartpoleSwingup 556.6 670.5 705.3 800 443→557 ✅ improved
p5-ppo7-fingerturneasy FingerTurnEasy 511.1 693.2 687.0 950 571→511 ❌ WORSE
p5-ppo7-fingerturnhard FingerTurnHard 321.9 416.8 425.2 950 484→322 ❌ WORSE
p5-ppo7-cartpoleswingupsparse2 CartpoleSwingupSparse 144.0 360.6 337.7 425 271→144 ❌ WORSE

KEY FINDING: time_horizon=480 helps CartpoleSwingup (+25%) but HURTS FingerTurn (-30 to -50%) and CartpoleSwingupSparse (-47%). Long GAE horizons produce noisy advantage estimates for precision/sparse tasks. The official Brax approach is 16×30-step unrolls (short GAE per unroll), NOT 1×480-step unroll.

Spec Changes Applied (2026-03-13)

Fix 1: reward_scale=10.0 (matches official mujoco_playground)

  • playground.py: PlaygroundVecEnv now multiplies rewards by self._reward_scale
  • __init__.py: threads reward_scale from env spec to wrapper
  • ppo_playground.yaml: reward_scale: 10.0 in shared _env anchor

Fix 2: Revert minibatch_size 2048→4096 (fixes CartpoleSwingup regression)

  • ppo_playground.yaml: all DM Control specs (ppo_playground, fingerspin, pendulum) now use minibatch_size=4096
  • 15 minibatches × 16 epochs = 240 grad steps (was 30×16=480)
  • Restores p5-ppo5 performance for CartpoleSwingup (803 vs 443)

Fix 3: Brax-matched spec (commit 6eb08fe9) — time_horizon=480, clip_eps=0.3, constant LR, 5-layer value net

  • Increased time_horizon from 30→480 to match total data per update (983K transitions)
  • clip_eps 0.2→0.3, constant LR (min_factor=1.0), 5-layer [256×5] value net
  • action std upper bound raised (max=2.0 in policy_util.py)
  • Result: CartpoleSwingup improved (443→557 strength), but FingerTurn and CartpoleSwingupSparse got WORSE
  • Root cause: 1×480-step unroll computes GAE over 480 steps (noisy), vs official 16×30-step unrolls (short, accurate GAE)

Fix 4: ppo_playground_short variant (time_horizon=30 + Brax improvements)

  • Keeps: reward_scale=10, clip_eps=0.3, constant LR, 5-layer value net, no grad clipping
  • Reverts: time_horizon=30, minibatch_size=4096 (15 minibatches, 240 grad steps)
  • Hypothesis: Short GAE + other Brax improvements = best of both worlds for precision tasks
  • Testing on FingerTurnEasy/Hard first (Wave D p5-ppo8-*)

Fix 5: Multi-unroll collection (IMPLEMENTED but NOT USED — code stays, spec reverted)

  • Added num_unrolls parameter to PPO (ppo.py, actor_critic.py). Code works correctly.
  • Brax-matched spec (Wave E, p5-ppo9): clip_eps=0.3, constant LR, 5-layer value, reward_scale=10
    • Result: WORSE on 5/7 tested envs. Only CartpoleSwingup improved (443→506).
    • Root cause: minibatch_size=30720 → 7.5x fewer gradient steps per transition → underfitting
  • Reverted spec + multi-unroll (Wave F, p5-ppo10): clip_eps=0.2, LR decay, 3-layer value, minibatch=4096
    • Result: Same or WORSE on all envs by strength metric. Same fps as single-unroll.
    • Training compute per env step is identical, but old_net staleness (480 vs 30 steps) hurts.
  • Conclusion: Multi-unroll adds complexity without benefit. Reverted spec to single-unroll (num_unrolls=1). Code preserved in ppo.py (defaults to 1). Spec uses original hyperparameters.

Completed Runs Needing Intake

Humanoid (ppo_playground_loco, post log_std fix) — intake immediately

Run HF Folder strength target HF status
p5-ppo6-humanoidrun ppo_playground_loco_humanoidrun_2026_03_12_175917 2.78 130 ✅ uploaded
p5-ppo6-humanoidwalk ppo_playground_loco_humanoidwalk_2026_03_12_175817 6.82 500 ✅ uploaded
p5-ppo6-humanoidstand ppo_playground_loco_humanoidstand_2026_03_12_175810 12.45 700 ❌ UPLOAD FAILED (412) — re-upload first

Re-upload HumanoidStand:

source .env && huggingface-cli upload SLM-Lab/benchmark-dev \
  hf_data/data/benchmark-dev/data/ppo_playground_loco_humanoidstand_2026_03_12_175810 \
  data/ppo_playground_loco_humanoidstand_2026_03_12_175810 --repo-type dataset

Conclusion: loco spec still fails completely for Humanoid — log_std fix insufficient. See spec fixes below.

BENCHMARKS.md correction needed (commit b6ef49d9 used wrong metric)

intake-a used total_reward_ma instead of strength. Fix these 4 entries:

Env Run strength (correct) total_reward_ma (wrong) target
AcrobotSwingup p5-ppo6-acrobotswingup2 172.8 253.24 220
CartpoleBalanceSparse p5-ppo6-cartpolebalancesparse2 545.1 991.81 700
CartpoleSwingup p5-ppo6-cartpoleswingup2 unknown — extract from logs 641.51 800
CartpoleSwingupSparse p5-ppo6-cartpoleswingupsparse 270.9 331.23 425

Extract correct values: dstack logs p5-ppo6-NAME --since 6h 2>&1 | grep "trial_metrics" | tail -1 → use strength: field.

Also check FingerSpin: dstack logs p5-ppo6-fingerspin2 --since 6h | grep trial_metrics | tail -1 — confirm strength value.

Metric decision needed: strength penalizes slow learners (CartpoleBalanceSparse strength=545 but final MA=992). Consider switching ALL entries to final_strength. But this requires auditing every existing entry — do it as a batch before publishing.

Queue (launch when slots open, all 100M)

Priority Env Spec Run name Rationale
1 PendulumSwingup ppo_playground_pendulum p5-ppo6-pendulumswingup action_repeat=4 + training_epoch=4 (code fix applied)
2 FingerSpin ppo_playground_fingerspin p5-ppo6-fingerspin3 canonical gamma=0.95 run; fingerspin2 used gamma=0.995 (override silently ignored)

Full Env Status

✅ Complete (13/25)

Env strength target normalize_v_targets
CartpoleBalance 968.23 950 true
AcrobotSwingupSparse 42.74 15 true
BallInCup 942.44 680 true
CheetahRun 865.83 850 true
ReacherEasy 955.08 950 true
ReacherHard 946.99 950 true
WalkerRun 637.80 560 true
WalkerStand 970.94 1000 true
WalkerWalk 952 960 true
HopperHop 22.00 ~2 true
HopperStand 118.2 ~70 true
PendulumSwingup 533.5 395 false
FingerSpin 652.4 600 false

⚠️ Below target (9/25)

Env best strength target best with status
CartpoleSwingup 576.1 800 false Improved +30% from 443 (true)
CartpoleBalanceSparse 545 700 true Testing false (p5-ppo11)
CartpoleSwingupSparse 296.3 425 false Improved +9% from 271 (true)
AcrobotSwingup 173 220 true false=105, regressed
FingerTurnEasy 571 950 true false=441, regressed
FingerTurnHard 484 950 true false=336, regressed
FishSwim 463 650 true Testing false (p5-ppo11)
SwimmerSwimmer6 509.3 560 true final_strength=560.6 (at target!)
PointMass 863 900 true false=854, ~same

❌ Fundamental failure — Humanoid (3/25)

Env best strength target diagnosis
HumanoidRun 3.19 130 <3% target, NormalTanh distribution needed
HumanoidWalk 7.68 500 <2% target, wider policy (2×256) didn't help
HumanoidStand 18.36 700 <3% target, constant LR + wider policy tested, no improvement

Humanoid tested and failed: wider 2×256 policy + constant LR + vnorm (Wave IV-H). MA stayed flat at 8-10 for HumanoidStand over entire training. Root cause is likely NormalTanh distribution (state-dependent std + tanh squashing) — a fundamental architectural difference from Brax.

Spec Fixes Required

Priority 1: Humanoid loco spec (update ppo_playground_loco)

Official uses num_envs=8192, time_horizon=20 (unroll_length) for loco. We use num_envs=2048, time_horizon=64.

Proposed update to ppo_playground_loco:

ppo_playground_loco:
  agent:
    algorithm:
      gamma: 0.97
      time_horizon: 20      # was 64; official unroll_length=20
      training_epoch: 4
  env:
    num_envs: 8192          # was 2048; official loco num_envs=8192

Before launching: verify VRAM by checking if 8192 envs fits A4500 20GB. Run one Humanoid env, check dstack logs NAME --since 10m | grep -i "memory\|OOM" after 5 min.

Rerun only: HumanoidRun, HumanoidWalk, HumanoidStand (3 runs). HopperStand also uses loco spec — add if VRAM confirmed OK.

Priority 2: CartpoleSwingup regression

p5-ppo5 scored 803 ✅; p5-ppo6 scored ~641. The p5-ppo6 change was minibatch_size: 2048 (30 minibatches) vs p5-ppo5's 4096 (15 minibatches). More gradient steps per iter hurt CartpoleSwingup.

Option A: Revert ppo_playground minibatch_size from 2048→4096 (15 minibatches). Rerun only failing DM Control envs (CartpoleSwingup, CartpoleSwingupSparse, + any that need it).

Option B: Accept 641 and note the trade-off — p5-ppo6 improved other envs (CartpoleBalance 968 was already ✅).

Priority 3: FingerTurnEasy/Hard

No official override. At 570/? vs target 950, gap is large. Check:

grep -A10 "Finger" ~/.cache/uv/archive-v0/ON8dY3irQZTYI3Bok0SlC/mujoco_playground/config/dm_control_suite_params.py

May need deeper policy network [32,32,32,32] (official arch) vs our [64,64].

Tuning Principles Learned

  1. Check official per-env overrides first: dm_control_suite_params.py has discounting, action_repeat, num_updates_per_batch per env. These are canonical.

  2. action_repeat is env-level, not spec-level. Implemented in playground.py via _ACTION_REPEAT dict. PendulumSwingup→4. Add others as found.

  3. NaN loss: log_std clamp max=0.5 helps but Humanoid (21 DOF) still has many NaN skips. Rate-limited to log every 10K. If NaN dominates → spec is wrong.

  4. num_envs scales with task complexity: Cartpole/Acrobot: 2048 fine. Humanoid locomotion: needs 8192 for rollout diversity.

  5. time_horizon (unroll_length): DM Control official=30, loco official=20. Longer → more correlated rollouts → less diversity per update. Match official.

  6. Minibatch count: more minibatches = more gradient steps per batch. Can overfit or slow convergence for simpler envs. 15 minibatches (p5-ppo5) vs 30 (p5-ppo6) — the latter hurt CartpoleSwingup.

  7. Sparse reward + strength metric: strength (trajectory mean) severely penalizes sparse/delayed convergence. CartpoleBalanceSparse strength=545 but final MA=992. Resolve metric before publishing.

  8. High seed variance (consistency < 0): some seeds solve, some don't → wrong spec, not bad luck. Fix exploration (entropy_coef) or use different spec.

  9. -s overrides are silently ignored if the YAML key isn't a ${variable} placeholder. Always verify overrides took effect via logs: grep "gamma\|lr\|training_epoch" dstack logs.

  10. Loco spec failures: if loco spec gives <20 on env with target >100, the issue is almost certainly num_envs/time_horizon mismatch vs official, not a fundamental algo failure.

Code Changes This Session

Commit Change
8fe7bc76 playground.py: _ACTION_REPEAT lookup for per-env action_repeat. ppo_playground.yaml: added ppo_playground_fingerspin and ppo_playground_pendulum specs.
fb55c2f9 base.py: rate-limit NaN loss warning (every 10K skips). ppo_playground.yaml: revert log_frequency 1M→100K.
3f4ede3d BENCHMARKS.md: mark HopperHop ✅.

Resume Commands 

# Setup
git pull && uv sync --no-default-groups

# Check jobs
dstack ps

# Intake a completed run
dstack logs RUN_NAME --since 6h 2>&1 | grep "trial_metrics" | tail -1
dstack logs RUN_NAME --since 6h 2>&1 | grep -iE "Uploading|benchmark-dev"

# Pull HF data
source .env && huggingface-cli download SLM-Lab/benchmark-dev \
  --local-dir hf_data/data/benchmark-dev --repo-type dataset \
  --include "data/FOLDER_NAME/*"

# Plot
uv run slm-lab plot -t "EnvName" -d hf_data/data/benchmark-dev/data -f FOLDER_NAME

# Launch PendulumSwingup (queue priority 1)
source .env && uv run slm-lab run-remote --gpu \
  slm_lab/spec/benchmark_arc/ppo/ppo_playground.yaml ppo_playground_pendulum train \
  -s env=playground/PendulumSwingup -s max_frame=100000000 -n p5-ppo6-pendulumswingup

# Launch FingerSpin canonical (queue priority 2)
source .env && uv run slm-lab run-remote --gpu \
  slm_lab/spec/benchmark_arc/ppo/ppo_playground.yaml ppo_playground_fingerspin train \
  -s env=playground/FingerSpin -s max_frame=100000000 -n p5-ppo6-fingerspin3

# Launch Humanoid loco (after updating ppo_playground_loco spec to num_envs=8192, time_horizon=20)
source .env && uv run slm-lab run-remote --gpu \
  slm_lab/spec/benchmark_arc/ppo/ppo_playground.yaml ppo_playground_loco train \
  -s env=playground/HumanoidRun -s max_frame=100000000 -n p5-ppo6-humanoidrun2

CRITICAL CORRECTION (2026-03-13) — Humanoid is DM Control, not Loco

Root cause of Humanoid failure: HumanoidRun/Walk/Stand are registered in dm_control_suite/__init__.py — they ARE DM Control envs. We incorrectly ran them with ppo_playground_loco (gamma=0.97, 4 epochs, time_horizon=64).

Official config uses DEFAULT DM Control params for them: discounting=0.995, 2048 envs, lr=1e-3, unroll_length=30, 16 epochs.

NaN was never the root cause — intake-b confirmed NaN skips were 0, 0, 2 in the loco runs. The spec was simply wrong.

Fix: Run all 3 Humanoid envs with ppo_playground (DM Control spec). No spec change needed.

# Launch with correct spec
source .env && uv run slm-lab run-remote --gpu \
  slm_lab/spec/benchmark_arc/ppo/ppo_playground.yaml ppo_playground train \
  -s env=playground/HumanoidRun -s max_frame=100000000 -n p5-ppo6-humanoidrun2

source .env && uv run slm-lab run-remote --gpu \
  slm_lab/spec/benchmark_arc/ppo/ppo_playground.yaml ppo_playground train \
  -s env=playground/HumanoidWalk -s max_frame=100000000 -n p5-ppo6-humanoidwalk2

source .env && uv run slm-lab run-remote --gpu \
  slm_lab/spec/benchmark_arc/ppo/ppo_playground.yaml ppo_playground train \
  -s env=playground/HumanoidStand -s max_frame=100000000 -n p5-ppo6-humanoidstand2

HopperStand: Also a DM Control env. If p5-ppo6-hopperstand (loco spec, 16.38) is below target, rerun with ppo_playground.

Do NOT intake the loco-spec Humanoid runs (2.78/6.82/12.45) — wrong spec, not valid benchmark results. The old ppo_playground runs (2.86/3.73) were also wrong spec but at least the right family.

Updated queue (prepend these as highest priority):

Priority Env Spec Run name
0 HumanoidRun ppo_playground p5-ppo6-humanoidrun2
0 HumanoidWalk ppo_playground p5-ppo6-humanoidwalk2
0 HumanoidStand ppo_playground p5-ppo6-humanoidstand2
0 HopperStand ppo_playground p5-ppo6-hopperstand2 (if loco result ⚠️)

Note on loco spec (ppo_playground_loco): only for actual locomotion robot envs (Go1, G1, BerkeleyHumanoid, etc.) — NOT for DM Control Humanoid.

METRIC CORRECTION (2026-03-13) — strength vs final_strength

Problem: strength = trajectory-averaged mean over entire run. For slow-rising envs this severely underrepresents end-of-training performance. After metric correction to strength:

Env strength total_reward_ma target conclusion
CartpoleSwingup 443.0 641.51 800 Massive regression from p5-ppo5 (803). Strength 443 << 665 (65M result) — curve rises but slow start drags average down
CartpoleBalanceSparse 545.1 991.81 700 Hits target by end (final MA=992) but sparse reward delays convergence
AcrobotSwingup 172.8 253.24 220 Below target by strength, above by final MA
CartpoleSwingupSparse 270.9 331.23 425 Below both metrics

Resolution needed: Reference scores from mujoco_playground are end-of-training values, not trajectory averages. final_strength (= last eval MA) is the correct comparison metric. Recommend switching BENCHMARKS.md score column to final_strength and audit all existing entries.

CartpoleSwingup regression is real regardless of metric: p5-ppo5 final_strength would be ~800+, p5-ppo6 total_reward_ma=641. The p5-ppo6 minibatch change (2048→30 minibatches) hurt CartpoleSwingup convergence speed. Fix: revert ppo_playground minibatch_size to 4096 (15 minibatches) — OR accept and investigate if CartpoleSwingup needs its own spec variant.

Next Architectural Changes

Research-based prioritized list of changes NOT yet tested. Ordered by expected impact across the most envs. Wave I (5-layer value + no grad clip) is currently running — results pending.

Priority 1: NormalTanhDistribution (tanh-squashed actions)

Expected impact: HIGH — affects FingerTurnEasy/Hard, FishSwim, Humanoid, CartpoleSwingup Implementation complexity: MEDIUM (new distribution class + policy_util changes) Envs helped: All continuous-action envs, especially precision/manipulation tasks

What Brax does differently: Brax uses NormalTanhDistribution — samples from Normal(loc, scale), then applies tanh to bound actions to [-1, 1]. The log-probability includes a log-det-jacobian correction: log_prob -= log(1 - tanh(x)^2). The scale is parameterized as softplus(raw_scale) + 0.001 (state-dependent, output by the network).

What SLM-Lab does: Raw Normal(loc, scale) with state-independent log_std as an nn.Parameter. Actions can exceed [-1, 1] and are silently clipped by the environment. The log-prob does NOT account for this clipping, creating a mismatch between the distribution the agent thinks it's using and the effective action distribution.

Why this matters:

  1. Gradient quality: Without jacobian correction, the policy gradient is biased. Actions near the boundary (common in precise manipulation like FingerTurn) have incorrect log-prob gradients. The agent cannot learn fine boundary control.
  2. Exploration: State-dependent std allows the agent to be precise where it's confident and exploratory where uncertain. State-independent std forces uniform exploration across all states — wasteful for tasks requiring both coarse and fine control.
  3. FingerTurn gap (571/950 = 60%): FingerTurn requires precise angular positioning of a fingertip. Without tanh squashing, actions at the boundary are clipped but the log-prob doesn't reflect this — the policy "thinks" it's outputting different actions that are actually identical after clipping. This prevents learning fine-grained control near action limits.
  4. Humanoid gap (<3%): 21 DOF with high-dimensional action space. State-independent std means all joints explore equally. Humanoid needs to stabilize torso (low variance) while exploring leg movement (high variance) — impossible with shared std.

Implementation plan:

  1. Add NormalTanhDistribution class in slm_lab/lib/distribution.py:
    • Forward: action = tanh(Normal(loc, scale).rsample())
    • log_prob: Normal.log_prob(atanh(action)) - log(1 - action^2 + eps)
    • entropy: approximate (no closed form for tanh-Normal)
  2. Modify policy_util.init_action_pd() to handle the new distribution
  3. Remove log_std_init for playground specs — let the network output both mean and std (state-dependent)
  4. Network change: policy output dim doubles (mean + raw_scale per action dim)

Risk: Medium. Tanh squashing changes gradient dynamics significantly. Need to validate on already-solved envs (CartpoleBalance, WalkerRun) to ensure no regression. Can gate behind a spec flag (action_pdtype: NormalTanh).

Fix 6: Constant LR variants + Humanoid variant (commit pending)

Added three new spec variants to ppo_playground.yaml:

  • ppo_playground_constlr: DM Control + constant LR + minibatch_size=4096. For envs where vnorm=false works.
  • ppo_playground_vnorm_constlr: DM Control + vnorm + constant LR + minibatch_size=2048. For precision envs.
  • ppo_playground_humanoid: 2×256 policy + constant LR + vnorm. For Humanoid DM Control envs.

Priority 2: Constant LR (remove LinearToMin decay)

Expected impact: MEDIUM — affects all envs, especially long-training ones Implementation complexity: TRIVIAL (spec-only change) Envs helped: CartpoleSwingup, CartpoleSwingupSparse, FingerTurnEasy/Hard, FishSwim

What Brax does: Constant LR = 1e-3 for all DM Control envs. No decay.

What SLM-Lab does: LinearToMin decay from 1e-3 to 3.3e-5 (min_factor=0.033) over the full training run.

Why this matters: By the midpoint of training, SLM-Lab's LR is already at ~5e-4 — half the Brax LR. By 75% of training, it's at ~2.7e-4. For envs that converge late (CartpoleSwingup, FishSwim), the LR is too low during the critical learning phase. Brax maintains full learning capacity throughout.

This was tested as part of the Brax hyperparameter bundle (Wave E) which was ALL worse, but that test changed 4 things simultaneously (clip_eps=0.3 + constant LR + 5-layer value + reward_scale=10). The constant LR was never tested in isolation.

Implementation: Set min_factor: 1.0 in spec (or remove lr_scheduler_spec entirely).

Risk: Low. Constant LR is the Brax default and widely used. If instability occurs late in training, a gentler decay (min_factor: 0.3) can be used as fallback.

Priority 3: Clip epsilon 0.3 (from 0.2)

Expected impact: MEDIUM — affects all envs Implementation complexity: TRIVIAL (spec-only change) Envs helped: FingerTurnEasy/Hard, FishSwim, CartpoleSwingup (tasks needing faster policy adaptation)

What Brax does: clipping_epsilon=0.3 for DM Control.

What SLM-Lab does: clip_eps=0.2.

Why this matters: Clip epsilon 0.2 constrains the policy ratio to [0.8, 1.2]. At 0.3, it's [0.7, 1.3] — allowing 50% larger policy updates per step. For envs that need to explore widely before converging (FingerTurn, FishSwim), the tighter constraint slows learning.

This was tested in the Brax bundle (Wave E) alongside 3 other changes — all worse together. Never tested in isolation or with just constant LR.

Implementation: Change start_val: 0.2 to start_val: 0.3 in clip_eps_spec.

Risk: Low-medium. Larger clip_eps can cause training instability with small batches. However, with our 61K batch (2048 envs * 30 steps), it should be safe. If combined with constant LR (#2), the compounding effect should be tested carefully.

Priority 4: Per-env tuning for FingerTurn (if P1-P3 insufficient)

Expected impact: HIGH for FingerTurn specifically Implementation complexity: LOW (spec variant) Envs helped: FingerTurnEasy, FingerTurnHard only

If NormalTanh + constant LR + clip_eps=0.3 don't close the FingerTurn gap (currently 60% and 51% of target), try:

  1. Lower gamma (0.99 → 0.95): FingerSpin uses gamma=0.95 officially. FingerTurn may benefit from shorter horizon discounting since reward is instantaneous (current angle vs target). Lower gamma reduces value function complexity.

  2. Smaller policy network: Brax DM Control uses (32, 32, 32, 32) — our (64, 64) may over-parameterize for manipulation tasks. Try (32, 32, 32, 32) to match exactly.

  3. Higher entropy coefficient: FingerTurn has a narrow solution manifold. Increasing entropy from 0.01 to 0.02 would encourage broader exploration of finger positions.

Priority 5: Humanoid-specific — num_envs=8192

Expected impact: HIGH for Humanoid specifically Implementation complexity: TRIVIAL (spec-only) Envs helped: HumanoidStand, HumanoidWalk, HumanoidRun

Current situation: Humanoid was incorrectly run with loco spec (gamma=0.97, 4 epochs). The correction to DM Control spec (gamma=0.995, 16 epochs) is being tested in Wave I (p5-ppo13). However, even with correct spec, the standard 2048 envs may be insufficient.

Why num_envs matters for Humanoid: 21 DOF, 67-dim observations. With 2048 envs and time_horizon=30, the batch is 61K transitions — each containing a narrow slice of the 21-DOF state space. Humanoid needs more diverse rollouts to learn coordinated multi-joint control. Brax's effective batch of 983K transitions provides 16x more state-space coverage per update.

Since we can't easily get 16x more data per update, increasing num_envs from 2048 to 4096 or 8192 doubles/quadruples rollout diversity. Combined with NormalTanh (state-dependent std for per-joint exploration), this could be sufficient.

VRAM concern: 8192 envs may exceed A4500 20GB. Test with a quick 1M frame run first. Fallback: 4096 envs.

NOT recommended (already tested, no benefit)

Change Wave Result Why it failed
normalize_v_targets: false G/G2 Mixed (helps 5, hurts 6) Already per-env split in spec
Multi-unroll (num_unrolls=16) F Same or worse by strength Stale old_net (480 vs 30 steps between copies)
Brax hyperparameter bundle (clip_eps=0.3 + constant LR + 5-layer value + reward_scale=10) E All worse Confounded — 4 changes at once. Individual effects unknown except for reward_scale (helps)
time_horizon=480 (single long unroll) C Helps CartpoleSwingup, hurts FingerTurn 480-step GAE is noisy for precision tasks
5-layer value + no grad clip III Only helped CartpoleSwingup slightly Hurt AcrobotSwingup, FishSwim; not general
NormalTanh distribution II Abandoned Architecturally incompatible — SLM-Lab stores post-tanh actions, atanh inversion unstable
vnorm=true rerun (reverted spec) IV All worse or same No new information — variance rerun
4×32 Brax policy + constant LR + vnorm VI All worse FingerTurnEasy 408 (vs 571), FingerTurnHard 244 (vs 484), FishSwim 106 (vs 463)
Humanoid wider 2×256 + constant LR + vnorm IV-H No improvement MA flat at 8-10 for all 3 Humanoid envs; NormalTanh is root cause

Currently testing

Wave V-B completed results (constant LR)

Env strength final_strength Old best Verdict
PointMass 841.3 877.3 863.5 ❌ strength lower
SwimmerSwimmer6 517.3 585.7 509.3 ✅ NEW BEST (+1.6%)
FishSwim 434.6 550.8 463.0 ❌ strength lower (final much better)

Wave VII completed results (clip_eps=0.3 + constant LR)

Env strength final_strength Old best Verdict
FingerTurnEasy 518.0 608.8 570.9 ❌ strength lower (final much better, but slow start drags average)
FingerTurnHard 401.7 489.7 484.1 ❌ strength lower (same pattern)
FishSwim 476.9 581.4 463.0 ✅ NEW BEST (+3%)

Key insight: clip_eps=0.3 produces higher final performance but worse trajectory-averaged strength. The wider clip allows bigger policy updates which increases exploration early (slower convergence) but reaches higher asymptotic performance. The strength metric penalizes late bloomers.

Wave V completed results

Env strength final_strength Old best Verdict
CartpoleSwingup 606.5 702.6 576.1 ✅ NEW BEST (+5%)
CartpoleSwingupSparse 383.7 536.2 296.3 ✅ NEW BEST (+29%)
CartpoleBalanceSparse 757.9 993.0 690.4 ✅ NEW BEST (+10%)
AcrobotSwingup 161.2 246.9 172.8 ❌ strength lower (final_strength much better but trajectory avg worse due to slow start)

Key insight: Constant LR is the single most impactful change found. LR decay from 1e-3 to 3.3e-5 was hurting late-converging envs. CartpoleBalanceSparse went from 690→993 (final_strength), effectively solved.

Completed waves

Wave VI (p5-ppo18): 4×32 Brax policy — STOPPED, all underperformed. FingerTurnEasy MA 408, FingerTurnHard MA 244, FishSwim MA 106. All below old bests.

Wave IV-H (p5-ppo16h): Humanoid wider 2×256 + constant LR + vnorm — all flat at MA 8-10.

Next steps after Wave VII

  1. Humanoid num_envs=4096/8192 — only major gap remaining after Wave VII
  2. Consider constant LR + clip_eps=0.3 as new general default if results hold across envs

Key Brax architecture differences (from source code analysis)

Parameter Brax Default SLM-Lab Impact
Policy 4×32 (deeper, narrower) 2×64 Testable via spec
Value 5×256 3×256 Tested Wave III — no help
Distribution tanh_normal Normal Cannot test (architectural incompatibility)
Init lecun_uniform orthogonal_ Would need code change
State-dep std False (scalar) False (nn.Parameter) Similar
Activation swish (SiLU) SiLU ✅ Match
clipping_epsilon 0.3 0.2 Testable via spec
num_minibatches 32 15-30 Close enough
num_unrolls 16 (implicit) 1 Tested Wave F — stale old_net hurts