Document the inlined tracker rollouts and the sharded layout

README.md

@@ -18,9 +18,9 @@ configs:
 - config_name: preference
   data_files:
   - split: train
-    path: preference_pair/train.parquet
+    path: preference_pair/train/train-*.parquet
   - split: test
-    path: preference_pair/test.parquet
+    path: preference_pair/test/test-*.parquet
 ---
 
 # Dataset Card for HumanTracker
@@ -30,9 +30,9 @@ configs:
 HumanTracker is a humanoid motion-tracking benchmark. This release contains two complementary subsets:
 
 - **`motions/`** — the evaluation test split: retargeted 29-DoF reference trajectories, grouped into four motion families.
-- **`preference_pair/`** — 6,000 human preference pairs over synchronized tracker rollouts, each stored with the corresponding source-motion clip.
+- **`preference_pair/`** — 6,000 human preference pairs, each stored with the two tracker rollouts that were compared and the source-motion clip they track.
 
-The evaluation harness and HumanScore reward model live in the [HumanTracker repository](https://github.com/GalaxyGeneralRobotics/HumanTracker).
+The evaluation harness and HumanScore reward model live in the [HumanTracker repository](https://github.com/GalaxyGeneralRobotics/HumanTracker). `preference_pair/` is the reward model's training input as published: the rollouts are inline, so nothing has to be re-simulated to reproduce HumanScore.
 
 ## Dataset Details
 
@@ -41,7 +41,7 @@ Humanoid tracking is often scored with per-frame kinematic error, which misses t
 | Subset | Role | Size |
 | --- | --- | --- |
 | `motions/` | Tracker evaluation references (test split) | 2,500 clips |
-| `preference_pair/` | Human preference labels + source-motion clips | 6,000 pairs (4,800 / 1,200) |
+| `preference_pair/` | Human preference labels + the compared tracker rollouts | 6,000 pairs (4,800 / 1,200), 10 GB |
 
 Motions are retargeted to a 29-DoF Unitree G1-style humanoid with [GMR](https://arxiv.org/abs/2510.02252) and stored as `qpos` trajectories at 50 Hz. Preference pairs compare GMT, TWIST2, SONIC and Humanoid-GPT rollouts of the same reference window (typically 250 frames / 5 s). Labels are a strict preference, `similar`, or `bad_traj` (cannot compare). The pair split is grouped by `motion_id`, so every clip from one source motion stays in one partition.
 
@@ -63,8 +63,8 @@ HumanTracker/
   preference_pair/
     train.json
     test.json
-    train.parquet
-    test.parquet
+    train/train-00000-of-00020.parquet ... train-00019-of-00020.parquet
+    test/test-00000-of-00005.parquet  ... test-00004-of-00005.parquet
 ```
 
 Filenames are anonymized for release. Dates, performer names, capture-system tags and sample-rate suffixes are removed. Family-level names (`Daily`, `Interaction`, `HighlyDynamic`) are numbered (`Daily_1.npz`). Action labels that are themselves the motion type are kept: Ground actions such as `burpee` and `sit-lie`, and Highly Dynamic actions such as `Tennis` or named martial-arts skills.
@@ -134,7 +134,7 @@ row = ds["train"][0]
 print(row["choice_type"], row["tracker_pair_key"], row["motion_id"])
 ```
 
-Or read the parquet / manifests directly, which is what the reward-model trainer does (`train.json` / `test.json` list `record_id`s; annotations live in parquet):
+Or read the parquet shards directly, which is what the reward-model trainer does:
 
 ```python
 import io
@@ -142,15 +142,16 @@ import json
 import numpy as np
 import pyarrow.parquet as pq
 
-table = pq.read_table("preference_pair/train.parquet")
-row = table.to_pydict()
-idx = 0
-annotation = json.loads(row["annotation_json"][idx])
-motion = np.load(io.BytesIO(row["motion_npz"][idx]))
-qpos = motion["qpos"]  # (num_frames, 36), already sliced to the labeled window
-```
+table = pq.read_table("preference_pair/test/test-00000-of-00005.parquet")
+row = table.slice(0, 1).to_pylist()[0]
 
-`motion_npz` is a compressed NumPy archive with the **source-motion clip** for that pair (same keys as `motions/*.npz`). It is already sliced to `[source_start_frame, source_end_frame)`. Most windows are 250 frames (5 s at 50 Hz); shorter tail windows are kept and padded at training time.
+annotation = json.loads(row["annotation_json"])
+reference = np.load(io.BytesIO(row["motion_npz"]))        # same keys as motions/*.npz
+candidate_0 = np.load(io.BytesIO(row["candidate_0_npz"]))
+candidate_1 = np.load(io.BytesIO(row["candidate_1_npz"]))
+print(row["choice_type"], row["preferred_candidate_idx"], row["candidate_0_tracker"])
+print(candidate_0["joint_pos"].shape)                     # (num_frames, 29)
+```
 
 | Column | Description |
 | --- | --- |
@@ -158,14 +159,29 @@ qpos = motion["qpos"]  # (num_frames, 36), already sliced to the labeled window
 | `motion_id` | anonymized source-motion id (`Daily_12`, `burpee_3`, `Tennis_8`, …) |
 | `category` | motion family |
 | `tracker_pair_key` | unordered tracker pair, e.g. `gmt\|twist2` |
+| `candidate_0_tracker` / `candidate_1_tracker` | which tracker occupies each candidate slot |
 | `choice_type` | `preference` / `similar` / `bad_traj` |
 | `preferred_candidate_idx` | `0` or `1` when `choice_type == preference`, else null |
 | `source_start_frame` / `source_end_frame` | clip range in the original capture |
 | `num_frames` / `fps` | clip length and 50 Hz |
+| `candidate_0_npz` / `candidate_1_npz` | the two tracker rollouts (bytes, `np.savez_compressed`) |
 | `motion_npz` | source-motion clip (bytes, `np.savez_compressed`) |
-| `annotation_json` | full cleaned record (candidates, preference, flags) |
+| `annotation_json` | full cleaned record (candidates, preference, flags, annotator alias) |
+
+Candidate slots are stable identities, not display positions: `preferred_candidate_idx` indexes them, and the order the annotator saw is recorded separately in `annotation_json`. `motion_npz` carries the same keys as `motions/*.npz`, already sliced to `[source_start_frame, source_end_frame)`. Most windows are 250 frames (5 s at 50 Hz); shorter tail windows are kept and right-padded at training time.
+
+Each candidate NPZ is one tracker's closed-loop rollout of that window, frame-aligned with the reference, `float32`, `num_frames` rows per array:
+
+| Block | Arrays | Dims |
+| --- | --- | --- |
+| Reference the tracker was following | `ref_pose`, `ref_root_navi_vel`, `ref_joint_pos`, `ref_joint_vel`, `ref_foot_contact` | 70 |
+| Simulated rollout | `sensor_pose`, `imu_pose`, `action`, `motor_target`, `joint_pos`, `joint_vel`, `foot_contact`, `foot_force`, `foot_vel`, `foot_acc`, `linvel_pelvis`, `root_navi_vel`, `acu_root2gv_lin_vel`, `acu_root2gv_ang_vel`, `acu_kpt2gv_pose`, `acu_kpt_cvel_in_gv` | 469 |
+| Future-reference residuals | `next_ref2acu_gv_vel`, `next_ref2acu_kpt_pose`, `next_ref2acu_kpt_cvel` | 311 |
+| Rendering | `qpos`, `qvel` | 71 |
 
-`annotation_json` candidates name the two trackers and the clip window. They do not include raw rollout files; those remain in the training pipeline. HumanScore training in the code repository consumes tracker-rollout features plus this preference label. `bad_traj` pairs are excluded from the reported reward-model fit; `preference` uses a Bradley–Terry loss and `similar` a symmetric 0.5 target.
+The reported HumanScore model concatenates the first two blocks into a 539-d per-frame token; the residual block is shipped for the paper's appendix ablation and is unused by default. `qpos` / `qvel` are the MuJoCo generalized state, for replaying a rollout in the viewer.
+
+`train.json` and `test.json` list the `record_id`s of each split, grouped by `motion_id`. `train.json` also carries `model_selection`, the 461 records held out for epoch selection, so a rerun selects the same checkpoint as the published one. `bad_traj` pairs are excluded from the fit, leaving 5,757 trained pairs; `preference` uses a Bradley–Terry loss and `similar` a symmetric 0.5 target.
 
 | Split | Pairs | Source motions | preference / similar / bad_traj |
 | --- | --- | --- | --- |
@@ -175,10 +191,19 @@ qpos = motion["qpos"]  # (num_frames, 36), already sliced to the labeled window
 
 The six unordered tracker pairs (`gmt|hgpt`, `gmt|sonic`, `gmt|twist2`, `hgpt|sonic`, `hgpt|twist2`, `sonic|twist2`) are balanced at 1,000 pairs each.
 
+Training HumanScore from this directory:
+
+```bash
+python -m humantracker.reward_model.train.trainer \
+    --data_dir /path/to/HumanTracker/preference_pair \
+    --cache_dir /path/to/feature_cache \
+    --output_dir storage/checkpoints/reward_model
+```
+
 ## Uses
 
 - **Tracker evaluation.** Run a policy on `motions/` with the published evaluator and report Succ / MPJPE / HumanScore per family.
-- **Reward-model / HumanScore research.** Train or analyze pairwise preferences in `preference_pair/`, using `motion_npz` as the shared reference clip.
+- **Reward-model / HumanScore research.** Reproduce or extend HumanScore directly from `preference_pair/`; the [code repository](https://github.com/GalaxyGeneralRobotics/HumanTracker) reads this directory as its `--data_dir`.
 - **Diagnostics.** Family labels and retained action names (`burpee`, `Tennis`, …) support fine-grained error breakdowns.
 
 This release is **not** a full training-motion dump. The 2,500 evaluation clips are the official test split; preference clips are the labeled 5 s windows, not the complete source takes.