README.md

---
license: other
task_categories:
  - robotics
  - reinforcement-learning
tags:
  - forklift
  - vr-simulation
  - telemetry
  - behavior-cloning
  - imitation-learning
  - physics-simulation
  - 50hz
  - xapi
  - rlhf
configs:
  - config_name: default
    data_files:
      - split: train
        path: "data/train-*.parquet"
      - split: validation
        path: "data/val-*.parquet"
      - split: test
        path: "data/test-*.parquet"
  - config_name: catalog
    data_files:
      - split: train
        path: "catalog/episodes.parquet"
  - config_name: xapi
    data_files:
      - split: train
        path: "xapi/xapi-*.parquet"
  - config_name: rule_events
    data_files:
      - split: train
        path: "rule_events/rule_events-*.parquet"
---

# Structured Human Action and Intent Dataset - Telemetry - xAPI

Real-world task (VR-forklift-operation), capturing aligned state → action → outcome trajectories.

The data includes explicit intent, task structure, and reward signals (success/failure, safety events), making it directly usable for policy learning, RLHF, and training agents for physical AI and world models.

## Dataset Statistics

| Split | Episodes | Timesteps (50 Hz) | Shards | Size |
|-------|----------|-------------------|--------|------|
| train | 9 | 384,950 | 3 | 183 MB |
| validation | 1 | 34,690 | 1 | 17 MB |
| test | 2 | 84,205 | 1 | 42 MB |

**Total:** 12 episodes, 503,845 timesteps

## Exercises

- `3.5`

## Schema

Each row is one physics timestep (50 Hz). Columns:

### Episode identifiers (4 columns)

| Column | Type | Description |
|--------|------|-------------|
| `session_id` | string | UUID of the recording session |
| `episode_id` | string | UUID of the episode within the session |
| `exercise_id` | string | Task label — primary grouping key for ML |
| `episode_step` | int32 | 0-based row index within this episode; use to reconstruct sequences across shard boundaries |

### Time index (2 columns)

| Column | Type | Description |
|--------|------|-------------|
| `fixed_step_index` | int64 | Physics step counter (monotonic within episode) |
| `t_sim` | float64 | Simulation time in seconds since episode start |

### Observations — 171 columns

| Group | Columns | Dim | Notes |
|-------|---------|-----|-------|
| Forklift body | `obs_pos_x/y/z`, `obs_rot_x/y/z/w`, `obs_lin_vel_x/y/z`, `obs_ang_vel_x/y/z`, `obs_steer_angle`, `obs_motor_torque`, `obs_parking_brake`, `obs_gear` | 17 | World-frame pose + drivetrain state |
| Mast & carriage | `obs_mast_height/tilt/side`, `obs_carriage_pos_x/y/z`, `obs_carriage_rot_x/y/z/w` | 10 | Fork assembly state (forklift frame) |
| HMD head pose | `obs_hmd_pos_x/y/z`, `obs_hmd_rot_x/y/z/w`, `obs_hmd_tracked` | 8 | Interpolated to physics rate, quaternion renormalized |
| Gaze | `obs_gaze_dir_x/y/z`, `obs_gaze_hit_distance` | 4 | Eye-tracking direction + surface hit distance |
| Hand controllers | `obs_hand_{left,right}_pos_x/y/z`, `obs_hand_{left,right}_rot_x/y/z/w`, `obs_hand_{left,right}_trigger/grip/tracked` | 20 | Pose interpolated; trigger/grip/tracked forward-filled |
| Environment rigidbodies | `obs_rb_{slot}_{pos,rot,lin_vel,ang_vel}_*`, `obs_rb_{slot}_present` | 112 | 8 role slots x 14 cols each (see below) |

#### Rigidbody role slots (`obs_rb_*`)

Each dynamic scene object is mapped to a fixed slot so the schema is uniform across exercises.
`present=1` when the entity provided data at that timestep; zeroed columns when `present=0`.

| Slot | Matched entity | Notes |
|------|---------------|-------|
| `rb_vehicle` | `vehicle_cb` / `vehicle_rt` | Forklift chassis — always present |
| `rb_carriage` | `carriage_cb_default` / `CarriageRail_` | Mast carriage body |
| `rb_pivot_reach` | `PIVOT_reach` | Reach-truck only; `present=0` on counterbalance |
| `rb_pivot_tilt` | `PIVOT_tilt` | Reach-truck only; `present=0` on counterbalance |
| `rb_crate_0..3` | `TargetCrate_<block>.<step>` sorted | Up to 4 crates; unused slots zeroed |

