khadim-hussain/gr00t-n1.5-libero-90-jerk-loss

GR00T N1.5 LIBERO-90 — Executed-Trajectory Jerk Loss

A vision-language-action (VLA) model for robot manipulation, fine-tuned from NVIDIA's GR00T N1.5 LIBERO-90 posttrain checkpoint with an auxiliary jerk-minimization loss applied to the executed (integrated) trajectory the flow-matching policy actually produces. On LIBERO-90 it lowers trajectory jerk by ~7–8% (position jerk 20.28 → 18.82 m/s³; rotation jerk 4.79 → 4.39 rad/s³) while keeping task success within run-to-run noise of the base model — a reproducible, statistically significant smoothness gain across 3 training seeds.

• 🤗 Base model: youliangtan/gr00t-n1.5-libero-90-posttrain
• 🐙 Code, training pipeline & evaluation NPZs: khadimhussain0/gr00t-n1.5-jerk-loss
• 📄 GR00T N1 paper: arXiv:2503.14734
• 🤖 Robot: Franka Panda (7-DoF + gripper), MuJoCo simulation
• 🎯 Action space: 7-DoF continuous delta commands [dx, dy, dz, droll, dpitch, dyaw, gripper] at 20 Hz

TL;DR

Standard diffusion/flow-matching policies optimize the velocity field, not the trajectory you execute — so a jerk penalty on the velocity field is redundant with the flow-matching objective and changes nothing. This model instead penalizes the jerk of the executed trajectory: during training the action chunk is produced by the same differentiable 4-step ODE used at inference, and an auxiliary term minimizes the squared third derivative (jerk) of that integrated trajectory. The result is smoother executed motion at no measurable success cost.

Method

L = L_flow_matching  +  w · ‖ jerk( ODE_integrate(policy) ) ‖²

• Jerk = second finite difference of the executed delta-action sequence (deltas are velocities, so two differences give the third derivative of position), applied to all 6 motion dimensions.
• The executed trajectory is built by a differentiable Euler ODE with 4 steps, matched exactly to the 4-step denoising used at inference, and gradients flow through the full solver into the DiT action head.
• w = 1.0, 2,000 steps, fine-tuned from youliangtan/gr00t-n1.5-libero-90-posttrain.

Evaluation

Protocol: action_horizon=8, denoising_steps=4, 450 episodes (90 tasks × 5 trials), MuJoCo, 20 Hz. One canonical metric (k=2 finite difference, gripper excluded, physical units = unitless/dt², dt=0.05) is applied identically to this model and the base model. Results are the mean over 3 training seeds (per-run bootstrap 95% CI in brackets; baseline = 2-run mean).

Metric	Base model	This model (3-seed mean)	Δ	Significance
Success rate	96.33%	95.41% ± 0.34	−0.93 pp	within noise (Wilson CIs overlap)
Position jerk (m/s³)	20.28	18.82 ± 0.14	−7.2% [−11.6, −4.1]	significant
Rotation jerk (rad/s³)	4.79	4.39 ± 0.08	−8.3% [−11.9, −8.1]	significant
6-DoF unitless jerk	0.0529	0.0491 ± 0.0004	−7.2% [−11.5, −4.4]	significant (Wilcoxon p≈1e-3 … 1e-13)
Scale-invariant jerk/speed	0.0868	0.0843	−3.1%	genuine shape smoothing

Training-seed SD (~0.34 pp success, ~0.7% jerk) is comparable to the eval-rollout SD measured by re-evaluating one checkpoint three times — i.e. the effect is reproducible and far larger than its noise.

What the smoothing is (honest decomposition)

The model reaches the same places (net end-effector displacement preserved to within ~0.4%) along straighter, less oscillatory paths (path straightness +2–3%), and the scale-invariant jerk/speed ratio drops ~3–4% — i.e. there is genuine shape smoothing that is not an artifact of the metric. About half of the raw jerk reduction is accompanied by a mild ~4% reduction in commanded action magnitude (a slightly gentler policy), which mechanically contributes to the lower jerk. So the defensible statement is: genuine partial trajectory smoothing at no measurable success cost, part shape and part magnitude.

Scope notes

