seil-umd/STL-Parkour

Dataset Card for Parkour-STL

Quadruped parkour trajectories paired with STL — for research at the intersection of reinforcement learning and formal methods for robotics.

Status: v0.1 draft card. Will be populated as the dataset is completed.

Dataset Summary

Parkour-STL is a dataset of Unitree Go2 extreme-parkour rollouts generated in IsaacSim 6.0 / IsaacLab 3.0, paired with (a) a library of normalized, STL-monitorable predicates sampled at 10 Hz, and (b) a reference library of Signal Temporal Logic (STL) specifications with ground-truth ternary (SAT / UNK / VIOL) labels computed by quantize-then-compute (QtC) STLCG++.

1. Raw superset (~75 GB) — full per-control-step simulation state (kinematics, per-body contacts, height-scan, actions, goal signals). Lets you derive your own predicates/specs.
2. Predicates — derived continuous, normalized signals at 10 Hz (the ready-to-use layer).
3. Specs + labels — a reference STL spec library and its QtC ternary labels.

Supported Tasks & Use Cases

• Neural / learned STL monitoring — train and benchmark learned monitors (e.g., ternary logic-gate networks, recurrent monitors) against the symbolic ground truth; study online causal vs predictive verification.
• Online runtime verification under partial observability — bounded-future operators (e.g., F[0,K]) create a causal gap a predictive monitor can close but a causal one cannot.
• Failure / fall prediction & anomaly detection — labeled crashes across competence.
• Competence-aware / safe RL — does a monitor's verdict (and its UNK mass) track policy skill.
• Predicate / representation learning — derive task/safety predicates from the raw state layer.
• Offline RL & imitation (secondary) — multi-competence state–action rollouts.

Dataset Structure

Layers / files

raw_superset/   rollout_seed{S}_diff{D}_ckpt{C}_sidecar.npz   # per-step sim state, ~75 GB total
predicates/     rollout_seed{S}_diff{D}_ckpt{C}_pred.npz       # (N, 200, P) normalized predicates
specs/          spec_library.json + labels_*.npz               # STL defs + QtC ternary labels
videos/ (extra) chase-cam mp4 samples per (seed, ckpt, env)    # qualitative inspection only

S ∈ {0,1,3} (seeds), D ∈ {easy, hard, hard_spread} (difficulty regimes), C ∈ {0,300,600,900,1200,1499} (checkpoints).

A data instance (predicates layer)

One trace = one environment's behavior from episode start to its first reset, truncated and reason-conditioned-padded to a fixed length:

• predicates: (200, P) float32, ∈ [−1, 1], boundary 0 ⇔ property satisfied (ρ>0 ⇔ SAT).
• 200 samples = 20 s at 10 Hz (1000 native 50 Hz control steps ÷ 5).

Data fields

Predicates (N, 200, P) float32 + predicate_names (column order). Provenance / split keys per trace: seed_idx, ckpt_step, difficulty, terrain_cell_id, terrain_type, terrain_level, traj_type (0=crash, 1=reach-goal success, 2=timeout). Raw superset fields (per native step): projected_gravity_b, root_pos_w, root_quat_w, root_lin_vel_w, root_ang_vel_b, joint_pos, joint_vel, applied_torque, per-body contact forces (base/thigh/calf/foot), feet_in_contact, 32-ray height_above_terrain, cur_goal_idx, env_goals, env_origins, reset_terminated, reset_time_outs, raw/processed actions.

Splits (leakage-free)

The independent unit is the terrain course (cell), not the environment (same-cell envs are one course with different domain randomization). Canonical split: partition by terrain_cell_id, stratified by terrain_type, so every course type appears in test and no cell is shared across train/test. Provided alternatives: checkpoint-held-out (generalize across competence) and seed-held-out (cross-policy generalization).

Predicate Library

All predicates ∈ [−1, 1] with a fixed satisfaction boundary at 0. Pilot set (P = 11; to be finalized — saturated/binary signals will be regraded with saturation-aware normalization):

#	name	meaning (ρ>0 ⇔ SAT)	type
1	track_goal_vel	moving toward current sub-goal at ≥ commanded speed	macro / graded
2	face_goal	oriented at the current sub-goal	macro / graded
3	progress	course progress (2·cur_goal_idx/8 − 1)	macro / discrete
4	near_final_goal	proximity to the final goal (dist→0 ⇒ +1)	macro / graded
5	upright	body uprightness (−gravity_z)	micro / graded
6	body_clear	no base/calf/thigh collision	micro / safety
7	attitude_calm	low angular velocity (not tumbling)	micro / graded
8	grounded	fraction of feet in contact (+1 all four, −1 airborne)	micro / discrete
9	episode_active	inside the real episode vs the pad	gate
10	terminal_crash	trace ended in a fall/collision	terminal flag
11	terminal_success	trace ended reaching the final goal	terminal flag

