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

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

Two experiments. First: does ISR beat downsampling and full data? Second: can a VLM make ISR smarter about where to keep frames? 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
Experiment 3 · segment-aware ISR

Can a VLM tell ISR where the frames matter?

Plain ISR uses one spacing rule for the whole episode and deletes every pause. We had Gemini 2.5 Pro split each demo into phases (transit → approach → grasp → carry → handover → retreat) and judge which pauses are deliberate, verified the boundaries frame by frame, then ran ISR per phase: dense in approach/grasp/handover, sparse in transit/carry/retreat, deliberate pauses kept at every 3rd frame.

VLM skill segments over the speed profile of six demonstrations Kept frames: plain ISR versus segment-aware ISR on one episode
37 vs 30%
Same ⅓ budget, better placement wins. sa_F (2° in precision phases, 4° in transit, pauses kept) beats plain ISR on every seed.
+14 pt
Deliberate pauses matter. Keeping the VLM-flagged holds lifts an otherwise identical arm from 15 % to 29 %.
50 ≈ 48%
No gain at half the frames. At a 50 % budget plain ISR (50 %) already matches segment-aware (48 %): the semantic layer pays off only when the budget is tight.
Success rate versus fraction of frames kept for every arm
armprecision / transit / pauseskeptsuccess (paper protocol)per seed
rawall frames100%60 ± 456 · 58 · 65
plain ISR3.5° / 3.5° / dropped32%30 ± 822 · 40 · 28
sa_A1° / 8° / dropped33%15 ± 512 · 22 · 10
sa_D1° / 8° / kept34%29 ± 730 · 37 · 20
sa_F2° / 4° / kept31%37 ± 534 · 44 · 32
sa_G1.5° / 6° / kept31%36 ± 924 · 44 · 40
sa_H1° / 3.5° / kept, no budget cap41%39 ± 445 · 36 · 36
sa_E0.5° / 8° / kept50%48 ± 453 · 43 · 46
plain ISR @ 50%1.75° / 1.75° / dropped52%50 ± 959 · 52 · 38

What we learned

  1. Deliberate pauses are information. Dropping them costs 14 points (sa_A vs sa_D); the VLM's deliberate/incidental verdicts carry real signal.
  2. Don't starve the travel phases. At 8° in transit, the robot fails to reach the cube twice as often (11 → 20 %). That loss cancelled the pause gain in round 1.
  3. With transit near ISR's density, segment awareness wins at equal budget (sa_F 37 vs 30, all seeds) and a little more without a cap (sa_H 39 at 41 %). The gain sits in the grasp phase.
  4. At 50 % kept there is nothing left to fix: plain ISR already retains enough of every phase.
  5. Segmentation had to be verified: the video-only VLM pass placed boundaries ~1 s late; timestamped frame grids fixed it. One episode needed a manual re-query.

Same policy, seeds, eval and playback rule as above. Prior art: ESPADA (arXiv 2512.07371) also segments demos with a VLM but compares to heuristic downsampling, not ISR. Artifacts: experiment repo / exp3.

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