• A jerk penalty on the velocity field (rather than the executed trajectory) has no measurable effect on LIBERO-90 — it is redundant with the flow-matching objective.
• A scale-invariant variant (penalizing jerk/speed directly) did not improve smoothness and reduced success, indicating the mild magnitude reduction is part of the working mechanism.
• The single most effective jerk reducer on this benchmark is temporal ensembling at inference time (~−30%), which is training-free and orthogonal to this model.

Intended Uses

• ✅ LIBERO-90 evaluation and research — drop-in replacement for the base posttrain checkpoint with smoother executed trajectories at comparable success.
• ✅ Smoothness-method baseline — reference for comparing trajectory-smoothing approaches.
• ✅ Reproducibility — paired with the GitHub repo, every number here is reproducible offline from the saved evaluation trajectory NPZs (no GPU needed to regenerate the metrics/figures).

Out-of-scope / Limitations

• ❌ Other LIBERO suites (Spatial/Object/Goal/Long) — fine-tuned for the 90-task suite.
• ❌ Other robots / embodiments — Franka Panda + LIBERO action space.
• ❌ Real-world deployment — trained and evaluated in MuJoCo simulation only.
• ⚠️ The jerk reduction is modest (~7–8%) and partly magnitude-driven; expect smoother, not dramatically different, motion.

How to Use

git clone https://github.com/khadimhussain0/gr00t-n1.5-jerk-loss
cd gr00t-n1.5-jerk-loss

# Start the inference server
python scripts/inference_service.py --server \
    --model-path khadim-hussain/gr00t-n1.5-libero-90-jerk-loss \
    --embodiment-tag new_embodiment \
    --data-config examples.Libero.custom_data_config:LiberoDataConfig \
    --denoising-steps 4 --port 5555

# In another terminal — run the 450-episode LIBERO-90 eval (h=8)
PYTHONPATH=$LIBERO_REPO:$PYTHONPATH python \
    scripts/jerk_experiments/libero90_action_chunking_eval.py \
    --port 5555 --action-horizon 8 --model-name jerk_loss

Training Details

Parameter	Value
Base model	youliangtan/gr00t-n1.5-libero-90-posttrain (96.33% success)
Loss	L = L_FM + 1.0 · ‖jerk(executed_trajectory)‖² (all 6 motion dims)
Executed trajectory	differentiable Euler ODE, 4 steps (matched to inference)
Steps	2,000
Learning rate	1e-5 (cosine, 5% warmup)
Effective batch	16 (batch 2 × grad-accum 8)
Tune	LLM ✗, visual ✗, projector ✓, diffusion (DiT) ✓
Hardware	NVIDIA A100-SXM4-40GB, single GPU
Dataset	LIBERO-90 (90 tasks, 3,921 demos, 569,249 frames)

Files

File	Purpose
model-0000{1,2}-of-00002.safetensors	model weights
model.safetensors.index.json	shard index
config.json	model architecture config (the denoised jerk loss is a training-time objective; the exact flags jerk_on_denoised=True, jerk_denoised_weight=1.0, jerk_denoised_ode_steps=4 live in the GitHub training script scripts/jerk_experiments/train_denoised.py)
experiment_cfg/metadata.json	embodiment / modality config (required by Gr00tPolicy)
trainer_state.json	training loss curves

Training-state files (optimizer.pt, rng_state.pth, scheduler.pt) are excluded; only inference-essential files are shipped. The full evaluation trajectories (this model and the base model) are in the GitHub repo under experiments/eval_results/ for independent verification.

Reproducibility

• Code & data: khadimhussain0/gr00t-n1.5-jerk-loss (branch jerk-loss)
• Evaluation trajectories: experiments/eval_results/libero90_denoised_alldims_ode4_w1_2k*_h8_trajectories.npz
• Metrics regenerate from the NPZs with scripts/jerk_experiments/generate_plot_data.py — pure NumPy, no GPU.

Citation

@inproceedings{gr00tn1_2025,
  archivePrefix = {arxiv},
  eprint     = {2503.14734},
  title      = {{GR00T} {N1}: An Open Foundation Model for Generalist Humanoid Robots},
  author     = {NVIDIA and Johan Bjorck and others},
  year       = {2025},
  booktitle  = {arXiv preprint arXiv:2503.14734},
}

License

Apache 2.0, matching the upstream GR00T N1.5 license.

Acknowledgements

• Base model and architecture: NVIDIA Isaac GR00T team
• LIBERO-90 posttrain checkpoint: youliangtan