zengxy0624/desimplex-pusht-eval

DeSimplex Push-T evaluation raw data

Per-episode raw logs of the Push-T evaluations in the DeSimplex paper: obstacles, goal, true and perceived states, end-effector trajectory, commanded actions, and the active controller at every step. Figures can be made or changed from these files alone; nothing needs to be re-run.

Contents

anchor200_20261004_dpobs/ is the paper's simulation result: seeds 10001–10200, mixed obstacle set, RGB noise σ = 10, at most 600 steps and a 300 s time budget. All three methods ran the same 200 episodes.

Method	Files	Success (%)	Episodes with a collision	Steps	Time (s)	SCT
HPA only (Diffusion Policy, no shield)	hpa.json, hpa_traces/	67.0	65	101.4	12.06	0.667
HAA only (MPC)	haa.json, haa_traces/	97.5	0	138.2	31.74	0.507
DeSimplex	switch.json, switch_traces/	96.0	0	122.7	19.77	0.835

Steps and time are means over the successful episodes; time is physical_time_s. SCT is the mean over the 200 seeds of 0 for a failure and T*/T for a success, where T* is the fastest successful time among the three methods on that seed. The paper's example episode is seed 10131.

plot_episode.py                           one-episode figure from a trace.json alone
anchor200_20261004_dpobs/
  <policy>.json                           results (one row per seed), summary, config
  <policy>_traces/seed_<N>/trace.json     one episode

Quick start

hf download zengxy0624/desimplex-pusht-eval --repo-type dataset --local-dir desimplex-pusht-eval
cd desimplex-pusht-eval
python plot_episode.py anchor200_20261004_dpobs/switch_traces/seed_10131/trace.json out.png

import json
ep = json.load(open('anchor200_20261004_dpobs/switch_traces/seed_10131/trace.json'))
ep['scene']['obstacles'][0]['polygon']                                   # [[x, y], ...]
ee = [(s['pre_true']['agent']['x'], s['pre_true']['agent']['y']) for s in ep['trace']]
ctrl = [s['planner'] for s in ep['trace']]                               # 'HPA' / 'HAA'

Frames and units

• The world is 512 × 512 px, in the pixel frame of the rendered image: x points right, y points down. Invert the y axis (as plot_episode.py does) to match the videos.
• Angles are in radians, pymunk convention, not wrapped (−10.83 is a valid angle).
• One step is 0.1 s of simulated time.
• The end-effector (agent) is a disc of radius 15 px.
• The T (block) pose (x, y, angle) is its body origin. Its outline is these local vertices, rotated by angle and translated by (x, y): [(-60,0), (60,0), (60,30), (15,30), (15,120), (-15,120), (-15,30), (-60,30)]. That is a 120 × 30 crossbar and a 30 × 90 stem, with the origin at the middle of the crossbar's outer edge. world = R(angle) · local + (x, y), where R = [[cos, −sin], [sin, cos]].
• The goal is [256, 256, π/4] in every episode. Success means the T covers at least 85 % of the goal T's area.
• The paper's margins are in each <policy>.json config, in px: r_T = haa.margin.block_clearance (4.953, T outline to obstacle), r_a = haa.margin.agent_radius + haa.margin.agent_clearance (18.352, end-effector centre to obstacle), r_w = haa.margin.cert_wall_buffer (10, T to the frame edge). The hand-back condition adds switch.margin_clearance_extra (19), switch.margin_pusher_extra (32) and switch.margin_wall_extra (13) to them. End-effector clearance is not logged; compute it from pre_true.agent and scene.obstacles[].polygon.

Episode file (trace.json)

summary: the episode outcome, the same as its row in <policy>.json.

Key	Meaning
success	coverage ≥ 0.85 reached within the budget
obstacle_hit	the T or the end-effector touched an obstacle; the episode ends there
length	number of steps
physical_time_s	controller compute time + 0.1 s × steps; the 300 s budget applies to this
timed_out, timeout_reason	ran out of the 300 s budget
max_coverage	best coverage reached
hpa_steps, haa_steps, switch_to_haa, switch_to_hpa	switch only: steps under each controller and number of hand-overs

