Replication · ALOHA transfer-cube · 50 human teleop demos · September 2026

Does ISR beat downsampling — and does it beat using all the data?

A robot policy learns from human demonstrations. ISR is a way to throw away the boring frames (pauses, slow drift) and keep the informative ones. We trained the same policy on three versions of the same 50 demonstrations and counted how often each one completed the task in simulation.

In one minute
30 vs 10%
ISR wins the paper's comparison. With the same ⅓ of the frames, ISR-trained policies succeed 3× as often as every-3rd-frame downsampling. All three training seeds agree.
60%
But all the data still wins. The policy trained on every frame succeeds twice as often as ISR. Throwing away frames costs success on a 50-demo dataset.
2–11%
Speed matters. If a compressed-data policy is run at full speed instead of the speed of its training data, it collapses. ISR output has no clock; you must supply one.
The three versions of the data
RawEvery frame of the 50 demonstrations: 20,000 frames. The reference. Uniform 3×Keep every 3rd frame, 6,700 frames. What the ISR paper compares against ("downsampling"). ISRKeep a frame every time the arm has moved 3.5° of joint travel (plus a small acceleration bonus and every gripper open/close). Pauses collapse to one frame; fast motion is kept densely. 6,412 frames — the same budget as uniform 3×. Paper protocolThe policy is run at the frame rate of its training data (a ⅓-budget policy is run at ⅓ speed). This is how the paper deployed ISR on its robot. Native rateThe same policy run at full simulator speed. Shown as the thin grey bar. Not part of the paper — included to show what happens if you forget to slow it down.
Joint speed over one demonstration with kept frames marked for uniform 3x and ISR

One demonstration. Ticks are kept frames. Uniform keeps pauses (flat speed) at the same density as motion; ISR drops them and concentrates on movement.

Result

How often the policy completed the handover

0%10%20%30%40%50%60%70%60%Raw100% of frames30%11%ISR32% of frames10%2%Uniform 3×34% of frames
rawISRuniform 3×same policy at native rateone training seed
training dataframes keptsuccess (paper protocol)per seedat native rate
Raw
all 20,000 frames
100%60% ± 456 · 58 · 65same
ISR
6,412 frames · d 3.5° · λ 0.0004
32%30% ± 822 · 40 · 2811%
Uniform 3×
6,700 frames · every 3rd
34%10% ± 36 · 14 · 82%

Each number: 200 test episodes with random cube positions (±7 pt), averaged over 3 independently trained policies (± = spread across seeds). Policy: LeRobot ACT, 20k steps, identical settings for every row. Same MuJoCo scene the humans demonstrated in.

See it

Rollouts from the seed-1000 policies

Top camera, same view the policy sees. Success = the cube ends up in the left gripper. "Successful episodes" were picked from a 50-episode re-run of each seed-1000 policy (raw 25 successes, ISR 7, uniform 2). "First two episodes" are episodes 0 and 1 of that run, unfiltered, so you also see typical failures. Watch how fast the arm approaches the cube in the native-rate clips.

Raw

60% success · runs at its own rate
Successful episodes
episode 2 — success, handover at 5.2 s
episode 4 — success, handover at 6.0 s
First two episodes, unfiltered
episode 0 — failed: lifted the cube, no handover
episode 1 — failed: lifted the cube, no handover

ISR

30% success · paper protocol
Successful episodes
episode 14 — success
episode 22 — success
First two episodes, unfiltered
episode 0 — failed: reached the cube, missed the grasp
episode 1 — success

Uniform 3×

10% success · paper protocol
Successful episodes
episode 14 — success (one of 2 in 50)
episode 32 — success (one of 2 in 50)
First two episodes, unfiltered
episode 0 — failed: reached, missed the grasp
episode 1 — failed: reached, missed the grasp

ISR at native rate

11% success · not slowed down
First two episodes, unfiltered
episode 0 — failed: rushed the approach
episode 1 — failed: rushed the approach
Is this a fair replication?
ISR vs every-3rd-frame at the same ⅓ budget
as in paper
Gripper frames always kept; acceleration ≈ 20 % of the selection signal
as in paper
Judged only by completed tasks in closed loop, no offline error metrics
as in paper
Policy executed at its training-data rate
as in paper
Paper used end-effector position in meters; we use joint angles in degrees (the paper's own numbers applied here keep 93 % of frames and behave like uniform sampling)
differs
Paper: real robot, 100–150 demos, two large policies, 3 tasks, multi-operator test. Here: simulation, 50 demos, ACT, 1 task
smaller
Raw full-data row, native-rate row, 3 seeds × 200 episodes
added by us

What we conclude

  1. The paper's claim holds. Selecting frames by motion beats selecting by the clock: +20 pt here, the paper reports +24 on real robots.
  2. ISR is a better compressor, not a data substitute. Full data beat it by 30 pt. Use ISR when you must shrink data; don't expect it to beat keeping everything.
  3. Deployment speed is part of the method. ISR removes time from the data, so the controller must put it back. The paper's hardware did this implicitly; in simulation you have to do it on purpose.
  4. Set ISR's knobs by outcome. Choose the frame budget you want and the acceleration share (0–20 %); the paper's raw numbers don't carry across robots or units.
Artifacts