The consumer thermometer-encodes each predicate (K=8 → 17 levels) before STL evaluation.

STL Specification Library

Reference specs are composite hybrids (macro task ∧ micro gait), with bounded-future horizons that create a causal gap and a genuine UNK band. Flagship:

Φ1 = G( episode_active>0 → F[0,20]( track_goal_vel>0 ∧ face_goal>0
                                    ∧ upright>0 ∧ body_clear>0 ∧ attitude_calm>0 ) )

"Never more than 2 s without a moment of simultaneously advancing-and-facing the goal and being upright, collision-free, and calm." Additional reference specs cover long-horizon completion (F[0,200] near_final_goal>τ), safety-with-recovery, and leap-and-land recovery. Each ships with QtC ternary labels; horizons are in 10 Hz samples (10–30 for windows, up to 200 for traversal-scale).

Dataset Creation

Source. Unitree Go2 in IsaacSim 6.0 / IsaacLab v3 (Extreme-Parkour parkour_focused terrain mix); PhysX 200 Hz, decimation 4 → 50 Hz control; 20 s (1000-step) episodes; 6144 parallel environments per rollout. Policies are RL (PPO) checkpoints at six training stages × seeds, giving the competence axis. Difficulty regimes are set by rescaling the terrain difficulty band.

Capture & processing. A per-step state superset is recorded, each trace is truncated at its first reset, then reason-conditioned padded (velocities zeroed; a crash injects the failure into safety predicates), downsampled to 10 Hz by windowed reduction (max/min/mean per 5-step bucket), and normalized to [−1, 1] with fixed physical bounds.

Competence axis & failure distribution (illustrative — seed 0, hard regime):

ckpt	crash %	reach-goal success %	timeout %
0	0	0	100
300	43	2	55
600	55	10	34
900	29	52	19
1200	19	71	10
1499	18	76	6

Success rises monotonically with competence; crashes peak at intermediate skill — a property that holds across seeds/regimes (full table TBD).

Annotations. Ground-truth verdicts are computed symbolically (STLCG++ QtC) over the reference specs; no labels are baked into the predicate layer — users may relabel with their own specs.

Baselines / Benchmark

Reference monitors to be evaluated and reported: R-DTLGN, GR-DTLGN, BLGN, LSTM, with online causal STLCG++ as the symbolic baseline. Metrics: verdict accuracy, UNK calibration, the causal-vs-predictive gap, Z3 realizability/soundness, and sampling-PAC bounds. Results: TBD (populated when training completes — not estimated here).

Considerations for Using the Data

• Simulation only — IsaacSim/PhysX dynamics; a sim-to-real gap applies.
• Single robot, single task family — Go2, extreme-parkour terrains; not a general-locomotion corpus.
• Predicates and specs are one design — mitigated by shipping the raw layer so users can derive their own; STLCG++ QtC is one labeling convention.
• Known pilot caveats being addressed before release: one safety predicate (body_clear) is currently near-binary (saturation-aware regrading planned); normalization constants are being finalized against full-scale value histograms.
• Sampling biases: terrain-type proportions, checkpoint selection, and difficulty-regime mix are design choices documented above.

Provenance, Versioning & Citation

Generation stack and code are released for reproducibility (static data is the primary product; rebuilding the generator requires the exact IsaacSim/IsaacLab pins). Versioned with a changelog; v0.1 = pilot. Mirrored to a DOI archive (e.g., Zenodo) for citation.

Datasheet (condensed)

• Why: to give the RL ∩ formal-methods community real robot data with STL-monitorable predicates, a competence axis, and genuine failures.
• What: time-series robot trajectories (proprioception/contacts/scan/actions/goals), derived predicates, STL specs + ternary labels. No PII.
• How collected: simulation rollouts of RL checkpoints; fully synthetic.
• Preprocessing: truncate-at-reset, reason-conditioned padding, 10 Hz windowed reduction, fixed-bound normalization (all documented + code released).
• Recommended uses / out-of-scope: monitoring/verification/failure-prediction research; not a sim-to-real-validated control benchmark.
• Maintenance: versioned releases, issue tracker, changelog; raw + derived layers kept in sync.