Download code/runner/check_grad_accum.py from Noctis12138/dexhand-train-kit: direct link, hf CLI and curl.
- Browser
- Download file 3.53 kB
-
https://huggingface.co/Noctis12138/dexhand-train-kit/resolve/main/code/runner/check_grad_accum.py
- Command line
-
hf download hf://Noctis12138/dexhand-train-kit/code/runner/check_grad_accum.py
-
curl -L -o check_grad_accum.py https://huggingface.co/Noctis12138/dexhand-train-kit/resolve/main/code/runner/check_grad_accum.py
3.53 kB
| """Check grad_accum.value_and_grad_accum (K=2) against openpi's own value_and_grad, on CPU with 4 virtual devices | |
| (FSDP 4, same sharding code path as training) and the pi0.5 architecture with openpi's "dummy" Gemma sizes and random | |
| init: the accumulation logic does not depend on model size, and the full model's gradients do not fit next to the | |
| training run. | |
| reference = mean over j=0,1 of openpi's loss/grad on rows j::2 with rng fold_in(rng, j) (what K=2 must equal) | |
| Pass: relative gradient error far below the "half batch" gap (grad on rows 0::2 alone vs the reference), which shows | |
| how large a real mistake (wrong rows, missing 1/K, one micro-batch dropped) would be. | |
| Run from the openpi dir: .venv/bin/python $SYT/code/runner/check_grad_accum.py (sets JAX to CPU itself) | |
| """ | |
| import argparse | |
| import dataclasses | |
| import os | |
| import sys | |
| os.environ["JAX_PLATFORMS"] = "cpu" | |
| os.environ["XLA_FLAGS"] = os.environ.get("XLA_FLAGS", "") + " --xla_force_host_platform_device_count=4" | |
| sys.path.insert(0, os.path.join(os.environ["SYT"], "code/runner")) | |
| import flax.nnx as nnx # noqa: E402 | |
| import jax # noqa: E402 | |
| import jax.numpy as jnp # noqa: E402 | |
| import optax # noqa: E402 | |
| from openpi.training import sharding # noqa: E402 | |
| from openpi.training import weight_loaders # noqa: E402 | |
| import grad_accum as ga # noqa: E402 | |
| import run # noqa: E402 | |
| B, K = 8, 2 | |
| cfg = run.build_config(argparse.Namespace(kind="subtask", repo_id="cover_sub"), batch_size=B, fsdp_devices=4) | |
| cfg = dataclasses.replace(cfg, weight_loader=weight_loaders.NoOpWeightLoader(), | |
| model=dataclasses.replace(cfg.model, paligemma_variant="dummy", action_expert_variant="dummy")) | |
| train = run._load_script("train") | |
| mesh = sharding.make_mesh(4) | |
| state, _ = train.init_train_state(cfg, jax.random.key(0), mesh, resume=False) | |
| # non-trivial inputs: random images / state / actions in the model's input ranges | |
| obs, act = cfg.model.fake_obs(B), cfg.model.fake_act(B) | |
| keys = iter(jax.random.split(jax.random.key(1), 16)) | |
| obs = dataclasses.replace( | |
| obs, images={k: jax.random.uniform(next(keys), v.shape, minval=-1, maxval=1) for k, v in obs.images.items()}, | |
| state=jax.random.normal(next(keys), obs.state.shape)) | |
| act = jax.random.normal(next(keys), act.shape) | |
| data_sharding = jax.sharding.NamedSharding(mesh, jax.sharding.PartitionSpec(sharding.DATA_AXIS)) | |
| obs, act = jax.device_put((obs, act), data_sharding) | |
| rng = jax.random.key(2) | |
| def vg(state, rng, obs, act, k): | |
| model = nnx.merge(state.model_def, state.params) | |
| model.train() | |
| return ga.value_and_grad_accum(cfg, model, rng, obs, act, k) | |
| def compare(state, rng, obs, act): | |
| """Everything in one jit, returning scalars only.""" | |
| loss_k, g_k = vg(state, rng, obs, act, K) | |
| parts = [vg(state, jax.random.fold_in(rng, j), *jax.tree.map(lambda x: x[j::K], (obs, act)), 1) for j in range(K)] | |
| loss_ref = sum(p[0] for p in parts) / K | |
| g_ref = jax.tree.map(lambda *g: sum(g) / K, *[p[1] for p in parts]) | |
| rel = lambda a, b: optax.global_norm(jax.tree.map(jnp.subtract, a, b)) / optax.global_norm(b) # noqa: E731 | |
| return loss_k, loss_ref, rel(g_k, g_ref), rel(parts[0][1], g_ref) | |
| with sharding.set_mesh(mesh): | |
| loss_k, loss_ref, err, gap = map(float, jax.jit(compare)(state, rng, obs, act)) | |
| print(f"loss K={K}: {loss_k:.6f} reference: {loss_ref:.6f}") | |
| print(f"grad |g_K - g_ref| / |g_ref| = {err:.2e} (half-batch gap for scale: {gap:.2e})") | |
| print("GRAD_ACCUM_OK" if err < 0.01 * gap and abs(loss_k - loss_ref) < 1e-3 else "GRAD_ACCUM_MISMATCH") | |