Reframe the caveat section: these clips do run on hardware; the numbers describe the reference trajectory
8061bcd verified | license: apache-2.0 | |
| task_categories: | |
| - robotics | |
| tags: | |
| - humanoid | |
| - motion-tracking | |
| - locomotion | |
| - ff-master | |
| - phc | |
| viewer: false | |
| # motionSample — FF Master motion references | |
| Joint-space motion references for the **FF Master** humanoid (31 DoF), stored in the | |
| **PHC-style pickle** format used by the humanoid motion-tracking codebase family | |
| (PHC / H2O / OmniH2O / ASAP / HumanoidVerse). | |
| Interactive viewer: **[Master Motion Sample Space](https://huggingface.co/spaces/faradayfuture/MotionSampleViewer)** | |
| | | | | |
| |---|---| | |
| | Clips | 2 (one file each) | | |
| | Frames | 2759 total | | |
| | FPS | 120 (inferred — see below) | | |
| | DoF | 31 | | |
| | Robot | FF Master (URDF `x2_ultra`) | | |
| **One file per clip** — they are not bundled together. `highjump` is trimmed to 5 consecutive | |
| jumps (source frames 654–1589 of a 21-jump take); `jogging` is the full take. | |
| | file | clip key | frames | duration | size | | |
| |---|---|---|---|---| | |
| | `jogging.pkl` | `jogging` | 1824 | 15.2 s | 1.3 MB | | |
| | `highjump.pkl` | `highjump` | 935 | 7.8 s | 0.7 MB | | |
| ## Loading | |
| Each file holds a `{clip_name: {...}}` dict with a single entry, so PHC-family loaders that | |
| expect a dict-of-motions read a single file without any code change. | |
| ```python | |
| import pickle | |
| d = pickle.load(open("highjump.pkl", "rb")) | |
| list(d) # ['highjump'] | |
| m = d["highjump"] | |
| m["dof"].shape # (935, 31) joint angles, rad | |
| m["root_trans_offset"].shape # (935, 3) base position, m | |
| m["root_rot"].shape # (935, 4) base orientation, xyzw | |
| m["fps"] # 120 | |
| ``` | |
| To use both at once, merge them: | |
| ```python | |
| import glob, pickle | |
| d = {} | |
| for f in sorted(glob.glob("*.pkl")): | |
| d.update(pickle.load(open(f, "rb"))) | |
| list(d) # ['highjump', 'jogging'] | |
| ``` | |
| ## Keys | |
| Key names are the **union** of what the PHC family reads. Each framework picks up the | |
| subset it knows; the extras are inert. | |
| | key | shape | read by | | |
| |---|---|---| | |
| | `root_trans_offset` | (T, 3) | all | | |
| | `root_rot` | (T, 4) **xyzw** | all | | |
| | `pose_aa` | (T, 1+31, 3) | PHC / H2O / OmniH2O | | |
| | `dof` | (T, 31) | all | | |
| | `fps` | int = 120 | all | | |
| | `dof_pos` | (T, 31), same array as `dof` | ASAP / HumanoidVerse | | |
| | `dof_vel` | (T, 31) | ASAP / HumanoidVerse | | |
| | `root_lin_vel` / `root_ang_vel` | (T, 3) | ASAP / HumanoidVerse | | |
| | `contacts` | (T, 2) left / right foot | — | | |
| | `com_pos` | (T, 3) whole-body centre of mass, world frame | — | | |
| | `total_mass` | float = 42.0 kg (from the URDF) | — | | |
| | `dof_names` / `body_names` | list | — | | |
| | `dof_axes` | (31, 3) | — | | |
| | `quat_order` | `"xyzw"` | — | | |
| ### `pose_aa` | |
| Per-body local rotation in axis-angle form, root first. For a 1-DoF revolute joint the | |
| local rotation is a turn of `q` about the URDF `axis`, so the axis-angle vector is just | |
| `axis * q`: | |
| ``` | |
| pose_aa[t, 0] = axis-angle of root_rot | |
| pose_aa[t, 1 + j] = dof_axes[j] * dof[t, j] | |
| ``` | |
| `dof_axes` ships with the file, so `pose_aa` can be rebuilt or cross-checked without the URDF. | |
| ### Conventions | |
| - **Quaternions are xyzw** (PHC / Isaac). MuJoCo and USD use wxyz — reorder when crossing over. | |
| - **z up, soles at z = 0.** Ground alignment uses the *stance-phase median* height, not a | |
| per-frame clamp (a per-frame clamp would flatten the high jump's flight phase). After | |
| alignment the stance-phase foot height IQR is within ±0.5 cm. | |
| - **Velocities are stored**, low-passed at 20 Hz zero-phase. Most loaders finite-difference | |
| them at load time instead, which yields noisier values than these — pick one and be consistent. | |
| ## Known characteristics and limits | |
| These clips are human motion capture retargeted onto the Master kinematics — no physics engine | |
| was involved in producing them. **They have been run on the real robot**: a whole-body | |
| motion-tracking controller follows them successfully on hardware. | |
| Everything below describes the **reference trajectory itself**, not what the robot can do. A | |
| tracking controller *approximates* a reference; it does not replay it frame-for-frame. So | |
| "the reference carries 0.72 g through flight" and "it runs on the real robot" are both true and | |
| not in conflict. Read this section before using a clip as a **per-frame** tracking target, or | |
| before assuming a number in it describes the machine. | |
| ### Flight-phase gravity is 0.72 g | |
| Fitting a parabola to the centre-of-mass height over the middle two thirds of each of | |
| `highjump`'s 5 flight phases gives a vertical acceleration of **−7.090 ± 0.057 m/s²**, not | |
| −9.807 — a consistent **0.723 g**. The spread across phases is 0.8 %, so this is systematic, | |
| not noise, and it is a property of the retargeted reference rather than of the robot. | |
| The likely cause is retargeting that rescaled the motion **spatially** to the robot's | |
| proportions while keeping the human's **original timing**. Froude similarity requires time to | |
| scale as √s when length scales by s; s = 0.723 implies the timeline should be compressed by | |
| √0.723, i.e. replayed at 120 × 1.176 ≈ **141 Hz**. That reading is self-consistent: s = 0.723 | |
| against the URDF's 0.602 m standing pelvis height implies a 0.833 m human pelvis, i.e. a | |
| subject about 1.57 m tall — a plausible capture subject. | |
| **This dataset ships at the source timing, un-retimed.** Retiming was tested and does fix the | |
| gravity (−9.843 ± 0.080 m/s², 0.37 % residual), but it pushes a few joints marginally past the | |
| URDF velocity limits (`jogging` 1/31 at 106 %, `highjump` 3/31 at 105 %) and raises the jogging | |
| cadence to 195 steps/min. To apply it yourself: resample the timeline by 1.176 and leave the | |
| joint angles untouched. | |
| ### `jogging`'s contact pattern is a walk, not a run | |
| Cadence is fine (166 steps/min) and swing clearance reaches 22 cm, but each foot is loaded | |
| **79 %** of the time, double support is **65.6 %**, and flight phases have a median of only | |
| **17 ms**. Real running has a duty factor below 0.5 and 100–200 ms of flight. Good enough as an | |
| AMP style prior; per-frame tracking will not teach running dynamics. | |
| `highjump`'s phase structure is sound: 73.8 % double support, 25.5 % airborne, 5 flight phases | |
| with a 400 ms median. | |
| ### Other limits | |
| - Residual ground penetration at the deepest frames: −1.9 cm (`jogging`), −3.6 cm (`highjump`). | |
| - **Base pose is not robot-measurable.** It comes from the capture system, so it is valid as an | |
| offline reference only — never as an observation the robot could produce on its own. | |
| - Joint angles are all within the URDF position limits, and joint velocities stay inside the | |
| URDF velocity limits (0/31 violations, peaking at 95 % of the limit). So the clips are | |
| **kinematically legal**; the trajectories are just not rigid-body-consistent on their own, | |
| which is normal for retargeted references and is what the tracking controller absorbs. | |
| ## Validation | |
| ```bash | |
| python3 validate.py # keys, shapes, quaternion norms, pose_aa round-trip, contact phases, | |
| # and flight-phase gravity computed from the shipped com_pos | |
| ``` | |
| ## Why 120 Hz | |
| The source files carry no sample rate. 120 Hz is inferred from `jogging`'s cadence: the knee | |
| angle's dominant period is 80–86 frames, which at 120 Hz is 166–180 steps/min — the normal | |
| jogging band. 60 Hz would give ~87 steps/min (a stroll) and 240 Hz ~340 (impossible). The | |
| gravity result above suggests the *dynamically* correct playback rate is ~141 Hz, so treat | |
| 120 Hz as the source timing rather than a physically validated one. | |