Dimios45/yam-pick-duster-bspline-joint

YAM Pick-Duster — B-spline Diffusion Policy (joint space)

A B-spline Policy UNet diffusion policy trained on Dimios45/yam-pick-duster for a single-arm I2RT YAM: pick up the duster.

The policy predicts B-spline knots and control points rather than a fixed grid of future actions, giving a continuous trajectory that can be resampled at any rate and temporally rescaled at deploy time.

This model commands joints directly — no inverse kinematics at inference. The end-effector counterpart trained on the same 50 takes is Dimios45/yam-pick-duster-bspline-ee; it emits Cartesian poses and does need IK.

Action and observation space

action / obs joint_pos  (7,) = [joint1..6 (radians), gripper]
gripper: 0 = open, 1 = closed

key	shape	notes
top_image	(3, 84, 84)	RGB, RAW 640×480 resized — not cropped
wrist_image	(3, 84, 84)	RGB, right wrist
joint_pos	(7,)	measured joints + gripper

Two observation steps; random crop to 76×76 in training, center crop at eval.

Actions stay 7-D: with action.shape [7], _convert_actions takes the raw_dim == target_action_dim branch and passes them through untouched — no rotation_6d expansion. infer_action_meta resolves this to single_yam_joint (verified on the published checkpoint).

The network output is (16, 8): column 0 is the knot vector in units of 25 Hz frames relative to the current observation, columns 1–7 are control points. 16 = chunk_size 10 + 2 × degree 3.

Files

file	size	use
deploy_ema.ckpt	426 MB	Inference. EMA weights only.
epoch0600_full.ckpt	1.5 GB	model + ema_model + optimizer, for resuming/fine-tuning.

Both embed the Hydra config (pickled with dill), so bspline_policy and diffusion_policy must be importable on load — cfg._target_ is a class path.

Training

base	B-spline-policy/bspline-policy UNet BSP
data	50 episodes, 28,068 frames @ 25 Hz → 28,018 B-spline chunks
hardware	1× RTX 4090, ~3.5 h, 21 s/epoch, 438 batches/epoch
epochs / batch	601 / 64
optimizer	AdamW, lr 1e-4, cosine, 500 warmup steps, EMA
scheduler	DDIM, 100 train timesteps, 16 inference steps, epsilon prediction
B-spline	degree 3, chunk_size 10, max_error 0.002 rad, absolute knots

Loss: 0.372 (ep0) → 0.007 (100) → 0.005 (200) → 0.003 (300) → 0.002 (400–600), final in-epoch 0.00086.

601 epochs is not arbitrary padding: the loss looks flat by epoch ~300 but fell another ~4.5× between epoch 377 and 550 as the cosine schedule annealed. Truncating the run would remove that low-LR refinement phase entirely.

Rollout

Requires the joint-space deployment patches (single_yam_joint decoder, yam_server joint mode that bypasses IK, the top_image camera). See Dimios45/yam-duster-bspline-dp for the full patch list — they are not in upstream B-spline-policy/bspline-policy.

cd ~/bspline-policy
export PYTHONPATH=$PWD/bspline_policy:$PWD/diffusion_policy:$PWD/real_env/yam_teleop

hf download Dimios45/yam-pick-duster-bspline-joint deploy_ema.ckpt --local-dir ./ckpt

# terminal 1 — arm server
sudo ip link set can_follower_r up type can bitrate 1000000
python real_env/yam_teleop/yam_server.py --channel can_follower_r

# terminal 2 — rollout
python real_env/yam_teleop/rollout_local_policy.py \
  --env yam --policy bspline \
  --ckpt-path ./ckpt/deploy_ema.ckpt \
  --diffusion-policy-dir $PWD/diffusion_policy \
  --control-freq 100 \
  --data-freq 25 \
  --origin-time-scale 25 \
  --predict-before-end 0.3 \
  --speed-up-times 1.0 \
  --save --output-dir data/rollouts_joint

Flags that are not optional

flag	value	why
--origin-time-scale	25	Knots are in data-frame units; this converts them to seconds and must equal the training rate. This dataset is 25 Hz — the EE counterpart is 10 Hz, so do not copy this flag between the two models. Using 10 here runs the arm at 0.4× speed.
--data-freq	25	Must match the above.
--control-freq	100	Matches YAM_CONTROL_HZ.
--speed-up-times	start at 1.0	Velocity scales linearly with it, acceleration quadratically.
--predict-before-end	0.3 (CPU), 0.06 (GPU)	Must exceed inference latency or the arm stalls between chunks.

A 16-knot chunk spans ~0.4 s at 25 Hz, so this model replans ~2.5× more often than the EE one.

Cameras and gripper

Images were trained uncropped (RAW 640×480 → 84×84). The dataset card recommends --crop top_image=42,28,598,414; this model did not use it, and whatever crop you train with must be applied identically at deployment.

Gripper is 0 = open, 1 = closed (inverted from i2rt's native normalisation, converted at record time). Verify on hardware before the first rollout — if the convention is reversed the policy opens to grasp and closes to release, which looks almost-working and is hard to diagnose:

cd real_env/yam_teleop && python -c "
from multiprocessing.managers import BaseManager as M
from constants import ARM_RPC_HOST, ARM_RPC_PORT, RPC_AUTHKEY
class Mg(M): pass
Mg.register('YamArm'); m = Mg(address=(ARM_RPC_HOST, ARM_RPC_PORT), authkey=RPC_AUTHKEY); m.connect()
print('gripper reads:', round(float(m.YamArm().get_state()['joint_pos'][6]), 3))"

Expect ~0.0 open, ~1.0 closed.

Reproducing

python ~/data/yam-pick-duster/to_robomimic.py --from lerobot \
  --repo-id Dimios45/yam-pick-duster --root ~/data/yam-pick-duster \
  --output-path data/yam_joint.hdf5

cd bspline_policy && python train.py \
  --config-name=yam_pick_joint_bspline \
  hydra.run.dir=../outputs/yam_pick_joint \
  training.resume=false logging.mode=offline \
  checkpoint.topk.k=601 dataloader.persistent_workers=True

Citation

@article{han2026b,
  title={B-spline Policy: Accelerating Manipulation Policies via B-spline Action Representations},
  author={Han, Xiaoshen and Xiong, Haoyu and Chen, Haonan and Liu, Chaoqi and
          Torralba, Antonio and Zhu, Yuke and Du, Yilun},
  journal={arXiv preprint arXiv:2607.09648},
  year={2026}
}