sungkyunner/infoviz

LagLens data: what a robot executes while its policy is still thinking

Recorded runs of two robot policies that plan in action chunks (16 future moves per inference), executed under different inference latencies and execution strategies. This is the data behind the LagLens visual analytics tool (an Information Visualization term project):

• Live demo: https://joowan1108.github.io/laglens/
• Code (generation, preprocessing, interface): https://github.com/joowan1108/laglens

Every planned chunk and every executed move is logged, so each move can be traced back to the plan and the observation it came from.

Tasks

Folder	Task	Policy
pusht/	PushT (simulated, gym-pusht): a round pusher must push a T-shaped block onto a fixed T-shaped goal. Success = more than 95 % overlap within 300 steps.	Pretrained Diffusion Policy lerobot/diffusion_pusht (2 camera frames + pusher position → 16 moves), sampled with 10 DDIM steps.
catch/	Catch the ball (ours): the same pusher, PD controller and walls; a ball (radius 25 px) rolls at 42–100 px/s and bounces off the walls, with a different speed, direction and position per start state. Success = touching it within 80 steps (8 s).	Small Diffusion Policy (MLP denoiser) trained by us on scripted interception demonstrations; same chunk layout.

1 step = 100 ms (10 Hz). Positions are in pixels on a 512 × 512 table.

Schedules

A schedule = strategy × latency d × execution horizon h:

• sync: the robot holds still for d steps while the next chunk is computed, then executes h moves.
• naive async: the robot keeps executing the old chunk while the next one is computed and switches when it arrives, skipping the d moves whose time has passed.
• inpaint async: as naive, but the new chunk is generated with the already committed moves fixed and the old plan softly blended in (a training-free approximation of Real-Time Chunking).

Shown grid: d ∈ {0, 2, 4} (0–400 ms) × h ∈ {4, 8} → 14 schedules (async needs d > 0), plus one noise replicate of sync_d0_h8 (sync_d0_h8_r1, same schedule, different sampling noise) that measures how many outcomes flip by chance. Each schedule is run from the same 30 start states (seeds 1000–1029), so schedules can be compared start state by start state.

Files (per task folder)

• episodes.csv: one row per (schedule, seed) episode, 450 rows × 23 columns (the viewer shows this table).
• schedules.json: one record per schedule with aggregates (success rate, means).
• runs/<schedule>.json: per-episode detail, column-oriented: ax, ay (pusher position per step), act (executed move per step), chunk (id of the chunk the move came from, −1 = idle), j (index 0–15 of the move inside its chunk), age (steps since the observation the chunk was planned from), chunks (per chunk: t_obs observation time, t_avail time it was ready, exec executed window, a the 16 planned moves), seams (time and size of every jump at a chunk switch); PushT adds bx, by, bth (block pose) and cov (block–goal coverage); Catch adds bx, by (ball position) and dist (pusher–ball distance).

Episode columns

Column	Meaning
schedule, strategy, latency, horizon, replicate, seed	keys
success, steps_to_success	outcome (steps empty if failed)
coverage_final, coverage_max	PushT only: block–goal overlap
dist_final, ball_speed	Catch only: final pusher–ball distance (px), ball speed (px/step)
n_inferences, n_switches	chunks computed, chunk switches
jump_mean, jump_max	jump at a chunk switch (px): gap between the new chunk's first move and the move the old chunk had planned next
inner_step_mean	mean step size inside a chunk (px)
staleness_mean	mean age of the observation behind each move (steps)
idle_frac	share of steps with nothing to execute
jerk_mean	mean second difference of executed moves
think_motion_mean, think_motion_max	how far the robot moved while the policy was thinking (px)
path_len	distance travelled by the pusher (px)

Notes

• All data were generated by running the policies in simulation on CPU; no external dataset is included.
• For PushT a larger grid (46 schedules × 50 seeds) was generated first; this release contains the subset used by the interface (first 30 seeds, fixed before looking at outcomes).
• Catch the ball: ball size and deadline were calibrated only with the no-latency sync policy on separate seeds (5000–5099) before any schedule with latency was run.
• Third-party components: lerobot/diffusion_pusht checkpoint (Apache-2.0), gym-pusht (MIT). This dataset itself is released under CC BY 4.0.
• Built with the help of an AI coding assistant (Claude Code); see docs/ai_disclosure.md in the code repository.