Per-slot columns (prefix `obs_{slot}_`): `pos_x/y/z`, `rot_x/y/z/w`, `lin_vel_x/y/z`, `ang_vel_x/y/z`, `present`.

### Actions — 7D float32

| Column | Range | Derivation |
|--------|-------|------------|
| `act_throttle` | [-1, 1] | `motor_torque / 4600 × gear_sign` |
| `act_steer` | [-1, 1] | `steer_angle / 70` |
| `act_brake` | [0, 1] | Prefer `forklift_state.input_brake`; fallback to `human_controls` brake axis/button |
| `act_lift` | [-1, 1] | direct from `input_lift` |
| `act_tilt` | [-1, 1] | direct from `input_tilt` |
| `act_sideshift` | [-1, 1] | direct from `input_sideshift` |
| `act_boost` | [0, 1] | direct from `input_boost` |

### Rewards (4 columns)

| Column | Type | Description |
|--------|------|-------------|
| `reward_collision` | float32 | `-0.1 × max_collision_velocity` per step |
| `reward_step_completed` | float64 | `+1.0` at timesteps where a step completes |
| `reward_task` | float64 | `+10.0` success / `-5.0` failure on final timestep (from xAPI) |
| `reward_time` | float64 | `-0.001` per timestep |

### Episode signals (4 columns)

| Column | Type | Description |
|--------|------|-------------|
| `step_token` | string | Active exercise step (forward-filled, `""` between steps) |
| `done` | bool | True on final timestep |
| `truncated` | bool | True if episode ended without a clean `episode_end` marker |
| `paused` | bool | True during paused intervals (rows excluded by default at build time) |

## Normalization

Observation vectors are **not globally normalized** — values are in Unity world-space units
(metres, rad/s, Nm). The action vector is normalized: `act_throttle` and `act_steer` are in
`[-1, 1]`; mast/fork inputs are direct joystick values in `[-1, 1]`.

For training, normalize observations using per-column statistics computed from the training split.

## Coordinate System

Unity left-handed: X right, Y up, Z forward. All positions in metres. Rotations as quaternions
in (x, y, z, w) component order.

## Known Limitations

- **VR-only data**: Episodes were recorded in a Unity VR simulator. Physics are high-fidelity
  but do not include all real-world sensor noise.
- **`obs_rb_*_present` masks**: Rigidbody slots that are absent for an exercise type (e.g.
  `obs_rb_pivot_reach_*` on counterbalance trucks) have `present=0` and zeroed pose columns
  for those timesteps.

## Loading the Dataset

```python
import pandas as pd

# Load a single shard
df = pd.read_parquet("data/train-00000-of-00001.parquet")

# Reconstruct per-episode sequences
for episode_id, episode in df.groupby("episode_id"):
    obs = episode[[c for c in episode.columns if c.startswith("obs_")]].values
    act = episode[[c for c in episode.columns if c.startswith("act_")]].values  # (T, 7)
    reward = (
        episode["reward_collision"]
        + episode["reward_step_completed"]
        + episode["reward_task"]
        + episode["reward_time"]
    ).values  # (T,)
    done = episode["done"].values  # (T,)
```

```python
# Load with Hugging Face datasets library
from datasets import load_dataset

ds = load_dataset("path/to/dataset", split="train")
```

## Companion Annotation Tables

Two companion configs provide structured event data that can be joined back to the trajectory
via `(session_id, episode_id, t_sim)`.

**`xapi` config** — one row per xAPI statement (attempted, completed, passed/failed):

```python
xapi = pd.read_parquet("xapi/xapi-00000-of-00001.parquet")
# columns: session_id, episode_id, exercise_id, statement_id, timestamp, verb,
#          actor_name, activity_id, step_token, success, completion, duration,
#          duration_seconds, score_scaled, registration, extensions_json
```

**`rule_events` config** — one row per rule firing (collision, procedure violation, etc.):

```python
rules = pd.read_parquet("rule_events/rule_events-00000-of-00001.parquet")
# columns: session_id, episode_id, exercise_id, t_sim, event_type, rule_name,
#          rule_version, severity, completion, competency_category, competency_type,
#          section_id, objective_index, pos_x/y/z, rot_x/y/z, localization_key
```

## Companion Catalog

The `catalog` config provides episode-level metadata (exercise_id, duration, quality flags, stream
inventory) without downloading any trajectory data:

```python
catalog = pd.read_parquet("catalog/episodes.parquet")
```

## License

**[PLACEHOLDER: license]**

## Citation

**[PLACEHOLDER: citation]**