Kavin60606/isr-aloha-transfer-cube-experiment

Does ISR (Information-Standardized Trajectory Resampling) improve policy success? A closed-loop test on public human teleop data

TL;DR — On lerobot/aloha_sim_transfer_cube_human (50 human demos) with ACT, evaluated by 100 sim rollouts per cell over 2 training seeds:

claim	result
ISR beats the paper's 3× uniform baseline at equal frame budget (~⅓ frames)	42 / 40 % vs 31 / 20 % (seed 1 / seed 2) ✅
ISR at half the frames matches full data	60 / 62 % vs 62 / 63 % ✅
Compressed-frame policies work at native control rate	❌ they collapse (uni3 3–14 %, ISR-⅓ 7 %) — playback must be rate-matched
Acceleration term (λ_acc) is essential	not on this task: λ_acc=0 → 54–59 % vs 60 % (within CI)

ISR paper: Yang et al., IROS 2026, arXiv:2606.22907 · code D-Robotics-AI-Lab/ISR. Paper reports +24 pt on real robots vs 3× downsampling; it never tested vs full data, in sim, or in joint space. This experiment fills those three gaps on public data.

1. What ISR does (on this data)

ISR keeps frames equally spaced in information (spatial displacement + accumulated acceleration) instead of time. Pauses collapse, fast motion is sampled densely, gripper-change frames are force-kept.

Calibration (joint space, degrees; calibration_index.json): median per-frame joint step 0.60°, so d_target = 3×median = 1.81° (→ 50 % kept) and 6×median = 3.63° (→ 31 %, equal to the uniform-3× budget). λ_acc = 3.5e-4 (acceleration ≈ 20 % of total information), gripper_thr = 2.84° (5 % of span).

2. Setup — only the frame selection differs between arms

source data	lerobot/aloha_sim_transfer_cube_human: 50 human teleop episodes, 400 frames @ 50 Hz, 14-D joint state/action, top camera 480×640
arms (each a LeRobot v3.0 dataset, linked below)	raw 100 % · uni3 33.5 % (every 3rd frame, paper baseline) · isr 49.6 % (d=3×median) · isr_lam0 41 % (λ_acc=0) · isr_k6 30.5 % (d=6×median, equal budget to uni3)
policy	LeRobot ACT, aloha defaults (chunk 100, batch 8, lr 1e-5), 60k steps seed 1000 (+40k steps seed 2000), checkpoint every 20k, all arms identical config
eval	gym_aloha/AlohaTransferCube-v0 via lerobot_eval, 100 episodes per cell, sim budget 400 steps (= demo length). 95 % CI ≈ ±10 pt
playback	native — one policy action per sim step (a policy trained on ⅓ of the frames therefore moves ~3× faster than the demos). rate-matched — each action held N sim steps, N ≈ 1/kept-ratio (uni3 & isr_k6: 3, isr & isr_lam0: 2), same 400-step sim budget

3. Results

3.1 Native playback (best checkpoint, seed 1000 / 2000)

arm	kept	SR %
raw	100 %	62 / 63
isr	50 %	42 / 41
isr_lam0	41 %	23 / –
uni3	34 %	14 / 3
isr_k6	31 %	7 / 7

3.2 Rate-matched playback

arm	kept	variant	seed 1000	seed 2000
isr	50 %	rep2	60	62
isr	50 %	rep3 (400 policy calls)	63	–
isr_lam0	41 %	rep2 / rep3	54 / 58	–
isr_k6	31 %	rep3	42	40
uni3	34 %	rep3	31	20
uni3	34 %	rep2	34	18
isr_k6	31 %	rep2	32	32

Full per-checkpoint table: results/aloha_transfer_cube_table.md. Every cell's raw eval_info.json (per-episode rewards/success) is under results/<arm>[_s<seed>]_<step>[_rep<N>[_long]]/. Sample rollout videos in videos/.

4. Findings

