--- license: bsd-3-clause pretty_name: NeDM Neural Reduced Dynamics Datasets tags: - robotics - vehicle-dynamics - project-chrono - simulation - time-series - reduced-order-model - reinforcement-learning - terramechanics task_categories: - time-series-forecasting - robotics size_categories: - 100M **Learning the Right Abstraction: Neural Reduced Dynamics for Complex Robot Control** > Harry Zhang and Dan Negrut, 2026 (preprint). > Project page: · Code: Every dataset here is exactly what the paper's models were trained and validated on. Two tiers are published (70 GB in total): * **`raw/`** — every recorded channel of every episode (Parquet, float32), plus a per-episode index and the byte-exact collection metadata (driver profiles, seeds, terrain, termination causes). This is the reusable resource: build your own reduced states from it. * **`processed/`** — the four training caches the deployed models read (`.npy`), so the paper's training configs run without touching the raw data. ## Datasets | Config | System | Terrain / task | Rate | Episodes (train / val) | Rows | Raw Parquet | Columns | |---|---|---|---|---|---|---|---| | `hmmwv_flat` | HMMWV (`HMMWV_Full`, TMEASY tires, SMC contact) | flat rigid, μ = 0.9, 900 × 900 m | 100 Hz | 32,768 (26,124 / 6,644) | 160,551,861 | 44.0 GB, 128 shards | 105 | | `hmmwv_bumpy` | HMMWV (same vehicle) | rigid heightmap, 100 random 500 × 500 m fields, ±0.6 m | 100 Hz | 1,360 (1,104 / 256) | 4,511,778 | 1.3 GB, 4 shards | 105 | | `hmmwv_crm` | HMMWV (rigid-mesh tires) | CRM deformable soil (SPH), 150 × 150 × 0.25 m | 100 Hz | 2,000 (1,582 / 418) | 2,884,961 | 0.8 GB, 4 parts | 105 | | `arm` | 4-DOF LRV arm mounted on an M113 (base held) | free-space joint motion, PD torque control | 50 Hz | 15,000 (12,716 / 2,284) | 920,640 | 0.09 GB, 15 shards | 47 | | `tracked` | M113 tracked vehicle, arm welded at home | flat rigid drive, 10 manoeuvre families | 50 Hz | 2,160 (1,808 / 352) | 1,683,484 | 0.2 GB, 60 shards | 42 | Roles in the paper: `hmmwv_flat` + `hmmwv_crm` train the terrain-conditioned HMMWV NN-ROM (Study Case I); `hmmwv_bumpy` is the zero-shot out-of-distribution test regime and never enters training, model selection, normalisation or reward tuning; `tracked` and `arm` train the two Study Case II NN-ROMs. All five were collected with PyChrono 10.0.0 (conda `projectchrono` channel) using the collectors in the code repository (`src/nedm/hmmwv_data.py`, `scripts/collection/collect_hmmwv_crm_dataset.py`, `src/nedm/arm_data.py`, `src/nedm/tracked_vehicle_data.py`). ### Splits Train/val is decided **per episode at collection time** and stored in the `split` column: `sha1(episode_id)[:8] / 0xFFFFFFFF < validation_ratio → val` (ratio 0.20 for the HMMWV sets, 0.15 for `arm` and `tracked`). Whole episodes stay together; the assignment depends only on the episode id, so it is stable under re-sharding. `train` and `val` files never share an episode. ## Layout ``` raw//train/.parquet transitions, one file per raw collection shard raw//val/.parquet raw//episodes.parquet one row per episode: index entry + JSON sidecar (see below) raw//metadata.tar.gz byte-exact originals: dataset_index.json, collector_config.resolved.json, episodes/.json sidecars, shard-plan manifests processed// .npy training caches + metadata.json (state layout, normalisation) assets/bumpy_terrain/bumpy_field_NNN.bmp the 100 heightmaps behind hmmwv_bumpy (256×256, 8-bit, gray 128 = 0 m) release_manifest.json sha256 / size / row count of every file, tool versions, source commit ``` Rows are ordered by episode (collection order) then `sample_index`; each episode is contiguous inside exactly one file. Column names and order are the collector's CSV columns, unchanged. All physical channels are `float32` (`time_s` is `float64`; `sample_index`, `collision` are `int32`; identifiers are dictionary-encoded strings). Files are zstd-compressed with BYTE_STREAM_SPLIT float encoding and ≤ 262,144-row row groups. ### Column groups **HMMWV (`hmmwv_flat`, `hmmwv_bumpy`, `hmmwv_crm` — identical 105 columns).** Units are in the names (`_m`, `_mps`, `_mps2`, `_rad`, `_radps`, `_n`, `_nm`); world frame is Chrono's ISO (x forward, z up), body frame is the chassis frame. | Group | Columns | |---|---| | identifiers | `episode_id`, `scenario_name`, `scenario_family`, `split`, `sample_index`, `time_s` | | driver command (the action) | `driver_steering` ∈ [−1, 1], `driver_throttle` ∈ [0, 1], `driver_braking` ∈ [0, 1] | | chassis pose | `pos_{x,y,z}_m`, `quat_e0..e3`, `roll_rad`, `pitch_rad`, `yaw_rad` | | chassis motion | `vel_world_{x,y,z}_mps`, `vel_body_{x,y,z}_mps`, `acc_world_*`, `acc_body_*`, `ang_vel_world_{x,y,z}_radps`, `ang_vel_body_{x,y,z}_radps`, `speed_mps`, `body_slip_rad`, `roll_rate_radps`, `yaw_rate_radps` | | per-tire block, prefix `tire_{fl,fr,rl,rr}_` (16 × 4) | `longitudinal_slip`, `slip_angle_rad`, `camber_angle_rad`, `force_world_{x,y,z}_n`, `moment_world_{x,y,z}_nm`, `force_wheel_{fx,fy,fz}_n`, `spindle_omega_radps`, `wheel_vx_mps`, `slip_ratio`, `deflection_m` | `force_wheel_*` and `slip_ratio` are derived from spindle state and the world-frame force so they are computed identically on rigid and CRM terrain (on CRM the tire force comes from the FSI solver, `tire_force_source: crm_fsi`). The paper's 15-D HMMWV state is `vel_body_x_mps, vel_body_y_mps, roll_rad, pitch_rad, roll_rate_radps, ang_vel_body_y_radps, yaw_rate_radps` + `tire_*_force_wheel_fz_n` (4) + `tire_*_spindle_omega_radps` (4); action is the driver triple; pose for open-loop rollout scoring is `pos_x_m, pos_y_m, yaw_rad`. Recording starts after a settle/warm-up window (`warmup_s` 2.5 s rigid, 0.2 s CRM), so `time_s` does not start at 0. **Arm (`arm`, 47 columns).** Each row is one 50 Hz control step written as a transition `(s, a, s')`: `q_0..3`, `qd_0..3` (joint angle rad / rate rad/s), `qcmd_0..3` (current joint command), `act_0..3` (Δq_cmd), `qcmd_next_0..3` (command applied over this step — the paper's action), `q_next_0..3`, `qd_next_0..3`, end-effector position in world (`ee_{x,y,z}`, `ee_next_*`) and in the vehicle base frame (`ee_base_{x,y,z}`, `ee_next_base_*`), plus `collision` (0/1), `collision_kind` (`ground` / `track` / `joint_limit` / empty), `contact_force_n`. Episodes start from the home pose with random command increments and terminate on the first contact or joint-limit hit, so lengths are 9–500 steps (mean ≈ 58). The paper's 8-D state is `[q, qd]` with the end effector recovered by forward kinematics. **Tracked (`tracked`, 42 columns).** The HMMWV chassis block without `body_slip_rad` and without tire channels, plus `left_sprocket_speed_radps`, `right_sprocket_speed_radps`. The paper's 3-D state is `vel_body_x_mps, vel_body_y_mps, yaw_rate_radps`; action is the driver triple. ### `episodes.parquet` and the metadata bundle `episodes.parquet` flattens each episode's `dataset_index.json` entry and its JSON sidecar (nested values are JSON strings): `episode_id`, `split`, `scenario_family`, `rows`, `duration_s`, `warmup_s`, `source_shard`, `parquet_file`, and per dataset e.g. `height_map_index` / `height_map` / `terminated_out_of_bounds` (bumpy), `terminated_near_boundary`, `crm_particles`, `crm_force_summary`, full `driver` profile (CRM), `collision_kind`, `collision_links`, `start_q` (arm), `diverged` (tracked), `tire_nominal_radius_m`. `metadata.tar.gz` is the untouched original metadata: per shard `dataset_index.json` and `collector_config.resolved.json` (every materialised scenario: driver profile, seed, family, terrain and solver settings), every per-episode sidecar, and the shard-plan manifests. It is what lets the release be turned back into the collectors' original directory tree (below). ## Loading **Streaming with 🤗 `datasets`** (no download of the 44 GB flat set required): ```python from datasets import load_dataset ds = load_dataset("harryzhang1018/NeDM", "hmmwv_crm", split="val", streaming=True) for row in ds.take(3): print(row["episode_id"], row["time_s"], row["vel_body_x_mps"], row["tire_fl_force_wheel_fz_n"]) episodes = load_dataset("harryzhang1018/NeDM", "hmmwv_bumpy_episodes", split="train") ``` **Arrow / DuckDB** — one shard at a time, with row-group statistics for pushdown: ```python import pyarrow.parquet as pq t = pq.read_table("raw/hmmwv_flat/train/shard_017.parquet", columns=["episode_id", "time_s", "vel_body_x_mps", "yaw_rate_radps"], filters=[("scenario_family", "==", "chirp_steer")]) ``` **Reproducing the paper** with the code repository (`conda env create -f environment.nedm.yml`): ```bash # training caches -> artifacts/training_datasets/, then any config in configs/ runs verbatim PYTHONPATH=src python scripts/release/download_nedm_datasets.py --dataset all --no-raw --processed PYTHONPATH=src python scripts/training/train_hmmwv_dynamics.py --config configs/tracked_transformer_v1.json # raw Parquet -> the collectors' original per-episode CSV tree under artifacts/datasets/, # so scripts/preprocess/* and the RL reference builders run unchanged PYTHONPATH=src python scripts/release/download_nedm_datasets.py --dataset arm --rehydrate ``` The rehydrated CSVs carry the float32 values the trainer uses; caches rebuilt from them are bit-identical to the ones in `processed/` (this is checked in the release validation). ## Processed caches | Cache | Trained model | State | Action | Transitions (train / val) | Size | |---|---|---|---|---|---| | `hmmwv_tire_rigid_300g_normal_force_omega_seq_v1` | terrain-conditioned HMMWV NN-ROM (flat share) | 15-D | 3-D | 128,043,338 / 32,475,755 | 23.1 GB | | `hmmwv_crm_2000_normal_force_omega_seq_v1` | terrain-conditioned HMMWV NN-ROM (CRM share) | 15-D | 3-D | 2,280,431 / 602,530 | 0.4 GB | | `arm_dyn_v3_8d_seq16_v1` | arm NN-ROM | 8-D `[q, q̇]` | 4-D `q_cmd` | 763,886 / 141,754 | 87 MB | | `tracked_drive_v2_seq16_v1` | tracked-base NN-ROM | 3-D `[vx, vy, r]` | 3-D | 1,407,465 / 273,859 | 81 MB | Each cache holds contiguous `float32` arrays `{train,val}_{states,actions,targets,rollout}.npy` (`targets = states[t+1] − states[t]`, `rollout` = pose per recorded row), `episode_starts` / `episode_lengths`, `{train,val}_episodes.json` (episode ids and provenance) and `metadata.json` (`state_fields`, `action_fields`, `dt_s`, train-split mean/std used for normalisation). Values are raw physical units; the model applies the statistics. ## Known limitations * `hmmwv_bumpy` episodes are short (mean 3.3 k rows) because 78 % end on the 0.9 × 500 m keep-in guard; the regime is meant as a test set. * The arm collection is restricted to free-space motion (episodes end at first contact) and under-samples the lower/rear workspace. * CRM episodes are 12–18 s long (SPH cost) and use rigid-mesh tires; the CRM tire "force" is the fluid–solid interaction force. * Simulation is deterministic and noise-free; there is no sensor model. ## Citation ```bibtex @article{zhang2026abstraction, title = {Learning the Right Abstraction: Neural Reduced Dynamics for Complex Robot Control}, author = {Zhang, Harry and Negrut, Dan}, journal = {Preprint}, year = {2026} } ``` License: BSD-3-Clause (same as the code). Simulation assets are Project Chrono's HMMWV and M113 models; the LRV arm geometry is in the code repository (`src/arm_model/`).