The remaining keys are timing breakdowns and the safety margins in px.

scene: ground truth, fixed for the episode.

• goal: [x, y, angle]
• obstacles: 0–3 per episode. Each has:
  • kind: circle, rect, triangle or wall
  • pos: the centre
  • size_a, size_b: circle radius; rect or wall half-length and half-width; triangle side length
  • angle
  • polygon: world-frame vertices. This is the exact geometry used for collision checks; circles are 32-gons.

trace: one entry per control step.

Key	Meaning
step	step index
action	[x, y], the commanded end-effector target (px); the end-effector tracks it through the environment's PD controller, with its speed capped at 300 px/s (150 px/s on steps where HAA acts) and its acceleration at 2000 px/s²
pre_true, post_true	true state before and after the step: agent {x, y, vx, vy}, block {x, y, angle, vx, vy, angular_velocity}
pre_perceived	what the controller saw before the step: the end-effector state (exact, robot-owned) and the T pose estimated from the noisy RGB frame (fit_score, pose_valid)
block_pos_error, block_angle_error	T error, true − perceived (px, rad)
true_t_clearance_pre, true_t_clearance_post, perceived_t_clearance_pre	distance (px) from the true or perceived T to the nearest obstacle, using the obstacles as perceived at the start of the episode. Seed 10057 has no obstacles, so these are Infinity there (Python's json reads it; strict JSON parsers do not)
coverage, reward, obstacle_hit, is_success, terminated, truncated	environment outputs after the step
planner	switch runs: the active controller, HPA or HAA (BRAKING steps count as HPA; a hand-back is a change from HAA to HPA). Empty in HPA-only and HAA-only runs
phase	HPA runs: HPA-only. HAA runs: NAV, BRAKE or PUSH. Switch runs: HPA; BRAKING (HPA's plan failed the safety check, so it brakes for 2 steps and then hands over to HAA); or the HAA phase
compute_dt_s	controller wall-clock time for the step
debug	controller internals; the keys vary by controller and phase

Provenance

• HPA only and HAA only come from the 200-seed run of all three methods by push_t/scripts/run_paper_anchor_200x3_4090.sh at code commit 56a2a1e (2026-10-03).
• DeSimplex was re-run at commit 798b16f (2026-10-04), which changes how DeSimplex feeds the Diffusion Policy: the policy also receives the current frame on braking and HAA steps, its observation history restarts after a perception gap, and its actions are clipped to [0, 512]. The fix does not affect the other two methods; HPA only was re-checked bit-identical on seeds 10001–10020 at 798b16f.
• The three runs share one config except policy and trace_dir, and ran one at a time on the same machine (AMD Ryzen 9 5950X, NVIDIA RTX 4090), with the HAA planner in 4 worker processes. Controller compute time counts toward physical_time_s and the 300 s budget, so times depend on the hardware.
• Every method receives the rendered RGB frame with i.i.d. Gaussian noise of standard deviation 10 intensity levels, plus the robot's own end-effector state. The noise is a deterministic function of the seed, the frame index and the image resolution, so all methods see identical images.
• HPA weights (HPA only and DeSimplex): final_20261002.pt in the model repo zengxy0624/pusht-desimplex-final, SHA-256 fc8d2fa22c69ddf8db6c1f62097835b651121ff64adb909890b69618421d04c7; its model card describes the training.
• <policy>.json is uploaded unchanged: trace_path and the paths in config are absolute paths on the authors' machine and are kept for provenance only. The traces are at anchor200_20261004_dpobs/<policy>_traces/seed_<N>/trace.json.
• These files are the record. A re-run is not guaranteed to reproduce them: controller time is measured on the wall clock and counts toward the 300 s budget, and the planner's results differ between machines.
• An earlier version of this repository held sim_anchor_fcc9a8b/, an earlier run (code fcc9a8b, earlier HPA weights) that the paper no longer uses. It remains in the history: hf download zengxy0624/desimplex-pusht-eval --repo-type dataset --revision f97658b333c17e09c6d95a508aa887ea28f4ba64.