README.md

---
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<n<1B
configs:
  - config_name: hmmwv_flat
    default: true
    data_files:
      - split: train
        path: raw/hmmwv_flat/train/*.parquet
      - split: val
        path: raw/hmmwv_flat/val/*.parquet
  - config_name: hmmwv_bumpy
    data_files:
      - split: train
        path: raw/hmmwv_bumpy/train/*.parquet
      - split: val
        path: raw/hmmwv_bumpy/val/*.parquet
  - config_name: hmmwv_crm
    data_files:
      - split: train
        path: raw/hmmwv_crm/train/*.parquet
      - split: val
        path: raw/hmmwv_crm/val/*.parquet
  - config_name: arm
    data_files:
      - split: train
        path: raw/arm/train/*.parquet
      - split: val
        path: raw/arm/val/*.parquet
  - config_name: tracked
    data_files:
      - split: train
        path: raw/tracked/train/*.parquet
      - split: val
        path: raw/tracked/val/*.parquet
  - config_name: hmmwv_flat_episodes
    data_files: raw/hmmwv_flat/episodes.parquet
  - config_name: hmmwv_bumpy_episodes
    data_files: raw/hmmwv_bumpy/episodes.parquet
  - config_name: hmmwv_crm_episodes
    data_files: raw/hmmwv_crm/episodes.parquet
  - config_name: arm_episodes
    data_files: raw/arm/episodes.parquet
  - config_name: tracked_episodes
    data_files: raw/tracked/episodes.parquet
---

# NeDM — Neural Reduced Dynamics Datasets

High-fidelity [Project Chrono](https://projectchrono.org) trajectories used to train the
neural reduced dynamics models (NN-ROMs) in

> **Learning the Right Abstraction: Neural Reduced Dynamics for Complex Robot Control**
> Harry Zhang and Dan Negrut, 2026 (preprint).
> Project page: <https://uwsbel.github.io/NeDM/> · Code: <https://github.com/uwsbel/NeDM>

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/<config>/train/<shard>.parquet     transitions, one file per raw collection shard
raw/<config>/val/<shard>.parquet
raw/<config>/episodes.parquet          one row per episode: index entry + JSON sidecar (see below)
raw/<config>/metadata.tar.gz           byte-exact originals: dataset_index.json, collector_config.resolved.json,
                                       episodes/<id>.json sidecars, shard-plan manifests
processed/<cache>/                     .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/`).