1. Playback rate dominates. A policy trained on temporally compressed frames must be executed proportionally slower. Uniform-3× goes 3–14 % → 20–34 % and ISR-⅓ goes 7 % → 40–42 % once rate-matched. isr rep3 = 11 % was the 400-step time budget (63 % with a full call budget), not the policy. Any ISR deployment needs rate-aware execution (here a fixed action-repeat; ideally replay at the kept frames' original timestamps).
2. Equal budget: ISR > uniform. 42/40 vs 31/20, same direction on both seeds (+11, +20 pt). This is the paper's headline comparison, reproduced on public human data, joint-space, in sim.
3. ISR at 50 % frames ≈ full data (60/62 vs 62/63). Half the training frames for the same policy — the practical value is cheaper training, not a better ceiling. No evidence ISR beats raw outright.
4. λ_acc is not what carries the gain here (54–59 vs 60). Transfer-cube is not contact-rich; the paper's "accel essential" ablation was on stacking. Pause removal / spatial equidistance does the work. Gripper force-keep was active in all ISR arms.
5. Sweet spot on this data: d_target ≈ 3× median joint step (50 % kept). 6× (30 %) costs ~20 pt.

Experiment 2 (2026-09-14) — paper protocol, 3 seeds × 200 rollouts

Redo with tighter statistics and knobs chosen from a full lookup table (exp2/tables/transfer_cube/grid.md) instead of a median rule: raw vs uniform-3× vs ISR at the paper's ⅓ budget (d 3.5°, λ 0.0004, acc-share 20 %). ACT 20k steps, seeds 1000/2000/3000, 200 rollouts per cell.

arm	kept	native SR %	rate-matched SR % (hold 3)
raw	100 %	60.0 ± 3.6	–
uniform 3×	34 %	2.3 ± 0.2	9.8 ± 3.4
ISR	32 %	10.8 ± 5.7	30.2 ± 7.7

ISR beats uniform 3× at equal budget on every seed (22/40/28 vs 6/14/8); both compressed arms trail full data by a wide margin at 20k steps; native-rate playback collapses compressed policies. Full write-up: exp2/REPORT_isr_exp2.pdf · figures exp2/figures/ · per-cell results exp2/results/ · lookup tables exp2/tables/ · checkpoints Kavin60606/isr-aloha-act-ckpts/exp2/ · ISR arm dataset Kavin60606/aloha_transfer_cube_isr_d3.5.

Experiment 3 (2026-09-16) — segment-aware ISR with VLM phase labels

Gemini 2.5 Pro (via OpenRouter) segments each demo into transit / approach / grasp / carry / handover / retreat (boundaries from a timestamped frame-grid pass, verified frame by frame) and judges which quiet holds are deliberate. ISR is then run per phase with phase-specific spacing, and deliberate holds keep every 3rd frame. Same ACT recipe, 3 seeds × 200 rollouts, rate-matched playback.

arm	precision / transit / pauses	kept	success
raw	all	100 %	60.0 ± 3.6
plain ISR	3.5° / 3.5° / dropped	32 %	30.2 ± 7.7
sa_A	1° / 8° / dropped	33 %	15.2 ± 5.2
sa_D	1° / 8° / kept	34 %	29.2 ± 7.0
sa_F	2° / 4° / kept	31 %	36.7 ± 5.2 (every seed > ISR)
sa_G	1.5° / 6° / kept	31 %	36.3 ± 8.6
sa_H	1° / 3.5° / kept, no cap	41 %	38.8 ± 4.4
sa_E	0.5° / 8° / kept	50 %	47.5 ± 4.1
plain ISR @ 50 %	1.75° / 1.75° / dropped	52 %	49.7 ± 9.0

Findings: deliberate pauses are worth +14 pt; starving transit (8°) costs the same; with transit near ISR's density, segment-aware ISR beats plain ISR by 6–9 pt at ⅓–41 % budgets; at 50 % plain ISR already matches. Report: exp3/REPORT_isr_exp3.pdf · segments/anchors/sweep/keeps/results/code under exp3/ · checkpoints isr-aloha-act-ckpts/exp3/.

5. Caveats

• n=100 per cell, 2 seeds → equal-budget gap is ~10–20 pt with ±10 pt CI: direction solid, magnitude uncertain.
• Joint-space ISR (paper: EE-space; joint space listed as future work). 50 demos only.
• Rate-matching used a constant action-repeat; ISR's compression is non-uniform, so a variable-rate controller would be the faithful deployment and was not tested.
• One task. aloha_sim_insertion_human (ACT ≈ 20 % baseline) is the natural second test.
• A first attempt on our own SO-100 3-cube pick-into-bowl sim gave 2–8 % for every arm including clean data — ACT cannot solve that task at all, so it produced no signal (kept in the report as a negative result about the testbed, not about ISR).

6. Repos

what	where
this experiment (results, keeps, calibration, code, videos, figures)	Kavin60606/isr-aloha-transfer-cube-experiment
arm datasets (LeRobot v3.0, load with LeRobotDataset("Kavin60606/aloha_transfer_cube_<arm>"))	aloha_transfer_cube_raw, _uni3, _isr, _isr_lam0, _isr_k6
ACT checkpoints (<job>/<step>/ = LeRobot pretrained_model)	Kavin60606/isr-aloha-act-ckpts

7. Reproduce (code/)

setup_isr_box.sh                       # venv: torch cu128, lerobot @3f2c29e [aloha,training,dataset], mani-skill not needed
run_aloha_data.sh transfer_cube        # prep_generic.py (npz + calibration) → select_frames.py (raw/uni3/isr/isr_lam0) → build.py (LeRobot v3.0) → cache_videos.py
train_aloha.sh <gpu> aloha_transfer_cube_<arm> 60000 20000 [seed]
eval_watch_aloha.sh <gpu> <job> 60000 AlohaTransferCube-v0        # native, every checkpoint
eval_rep_aloha.sh <gpu> <job> <step> <N> AlohaTransferCube-v0     # rate-matched (action-repeat N)
report_aloha.py aloha_transfer_cube

Implementation notes: isr_resample.py is the official DP condensed (Apache-2.0). Training decodes from an in-RAM frame cache (cache_videos.py + memdecode.py, monkeypatched via sitecustomize.py) — AV1 decode was the bottleneck. sitecustomize.py also holds the eval shims: gym_aloha registration in forkserver children, task_description, deg↔rad conversion (datasets are in degrees), and ISR_ACTION_REPEAT.